Deprecate and rename FutureExt::{left, right}

Author: cramertj

futures-util/src/future/mod.rs

@@ -509,17 +509,49 @@ pub trait FutureExt: Future {
     /// assert_eq!(x, block_on(future).unwrap());
     /// # }
     /// ```
+    #[deprecated(note = "use `left_future` instead")]
     fn left<B>(self) -> Either<Self, B>
         where B: Future<Item = Self::Item, Error = Self::Error>,
               Self: Sized
     {
         Either::Left(self)
     }
 
+    /// Wrap this future in an `Either` future, making it the left-hand variant
+    /// of that `Either`.
+    ///
+    /// This can be used in combination with the `right_future` method to write `if`
+    /// statements that evaluate to different futures in different branches.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # extern crate futures;
+    /// use futures::executor::block_on;
+    /// use futures::future::*;
+    ///
+    /// # fn main() {
+    /// let x = 6;
+    /// let future = if x < 10 {
+    ///     ok::<_, bool>(x).left_future()
+    /// } else {
+    ///     empty().right_future()
+    /// };
+    ///
+    /// assert_eq!(x, block_on(future).unwrap());
+    /// # }
+    /// ```
+    fn left_future<B>(self) -> Either<Self, B>
+        where B: Future<Item = Self::Item, Error = Self::Error>,
+              Self: Sized
+    {
+        Either::Left(self)
+    }
+
     /// Wrap this future in an `Either` future, making it the right-hand variant
     /// of that `Either`.
     ///
-    /// This can be used in combination with the `left` method to write `if`
+    /// This can be used in combination with the `left_future` method to write `if`
     /// statements that evaluate to different futures in different branches.
     ///
     /// # Examples
@@ -540,13 +572,45 @@ pub trait FutureExt: Future {
     /// assert_eq!(x, block_on(future).unwrap());
     /// # }
     /// ```
+    #[deprecated(note = "use `right_future` instead")]
     fn right<A>(self) -> Either<A, Self>
         where A: Future<Item = Self::Item, Error = Self::Error>,
               Self: Sized,
     {
         Either::Right(self)
     }
 
+    /// Wrap this future in an `Either` future, making it the right-hand variant
+    /// of that `Either`.
+    ///
+    /// This can be used in combination with the `left_future` method to write `if`
+    /// statements that evaluate to different futures in different branches.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # extern crate futures;
+    /// use futures::executor::block_on;
+    /// use futures::future::*;
+    ///
+    /// # fn main() {
+    /// let x = 6;
+    /// let future = if x < 10 {
+    ///     ok::<_, bool>(x).left_future()
+    /// } else {
+    ///     empty().right_future()
+    /// };
+    ///
+    /// assert_eq!(x, block_on(future).unwrap());
+    /// # }
+    /// ```
+    fn right_future<A>(self) -> Either<A, Self>
+        where A: Future<Item = Self::Item, Error = Self::Error>,
+              Self: Sized,
+    {
+        Either::Right(self)
+    }
+
     /// Convert this future into a single element stream.
     ///
     /// The returned stream contains single success if this future resolves to

futures-util/src/stream/mod.rs

@@ -962,12 +962,12 @@ pub trait StreamExt: Stream {
         recover::new(self, f)
     }
 
-
     /// Wrap this stream in an `Either` stream, making it the left-hand variant
     /// of that `Either`.
     ///
     /// This can be used in combination with the `right` method to write `if`
     /// statements that evaluate to different streams in different branches.
+    #[deprecated(note = "use `left_stream` instead")]
     fn left<B>(self) -> Either<Self, B>
         where B: Stream<Item = Self::Item, Error = Self::Error>,
               Self: Sized
@@ -980,10 +980,35 @@ pub trait StreamExt: Stream {
     ///
     /// This can be used in combination with the `left` method to write `if`
     /// statements that evaluate to different streams in different branches.
+    #[deprecated(note = "use `right_stream` instead")]
     fn right<B>(self) -> Either<B, Self>
         where B: Stream<Item = Self::Item, Error = Self::Error>,
               Self: Sized
     {
         Either::Right(self)
     }
+
+    /// Wrap this stream in an `Either` stream, making it the left-hand variant
+    /// of that `Either`.
+    ///
+    /// This can be used in combination with the `right_stream` method to write `if`
+    /// statements that evaluate to different streams in different branches.
+    fn left_stream<B>(self) -> Either<Self, B>
+        where B: Stream<Item = Self::Item, Error = Self::Error>,
+              Self: Sized
+    {
+        Either::Left(self)
+    }
+
+    /// Wrap this stream in an `Either` stream, making it the right-hand variant
+    /// of that `Either`.
+    ///
+    /// This can be used in combination with the `left_stream` method to write `if`
+    /// statements that evaluate to different streams in different branches.
+    fn right_stream<B>(self) -> Either<B, Self>
+        where B: Stream<Item = Self::Item, Error = Self::Error>,
+              Self: Sized
+    {
+        Either::Right(self)
+    }
 }