Merge pull request #1106 from MajorBreakfast/try-refactor

Refactor `TryFuture` combinators

Author: MajorBreakfast

futures-util/src/try_future/and_then.rs

@@ -20,9 +20,9 @@ impl<Fut1, Fut2, F> AndThen<Fut1, Fut2, F>
     unsafe_pinned!(try_chain: TryChain<Fut1, Fut2, F>);
 
     /// Creates a new `Then`.
-    pub(super) fn new(future: Fut1, async_op: F) -> AndThen<Fut1, Fut2, F> {
+    pub(super) fn new(future: Fut1, f: F) -> AndThen<Fut1, Fut2, F> {
         AndThen {
-            try_chain: TryChain::new(future, async_op),
+            try_chain: TryChain::new(future, f),
         }
     }
 }

futures-util/src/try_future/err_into.rs

@@ -8,29 +8,32 @@ use futures_core::task::{self, Poll};
 /// This is created by the `Future::err_into` method.
 #[derive(Debug)]
 #[must_use = "futures do nothing unless polled"]
-pub struct ErrInto<A, E> {
-    future: A,
+pub struct ErrInto<Fut, E> {
+    future: Fut,
     _marker: PhantomData<E>,
 }
 
-impl<A, E> ErrInto<A, E> {
-    unsafe_pinned!(future: A);
-}
+impl<Fut, E> ErrInto<Fut, E> {
+    unsafe_pinned!(future: Fut);
 
-pub fn new<A, E>(future: A) -> ErrInto<A, E> {
-    ErrInto {
-        future,
-        _marker: PhantomData,
+    pub(super) fn new(future: Fut) -> ErrInto<Fut, E> {
+        ErrInto {
+            future,
+            _marker: PhantomData,
+        }
     }
 }
 
-impl<A, E> Future for ErrInto<A, E>
-    where A: TryFuture,
-          A::Error: Into<E>,
+impl<Fut, E> Future for ErrInto<Fut, E>
+    where Fut: TryFuture,
+          Fut::Error: Into<E>,
 {
-    type Output = Result<A::Ok, E>;
+    type Output = Result<Fut::Ok, E>;
 
-    fn poll(mut self: PinMut<Self>, cx: &mut task::Context) -> Poll<Self::Output> {
+    fn poll(
+        mut self: PinMut<Self>,
+        cx: &mut task::Context,
+    ) -> Poll<Self::Output> {
         match self.future().try_poll(cx) {
             Poll::Pending => Poll::Pending,
             Poll::Ready(output) => {

futures-util/src/try_future/flatten_sink.rs

@@ -5,9 +5,9 @@ use futures_core::task::{self, Poll};
 use futures_sink::Sink;
 
 #[derive(Debug)]
-enum State<F, S> {
-    Waiting(F),
-    Ready(S),
+enum State<Fut, Si> {
+    Waiting(Fut),
+    Ready(Si),
     Closed,
 }
 use self::State::*;
@@ -17,14 +17,22 @@ use self::State::*;
 ///
 /// This is created by the `Future::flatten_sink` method.
 #[derive(Debug)]
-pub struct FlattenSink<F, S>(State<F, S>);
+pub struct FlattenSink<Fut, Si>(State<Fut, Si>);
 
-impl<F: Unpin, S: Unpin> Unpin for FlattenSink<F, S> {}
+impl<Fut: Unpin, Si: Unpin> Unpin for FlattenSink<Fut, Si> {}
+
+impl<Fut, Si> FlattenSink<Fut, Si>
+where
+    Fut: TryFuture<Ok = Si>,
+    Si: Sink<SinkError = Fut::Error>,
+{
+    pub(super) fn new(future: Fut) -> FlattenSink<Fut, Si> {
+        FlattenSink(Waiting(future))
+    }
 
-impl<F, S> FlattenSink<F, S> {
     fn project_pin<'a>(
         self: PinMut<'a, Self>
-    ) -> State<PinMut<'a, F>, PinMut<'a, S>> {
+    ) -> State<PinMut<'a, Fut>, PinMut<'a, Si>> {
         unsafe {
             match &mut PinMut::get_mut_unchecked(self).0 {
                 Waiting(f) => Waiting(PinMut::new_unchecked(f)),
@@ -35,17 +43,18 @@ impl<F, S> FlattenSink<F, S> {
     }
 }
 
-impl<F, S> Sink for FlattenSink<F, S>
+impl<Fut, Si> Sink for FlattenSink<Fut, Si>
 where
-    F: TryFuture<Ok = S>,
-    S: Sink<SinkError = F::Error>,
+    Fut: TryFuture<Ok = Si>,
+    Si: Sink<SinkError = Fut::Error>,
 {
-    type SinkItem = S::SinkItem;
-    type SinkError = S::SinkError;
+    type SinkItem = Si::SinkItem;
+    type SinkError = Si::SinkError;
 
-    fn poll_ready(mut self: PinMut<Self>, cx: &mut task::Context)
-        -> Poll<Result<(), Self::SinkError>>
-    {
+    fn poll_ready(
+        mut self: PinMut<Self>,
+        cx: &mut task::Context,
+    ) -> Poll<Result<(), Self::SinkError>> {
         let resolved_stream = match self.reborrow().project_pin() {
             Ready(s) => return s.poll_ready(cx),
             Waiting(f) => try_ready!(f.try_poll(cx)),
@@ -59,19 +68,21 @@ where
         }
     }
 
-    fn start_send(self: PinMut<Self>, item: Self::SinkItem)
-        -> Result<(), Self::SinkError>
-    {
+    fn start_send(
+        self: PinMut<Self>,
+        item: Self::SinkItem,
+    ) -> Result<(), Self::SinkError> {
         match self.project_pin() {
             Ready(s) => s.start_send(item),
             Waiting(_) => panic!("poll_ready not called first"),
             Closed => panic!("start_send called after eof"),
         }
     }
 
-    fn poll_flush(self: PinMut<Self>, cx: &mut task::Context)
-        -> Poll<Result<(), Self::SinkError>>
-    {
+    fn poll_flush(
+        self: PinMut<Self>,
+        cx: &mut task::Context,
+    ) -> Poll<Result<(), Self::SinkError>> {
         match self.project_pin() {
             Ready(s) => s.poll_flush(cx),
             // if sink not yet resolved, nothing written ==> everything flushed
@@ -80,9 +91,10 @@ where
         }
     }
 
-    fn poll_close(mut self: PinMut<Self>, cx: &mut task::Context)
-        -> Poll<Result<(), Self::SinkError>>
-    {
+    fn poll_close(
+        mut self: PinMut<Self>,
+        cx: &mut task::Context,
+    ) -> Poll<Result<(), Self::SinkError>> {
         let res = match self.reborrow().project_pin() {
             Ready(s) => s.poll_close(cx),
             Waiting(_) | Closed => Poll::Ready(Ok(())),
@@ -93,11 +105,3 @@ where
         res
     }
 }
-
-pub fn new<F, S>(fut: F) -> FlattenSink<F, S>
-where
-    F: TryFuture<Ok = S>,
-    S: Sink<SinkError = F::Error>,
-{
-    FlattenSink(Waiting(fut))
-}

futures-util/src/try_future/into_future.rs

@@ -22,7 +22,10 @@ impl<Fut: TryFuture> Future for IntoFuture<Fut> {
     type Output = Result<Fut::Ok, Fut::Error>;
 
     #[inline]
-    fn poll(mut self: PinMut<Self>, cx: &mut task::Context) -> Poll<Self::Output> {
+    fn poll(
+        mut self: PinMut<Self>,
+        cx: &mut task::Context,
+    ) -> Poll<Self::Output> {
         self.future().try_poll(cx)
     }
 }

futures-util/src/try_future/map_err.rs

@@ -10,16 +10,16 @@ use futures_core::task::{self, Poll};
 #[must_use = "futures do nothing unless polled"]
 pub struct MapErr<Fut, F> {
     future: Fut,
-    op: Option<F>,
+    f: Option<F>,
 }
 
 impl<Fut, F> MapErr<Fut, F> {
     unsafe_pinned!(future: Fut);
-    unsafe_unpinned!(op: Option<F>);
+    unsafe_unpinned!(f: Option<F>);
 
     /// Creates a new MapErr.
-    pub(super) fn new(future: Fut, op: F) -> MapErr<Fut, F> {
-        MapErr { future, op: Some(op) }
+    pub(super) fn new(future: Fut, f: F) -> MapErr<Fut, F> {
+        MapErr { future, f: Some(f) }
     }
 }
 
@@ -31,13 +31,16 @@ impl<Fut, F, E> Future for MapErr<Fut, F>
 {
     type Output = Result<Fut::Ok, E>;
 
-    fn poll(mut self: PinMut<Self>, cx: &mut task::Context) -> Poll<Self::Output> {
+    fn poll(
+        mut self: PinMut<Self>,
+        cx: &mut task::Context,
+    ) -> Poll<Self::Output> {
         match self.future().try_poll(cx) {
             Poll::Pending => Poll::Pending,
             Poll::Ready(result) => {
-                let op = self.op().take()
+                let f = self.f().take()
                     .expect("MapErr must not be polled after it returned `Poll::Ready`");
-                Poll::Ready(result.map_err(op))
+                Poll::Ready(result.map_err(f))
             }
         }
     }

futures-util/src/try_future/map_ok.rs

@@ -10,16 +10,16 @@ use futures_core::task::{self, Poll};
 #[must_use = "futures do nothing unless polled"]
 pub struct MapOk<Fut, F> {
     future: Fut,
-    op: Option<F>,
+    f: Option<F>,
 }
 
 impl<Fut, F> MapOk<Fut, F> {
     unsafe_pinned!(future: Fut);
-    unsafe_unpinned!(op: Option<F>);
+    unsafe_unpinned!(f: Option<F>);
 
     /// Creates a new MapOk.
-    pub(super) fn new(future: Fut, op: F) -> MapOk<Fut, F> {
-        MapOk { future, op: Some(op) }
+    pub(super) fn new(future: Fut, f: F) -> MapOk<Fut, F> {
+        MapOk { future, f: Some(f) }
     }
 }
 
@@ -31,11 +31,14 @@ impl<Fut, F, T> Future for MapOk<Fut, F>
 {
     type Output = Result<T, Fut::Error>;
 
-    fn poll(mut self: PinMut<Self>, cx: &mut task::Context) -> Poll<Self::Output> {
+    fn poll(
+        mut self: PinMut<Self>,
+        cx: &mut task::Context,
+    ) -> Poll<Self::Output> {
         match self.future().try_poll(cx) {
             Poll::Pending => Poll::Pending,
             Poll::Ready(result) => {
-                let op = self.op().take()
+                let op = self.f().take()
                     .expect("MapOk must not be polled after it returned `Poll::Ready`");
                 Poll::Ready(result.map(op))
             }

futures-util/src/try_future/mod.rs

@@ -66,10 +66,10 @@ pub trait TryFutureExt: TryFuture {
     /// version of it.
     fn flatten_sink(self) -> FlattenSink<Self, Self::Ok>
     where
-        Self::Ok: Sink<SinkError=Self::Error>,
+        Self::Ok: Sink<SinkError = Self::Error>,
         Self: Sized,
     {
-        flatten_sink::new(self)
+        FlattenSink::new(self)
     }
 
     /// Map this future's result to a different type, returning a new future of
@@ -112,11 +112,11 @@ pub trait TryFutureExt: TryFuture {
     /// let new_future = future.map_ok(|x| x + 3);
     /// assert_eq!(block_on(new_future), Err(1));
     /// ```
-    fn map_ok<T, F>(self, op: F) -> MapOk<Self, F>
+    fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>
         where F: FnOnce(Self::Ok) -> T,
               Self: Sized,
     {
-        MapOk::new(self, op)
+        MapOk::new(self, f)
     }
 
     /// Map this future's error to a different error, returning a new future.
@@ -158,11 +158,11 @@ pub trait TryFutureExt: TryFuture {
     /// let new_future = future.map_err(|x| x + 3);
     /// assert_eq!(block_on(new_future), Ok(1));
     /// ```
-    fn map_err<E, F>(self, op: F) -> MapErr<Self, F>
+    fn map_err<E, F>(self, f: F) -> MapErr<Self, F>
         where F: FnOnce(Self::Error) -> E,
               Self: Sized,
     {
-        MapErr::new(self, op)
+        MapErr::new(self, f)
     }
 
     /// Map this future's error to a new error type using the `Into` trait.
@@ -190,7 +190,7 @@ pub trait TryFutureExt: TryFuture {
         where Self: Sized,
               Self::Error: Into<E>
     {
-        err_into::new(self)
+        ErrInto::new(self)
     }
 
     /// Execute another future after this one has resolved successfully.
@@ -227,12 +227,12 @@ pub trait TryFutureExt: TryFuture {
     ///     panic!("should not be called in case of an error");
     /// });
     /// ```
-    fn and_then<Fut, F>(self, async_op: F) -> AndThen<Self, Fut, F>
+    fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>
         where F: FnOnce(Self::Ok) -> Fut,
               Fut: TryFuture<Error = Self::Error>,
               Self: Sized,
     {
-        AndThen::new(self, async_op)
+        AndThen::new(self, f)
     }
 
     /// Execute another future if this one resolves with an error.
@@ -269,12 +269,12 @@ pub trait TryFutureExt: TryFuture {
     ///     panic!("should not be called in case of success");
     /// });
     /// ```
-    fn or_else<Fut, F>(self, async_op: F) -> OrElse<Self, Fut, F>
+    fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>
         where F: FnOnce(Self::Error) -> Fut,
               Fut: TryFuture<Ok = Self::Ok>,
               Self: Sized,
     {
-        OrElse::new(self, async_op)
+        OrElse::new(self, f)
     }
 
     /* TODO
@@ -427,11 +427,11 @@ pub trait TryFutureExt: TryFuture {
     /// let new_future = future.unwrap_or_else(|_| ());
     /// assert_eq!(block_on(new_future), ());
     /// ```
-    fn unwrap_or_else<F>(self, op: F) -> UnwrapOrElse<Self, F>
+    fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F>
         where Self: Sized,
               F: FnOnce(Self::Error) -> Self::Ok
     {
-        UnwrapOrElse::new(self, op)
+        UnwrapOrElse::new(self, f)
     }
 
     /// Wraps a `TryFuture` so that it implements `Future`. `TryFuture`s

futures-util/src/try_future/or_else.rs

@@ -20,9 +20,9 @@ impl<Fut1, Fut2, F> OrElse<Fut1, Fut2, F>
     unsafe_pinned!(try_chain: TryChain<Fut1, Fut2, F>);
 
     /// Creates a new `Then`.
-    pub(super) fn new(future: Fut1, async_op: F) -> OrElse<Fut1, Fut2, F> {
+    pub(super) fn new(future: Fut1, f: F) -> OrElse<Fut1, Fut2, F> {
         OrElse {
-            try_chain: TryChain::new(future, async_op),
+            try_chain: TryChain::new(future, f),
         }
     }
 }
@@ -34,7 +34,10 @@ impl<Fut1, Fut2, F> Future for OrElse<Fut1, Fut2, F>
 {
     type Output = Result<Fut2::Ok, Fut2::Error>;
 
-    fn poll(mut self: PinMut<Self>, cx: &mut task::Context) -> Poll<Self::Output> {
+    fn poll(
+        mut self: PinMut<Self>,
+        cx: &mut task::Context,
+    ) -> Poll<Self::Output> {
         self.try_chain().poll(cx, |result, async_op| {
             match result {
                 Ok(ok) => TryChainAction::Output(Ok(ok)),