1- package wasi : io @ 0.2.0 ;
1+ package wasi : io @ 0.2.1 ;
22
33/// WASI I/O is an I/O abstraction API which is currently focused on providing
44/// stream types.
55///
66/// In the future, the component model is expected to add built-in stream types;
77/// when it does, they are expected to subsume this API.
8+ @since (version = 0.2.0 )
89interface streams {
10+ @since (version = 0.2.0 )
911 use error . {error };
12+ @since (version = 0.2.0 )
1013 use poll . {pollable };
1114
1215 /// An error for input-stream and output-stream operations.
16+ @since (version = 0.2.0 )
1317 variant stream-error {
1418 /// The last operation (a write or flush) failed before completion.
1519 ///
@@ -29,6 +33,7 @@ interface streams {
2933 /// available, which could even be zero. To wait for data to be available,
3034 /// use the `subscribe` function to obtain a `pollable` which can be polled
3135 /// for using `wasi:io/poll` .
36+ @since (version = 0.2.0 )
3237 resource input-stream {
3338 /// Perform a non-blocking read from the stream.
3439 ///
@@ -56,13 +61,15 @@ interface streams {
5661 /// is not possible to allocate in wasm32, or not desirable to allocate as
5762 /// as a return value by the callee. The callee may return a list of bytes
5863 /// less than `len` in size while more bytes are available for reading.
64+ @since (version = 0.2.0 )
5965 read : func (
6066 /// The maximum number of bytes to read
6167 len : u64
6268 ) -> result <list <u8 >, stream-error >;
6369
6470 /// Read bytes from a stream, after blocking until at least one byte can
6571 /// be read. Except for blocking, behavior is identical to `read` .
72+ @since (version = 0.2.0 )
6673 blocking-read : func (
6774 /// The maximum number of bytes to read
6875 len : u64
@@ -72,13 +79,15 @@ interface streams {
7279 ///
7380 /// Behaves identical to `read` , except instead of returning a list
7481 /// of bytes, returns the number of bytes consumed from the stream.
82+ @since (version = 0.2.0 )
7583 skip : func (
7684 /// The maximum number of bytes to skip.
7785 len : u64 ,
7886 ) -> result <u64 , stream-error >;
7987
8088 /// Skip bytes from a stream, after blocking until at least one byte
8189 /// can be skipped. Except for blocking behavior, identical to `skip` .
90+ @since (version = 0.2.0 )
8291 blocking-skip : func (
8392 /// The maximum number of bytes to skip.
8493 len : u64 ,
@@ -90,6 +99,7 @@ interface streams {
9099 /// The created `pollable` is a child resource of the `input-stream` .
91100 /// Implementations may trap if the `input-stream` is dropped before
92101 /// all derived `pollable` s created with this function are dropped.
102+ @since (version = 0.2.0 )
93103 subscribe : func () -> pollable ;
94104 }
95105
@@ -102,6 +112,11 @@ interface streams {
102112 /// promptly, which could even be zero. To wait for the stream to be ready to
103113 /// accept data, the `subscribe` function to obtain a `pollable` which can be
104114 /// polled for using `wasi:io/poll` .
115+ ///
116+ /// Dropping an `output-stream` while there's still an active write in
117+ /// progress may result in the data being lost. Before dropping the stream,
118+ /// be sure to fully flush your writes.
119+ @since (version = 0.2.0 )
105120 resource output-stream {
106121 /// Check readiness for writing. This function never blocks.
107122 ///
@@ -112,6 +127,7 @@ interface streams {
112127 /// When this function returns 0 bytes, the `subscribe` pollable will
113128 /// become ready when this function will report at least 1 byte, or an
114129 /// error.
130+ @since (version = 0.2.0 )
115131 check-write : func () -> result <u64 , stream-error >;
116132
117133 /// Perform a write. This function never blocks.
@@ -127,6 +143,7 @@ interface streams {
127143 ///
128144 /// returns Err(closed) without writing if the stream has closed since
129145 /// the last call to check-write provided a permit.
146+ @since (version = 0.2.0 )
130147 write : func (
131148 contents : list <u8 >
132149 ) -> result <_ , stream-error >;
@@ -155,6 +172,7 @@ interface streams {
155172 /// // Check for any errors that arose during `flush`
156173 /// let _ = this.check-write(); // eliding error handling
157174 /// `` `
175+ @since (version = 0.2.0 )
158176 blocking-write-and-flush : func (
159177 contents : list <u8 >
160178 ) -> result <_ , stream-error >;
@@ -169,14 +187,16 @@ interface streams {
169187 /// writes (`check-write` will return `ok(0)` ) until the flush has
170188 /// completed. The `subscribe` pollable will become ready when the
171189 /// flush has completed and the stream can accept more writes.
190+ @since (version = 0.2.0 )
172191 flush : func () -> result <_ , stream-error >;
173192
174193 /// Request to flush buffered output, and block until flush completes
175194 /// and stream is ready for writing again.
195+ @since (version = 0.2.0 )
176196 blocking-flush : func () -> result <_ , stream-error >;
177197
178198 /// Create a `pollable` which will resolve once the output-stream
179- /// is ready for more writing, or an error has occured . When this
199+ /// is ready for more writing, or an error has occurred . When this
180200 /// pollable is ready, `check-write` will return `ok(n)` with n>0, or an
181201 /// error.
182202 ///
@@ -193,6 +213,7 @@ interface streams {
193213 /// preconditions (must use check-write first), but instead of
194214 /// passing a list of bytes, you simply pass the number of zero-bytes
195215 /// that should be written.
216+ @since (version = 0.2.0 )
196217 write-zeroes : func (
197218 /// The number of zero-bytes to write
198219 len : u64
@@ -222,14 +243,15 @@ interface streams {
222243 /// // Check for any errors that arose during `flush`
223244 /// let _ = this.check-write(); // eliding error handling
224245 /// `` `
246+ @since (version = 0.2.0 )
225247 blocking-write-zeroes-and-flush : func (
226248 /// The number of zero-bytes to write
227249 len : u64
228250 ) -> result <_ , stream-error >;
229251
230252 /// Read from one stream and write to another.
231253 ///
232- /// The behavior of splice is equivelant to:
254+ /// The behavior of splice is equivalent to:
233255 /// 1. calling `check-write` on the `output-stream`
234256 /// 2. calling `read` on the `input-stream` with the smaller of the
235257 /// `check-write` permitted length and the `len` provided to `splice`
@@ -240,6 +262,7 @@ interface streams {
240262 ///
241263 /// This function returns the number of bytes transferred; it may be less
242264 /// than `len` .
265+ @since (version = 0.2.0 )
243266 splice : func (
244267 /// The stream to read from
245268 src : borrow <input-stream >,
@@ -252,6 +275,7 @@ interface streams {
252275 /// This is similar to `splice` , except that it blocks until the
253276 /// `output-stream` is ready for writing, and the `input-stream`
254277 /// is ready for reading, before performing the `splice` .
278+ @since (version = 0.2.0 )
255279 blocking-splice : func (
256280 /// The stream to read from
257281 src : borrow <input-stream >,
0 commit comments