Add Sink::{left_sink, right_sink}

Author: cramertj

futures-sink/Cargo.toml

@@ -11,9 +11,10 @@ The asynchronous `Sink` trait for the futures-rs library.
 """
 
 [features]
-std = ["futures-core/std", "futures-channel/std"]
+std = ["either/use_std", "futures-core/std", "futures-channel/std"]
 default = ["std"]
 
 [dependencies]
+either = { version = "1.4", default-features = false, optional = true }
 futures-core = { path = "../futures-core", version = "0.2.0", default-features = false }
 futures-channel = { path = "../futures-channel", version = "0.2.0", default-features = false }

futures-sink/src/lib.rs

@@ -23,6 +23,48 @@ macro_rules! if_std {
 
 use futures_core::{Poll, task};
 
+#[cfg(feature = "either")]
+extern crate either;
+#[cfg(feature = "either")]
+use either::Either;
+#[cfg(feature = "either")]
+impl<A, B> Sink for Either<A, B>
+    where A: Sink,
+          B: Sink<SinkItem=<A as Sink>::SinkItem,
+                  SinkError=<A as Sink>::SinkError>
+{
+    type SinkItem = <A as Sink>::SinkItem;
+    type SinkError = <A as Sink>::SinkError;
+
+    fn poll_ready(&mut self, cx: &mut task::Context) -> Poll<(), Self::SinkError> {
+        match *self {
+            Either::Left(ref mut x) => x.poll_ready(cx),
+            Either::Right(ref mut x) => x.poll_ready(cx),
+        }
+    }
+
+    fn start_send(&mut self, item: Self::SinkItem) -> Result<(), Self::SinkError> {
+        match *self {
+            Either::Left(ref mut x) => x.start_send(item),
+            Either::Right(ref mut x) => x.start_send(item),
+        }
+    }
+
+    fn poll_flush(&mut self, cx: &mut task::Context) -> Poll<(), Self::SinkError> {
+        match *self {
+            Either::Left(ref mut x) => x.poll_flush(cx),
+            Either::Right(ref mut x) => x.poll_flush(cx),
+        }
+    }
+
+    fn poll_close(&mut self, cx: &mut task::Context) -> Poll<(), Self::SinkError> {
+        match *self {
+            Either::Left(ref mut x) => x.poll_close(cx),
+            Either::Right(ref mut x) => x.poll_close(cx),
+        }
+    }
+}
+
 if_std! {
     mod channel_impls;
 

futures-util/Cargo.toml

@@ -12,7 +12,7 @@ Common utilities and extension traits for the futures-rs library.
 
 [features]
 std = ["futures-core/std", "futures-io/std", "futures-sink/std", "either/use_std"]
-default = ["std", "futures-core/either"]
+default = ["std", "futures-core/either", "futures-sink/either"]
 bench = []
 
 [dependencies]

futures-util/src/sink/mod.rs

@@ -5,6 +5,7 @@
 
 use futures_core::{Stream, IntoFuture};
 use futures_sink::Sink;
+use super::future::Either;
 
 mod close;
 mod fanout;
@@ -219,4 +220,28 @@ pub trait SinkExt: Sink {
     {
         send_all::new(self, stream)
     }
+
+    /// Wrap this sink in an `Either` sink, making it the left-hand variant
+    /// of that `Either`.
+    ///
+    /// This can be used in combination with the `right_sink` method to write `if`
+    /// statements that evaluate to different streams in different branches.
+    fn left_sink<B>(self) -> Either<Self, B>
+        where B: Sink<SinkItem = Self::SinkItem, SinkError = Self::SinkError>,
+              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_sink` method to write `if`
+    /// statements that evaluate to different streams in different branches.
+    fn right_sink<B>(self) -> Either<B, Self>
+        where B: Sink<SinkItem = Self::SinkItem, SinkError = Self::SinkError>,
+              Self: Sized
+    {
+        Either::Right(self)
+    }
 }

futures/tests/sink.rs

@@ -18,6 +18,17 @@ use futures::sink::SinkErrInto;
 mod support;
 use support::*;
 
+#[test]
+fn either_sink() {
+    let mut s = if true {
+        Vec::<i32>::new().left_sink()
+    } else {
+        VecDeque::<i32>::new().right_sink()
+    };
+
+    s.start_send(0).unwrap();
+}
+
 #[test]
 fn vec_sink() {
     let mut v = Vec::new();