Fix Ok(Poll) in documentation

Author: taiki-e

futures-channel/src/mpsc/mod.rs

@@ -548,11 +548,11 @@ impl<T> SenderInner<T> {
     ///
     /// This method returns:
     ///
-    /// - `Ok(Poll::Ready(_))` if there is sufficient capacity;
-    /// - `Ok(Poll::Pending)` if the channel may not have
+    /// - `Poll::Ready(Ok(_))` if there is sufficient capacity;
+    /// - `Poll::Pending` if the channel may not have
     ///   capacity, in which case the current task is queued to be notified once
     ///   capacity is available;
-    /// - `Err(SendError)` if the receiver has been dropped.
+    /// - `Poll::Ready(Err(SendError))` if the receiver has been dropped.
     fn poll_ready(
         &mut self,
         cx: &mut Context<'_>,
@@ -642,11 +642,11 @@ impl<T> Sender<T> {
     ///
     /// This method returns:
     ///
-    /// - `Ok(Poll::Ready(_))` if there is sufficient capacity;
-    /// - `Ok(Poll::Pending)` if the channel may not have
+    /// - `Poll::Ready(Ok(_))` if there is sufficient capacity;
+    /// - `Poll::Pending` if the channel may not have
     ///   capacity, in which case the current task is queued to be notified once
     ///   capacity is available;
-    /// - `Err(SendError)` if the receiver has been dropped.
+    /// - `Poll::Ready(Err(SendError))` if the receiver has been dropped.
     pub fn poll_ready(
         &mut self,
         cx: &mut Context<'_>,

futures-io/src/lib.rs

@@ -96,10 +96,10 @@ mod if_std {
 
         /// Attempt to read from the `AsyncRead` into `buf`.
         ///
-        /// On success, returns `Ok(Poll::Ready(num_bytes_read))`.
+        /// On success, returns `Poll::Ready(Ok(num_bytes_read))`.
         ///
         /// If no data is available for reading, the method returns
-        /// `Ok(Poll::Pending)` and arranges for the current task (via
+        /// `Poll::Pending` and arranges for the current task (via
         /// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes
         /// readable or is closed.
         ///
@@ -118,10 +118,10 @@ mod if_std {
         /// This method is similar to `poll_read`, but allows data to be read
         /// into multiple buffers using a single operation.
         ///
-        /// On success, returns `Ok(Poll::Ready(num_bytes_read))`.
+        /// On success, returns `Poll::Ready(Ok(num_bytes_read))`.
         ///
         /// If no data is available for reading, the method returns
-        /// `Ok(Poll::Pending)` and arranges for the current task (via
+        /// `Poll::Pending` and arranges for the current task (via
         /// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes
         /// readable or is closed.
         /// By default, this method delegates to using `poll_read` on the first
@@ -156,10 +156,10 @@ mod if_std {
     pub trait AsyncWrite {
         /// Attempt to write bytes from `buf` into the object.
         ///
-        /// On success, returns `Ok(Poll::Ready(num_bytes_written))`.
+        /// On success, returns `Poll::Ready(Ok(num_bytes_written))`.
         ///
         /// If the object is not ready for writing, the method returns
-        /// `Ok(Poll::Pending)` and arranges for the current task (via
+        /// `Poll::Pending` and arranges for the current task (via
         /// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes
         /// readable or is closed.
         ///
@@ -178,10 +178,10 @@ mod if_std {
         /// This method is similar to `poll_write`, but allows data from multiple buffers to be written
         /// using a single operation.
         ///
-        /// On success, returns `Ok(Poll::Ready(num_bytes_written))`.
+        /// On success, returns `Poll::Ready(Ok(num_bytes_written))`.
         ///
         /// If the object is not ready for writing, the method returns
-        /// `Ok(Poll::Pending)` and arranges for the current task (via
+        /// `Poll::Pending` and arranges for the current task (via
         /// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes
         /// readable or is closed.
         ///
@@ -209,10 +209,10 @@ mod if_std {
         /// Attempt to flush the object, ensuring that any buffered data reach
         /// their destination.
         ///
-        /// On success, returns `Ok(Poll::Ready(()))`.
+        /// On success, returns `Poll::Ready(Ok(()))`.
         ///
         /// If flushing cannot immediately complete, this method returns
-        /// `Ok(Poll::Pending)` and arranges for the current task (via
+        /// `Poll::Pending` and arranges for the current task (via
         /// `cx.waker().wake_by_ref()`) to receive a notification when the object can make
         /// progress towards flushing.
         ///
@@ -226,10 +226,10 @@ mod if_std {
 
         /// Attempt to close the object.
         ///
-        /// On success, returns `Ok(Poll::Ready(()))`.
+        /// On success, returns `Poll::Ready(Ok(()))`.
         ///
         /// If closing cannot immediately complete, this function returns
-        /// `Ok(Poll::Pending)` and arranges for the current task (via
+        /// `Poll::Pending` and arranges for the current task (via
         /// `cx.waker().wake_by_ref()`) to receive a notification when the object can make
         /// progress towards closing.
         ///

futures-sink/src/lib.rs

@@ -48,7 +48,7 @@ pub trait Sink<Item> {
 
     /// Attempts to prepare the `Sink` to receive a value.
     ///
-    /// This method must be called and return `Ok(Poll::Ready(()))` prior to
+    /// This method must be called and return `Poll::Ready(Ok(()))` prior to
     /// each call to `start_send`.
     ///
     /// This method returns `Poll::Ready` once the underlying sink is ready to
@@ -62,7 +62,7 @@ pub trait Sink<Item> {
 
     /// Begin the process of sending a value to the sink.
     /// Each call to this function must be proceeded by a successful call to
-    /// `poll_ready` which returned `Ok(Poll::Ready(()))`.
+    /// `poll_ready` which returned `Poll::Ready(Ok(()))`.
     ///
     /// As the name suggests, this method only *begins* the process of sending
     /// the item. If the sink employs buffering, the item isn't fully processed
@@ -84,11 +84,11 @@ pub trait Sink<Item> {
 
     /// Flush any remaining output from this sink.
     ///
-    /// Returns `Ok(Poll::Ready(()))` when no buffered items remain. If this
+    /// Returns `Poll::Ready(Ok(()))` when no buffered items remain. If this
     /// value is returned then it is guaranteed that all previous values sent
     /// via `start_send` have been flushed.
     ///
-    /// Returns `Ok(Poll::Pending)` if there is more work left to do, in which
+    /// Returns `Poll::Pending` if there is more work left to do, in which
     /// case the current task is scheduled (via `cx.waker().wake_by_ref()`) to wake up when
     /// `poll_flush` should be called again.
     ///
@@ -98,10 +98,10 @@ pub trait Sink<Item> {
 
     /// Flush any remaining output and close this sink, if necessary.
     ///
-    /// Returns `Ok(Poll::Ready(()))` when no buffered items remain and the sink
+    /// Returns `Poll::Ready(Ok(()))` when no buffered items remain and the sink
     /// has been successfully closed.
     ///
-    /// Returns `Ok(Poll::Pending)` if there is more work left to do, in which
+    /// Returns `Poll::Pending` if there is more work left to do, in which
     /// case the current task is scheduled (via `cx.waker().wake_by_ref()`) to wake up when
     /// `poll_close` should be called again.
     ///

futures-util/src/stream/futures_ordered.rs

@@ -101,7 +101,7 @@ impl<Fut: Future> FuturesOrdered<Fut> {
     /// Constructs a new, empty `FuturesOrdered`
     ///
     /// The returned `FuturesOrdered` does not contain any futures and, in this
-    /// state, `FuturesOrdered::poll` will return `Ok(Poll::Ready(None))`.
+    /// state, `FuturesOrdered::poll_next` will return `Poll::Ready(None)`.
     pub fn new() -> FuturesOrdered<Fut> {
         FuturesOrdered {
             in_progress_queue: FuturesUnordered::new(),

futures-util/src/stream/unfold.rs

@@ -15,12 +15,12 @@ use pin_utils::{unsafe_pinned, unsafe_unpinned};
 /// value `a`, and use `b` as the next internal state.
 ///
 /// If the closure returns `None` instead of `Some(Future)`, then the `unfold()`
-/// will stop producing items and return `Ok(Poll::Ready(None))` in future
+/// will stop producing items and return `Poll::Ready(None)` in future
 /// calls to `poll()`.
 ///
 /// In case of error generated by the returned `Future`, the error will be
 /// returned by the `Stream`.  The `Stream` will then yield
-/// `Ok(Poll::Ready(None))` in future calls to `poll()`.
+/// `Poll::Ready(None)` in future calls to `poll()`.
 ///
 /// This function can typically be used when wanting to go from the "world of
 /// futures" to the "world of streams": the provided closure can build a