Add TryStreamExt::try_filter

Author: svartalf

futures-util/src/try_stream/mod.rs

@@ -4,7 +4,7 @@
 //! that return `Result`s, allowing for short-circuiting computations.
 
 use core::pin::Pin;
-use futures_core::future::TryFuture;
+use futures_core::future::{Future, TryFuture};
 use futures_core::stream::TryStream;
 use futures_core::task::{Context, Poll};
 
@@ -35,6 +35,9 @@ pub use self::try_next::TryNext;
 mod try_for_each;
 pub use self::try_for_each::TryForEach;
 
+mod try_filter;
+pub use self::try_filter::TryFilter;
+
 mod try_filter_map;
 pub use self::try_filter_map::TryFilterMap;
 
@@ -60,8 +63,6 @@ cfg_target_has_atomic! {
     mod try_for_each_concurrent;
     #[cfg(feature = "alloc")]
     pub use self::try_for_each_concurrent::TryForEachConcurrent;
-    #[cfg(feature = "alloc")]
-    use futures_core::future::Future;
 }
 
 #[cfg(feature = "std")]
@@ -444,6 +445,46 @@ pub trait TryStreamExt: TryStream {
         TryCollect::new(self)
     }
 
+    /// Attempt to filter the values produced by this stream according to the
+    /// provided asynchronous closure.
+    ///
+    /// As values of this stream are made available, the provided predicate `f`
+    /// will be run on them. If the predicate returns a `Future` which resolves
+    /// to `true`, then the stream will yield the value, but if the predicate
+    /// return a `Future` which resolves to `false`, then the value will be
+    /// discarded and the next value will be produced.
+    ///
+    /// All errors are passed through without filtering in this combinator.
+    ///
+    /// Note that this function consumes the stream passed into it and returns a
+    /// wrapped version of it, similar to the existing `filter` methods in
+    /// the standard library.
+    ///
+    /// # Examples
+    /// ```
+    /// #![feature(async_await, await_macro)]
+    /// # futures::executor::block_on(async {
+    /// use futures::executor::block_on;
+    /// use futures::future;
+    /// use futures::stream::{self, StreamExt, TryStreamExt};
+    ///
+    /// let stream = stream::iter(vec![Ok(1i32), Ok(2i32), Ok(3i32), Err("error")]);
+    /// let mut evens = stream.try_filter(|x| {
+    ///     future::ready(x % 2 == 0)
+    /// });
+    ///
+    /// assert_eq!(await!(evens.next()), Some(Ok(2)));
+    /// assert_eq!(await!(evens.next()), Some(Err("error")));
+    /// # })
+    /// ```
+    fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F>
+        where Fut: Future<Output = bool>,
+              F: FnMut(&Self::Ok) -> Fut,
+              Self: Sized
+    {
+        TryFilter::new(self, f)
+    }
+
     /// Attempt to filter the values produced by this stream while
     /// simultaneously mapping them to a different type according to the
     /// provided asynchronous closure.

futures-util/src/try_stream/try_filter.rs

@@ -0,0 +1,128 @@
+use core::pin::Pin;
+use futures_core::future::Future;
+use futures_core::stream::{Stream, TryStream, FusedStream};
+use futures_core::task::{Context, Poll};
+use futures_sink::Sink;
+use pin_utils::{unsafe_pinned, unsafe_unpinned};
+
+/// Stream for the [`try_filter`](super::TryStreamExt::try_filter)
+/// method.
+#[derive(Debug)]
+#[must_use = "streams do nothing unless polled"]
+pub struct TryFilter<St, Fut, F>
+    where St: TryStream
+{
+    stream: St,
+    f: F,
+    pending_fut: Option<Fut>,
+    pending_item: Option<St::Ok>,
+}
+
+impl<St, Fut, F> Unpin for TryFilter<St, Fut, F>
+    where St: TryStream + Unpin, Fut: Unpin,
+{}
+
+impl<St, Fut, F> TryFilter<St, Fut, F>
+    where St: TryStream
+{
+    unsafe_pinned!(stream: St);
+    unsafe_unpinned!(f: F);
+    unsafe_pinned!(pending_fut: Option<Fut>);
+    unsafe_unpinned!(pending_item: Option<St::Ok>);
+
+    pub(super) fn new(stream: St, f: F) -> Self {
+        TryFilter {
+            stream,
+            f,
+            pending_fut: None,
+            pending_item: None,
+        }
+    }
+
+    /// Acquires a reference to the underlying stream that this combinator is
+    /// pulling from.
+    pub fn get_ref(&self) -> &St {
+        &self.stream
+    }
+
+    /// Acquires a mutable reference to the underlying stream that this
+    /// combinator is pulling from.
+    ///
+    /// Note that care must be taken to avoid tampering with the state of the
+    /// stream which may otherwise confuse this combinator.
+    pub fn get_mut(&mut self) -> &mut St {
+        &mut self.stream
+    }
+
+    /// Acquires a pinned mutable reference to the underlying stream that this
+    /// combinator is pulling from.
+    ///
+    /// Note that care must be taken to avoid tampering with the state of the
+    /// stream which may otherwise confuse this combinator.
+    pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut St> {
+        self.stream()
+    }
+
+    /// Consumes this combinator, returning the underlying stream.
+    ///
+    /// Note that this may discard intermediate state of this combinator, so
+    /// care should be taken to avoid losing resources when this is called.
+    pub fn into_inner(self) -> St {
+        self.stream
+    }
+}
+
+impl<St, Fut, F> FusedStream for TryFilter<St, Fut, F>
+    where St: TryStream + FusedStream,
+          F: FnMut(&St::Ok) -> Fut,
+          Fut: Future<Output = bool>,
+{
+    fn is_terminated(&self) -> bool {
+        self.pending_fut.is_none() && self.stream.is_terminated()
+    }
+}
+
+impl<St, Fut, F> Stream for TryFilter<St, Fut, F>
+    where St: TryStream,
+          Fut: Future<Output = bool>,
+          F: FnMut(&St::Ok) -> Fut,
+{
+    type Item = Result<St::Ok, St::Error>;
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<St::Ok, St::Error>>> {
+        loop {
+            if self.pending_fut.is_none() {
+                let item = match ready!(self.as_mut().stream().try_poll_next(cx)) {
+                    Some(Ok(x)) => x,
+                    Some(Err(e)) => return Poll::Ready(Some(Err(e))),
+                    None => return Poll::Ready(None),
+                };
+                let fut = (self.as_mut().f())(&item);
+                self.as_mut().pending_fut().set(Some(fut));
+                *self.as_mut().pending_item() = Some(item);
+            }
+
+            let yield_item = ready!(self.as_mut().pending_fut().as_pin_mut().unwrap().poll(cx));
+            self.as_mut().pending_fut().set(None);
+            let item = self.as_mut().pending_item().take().unwrap();
+
+            if yield_item {
+                return Poll::Ready(Some(Ok(item)));
+            }
+        }
+    }
+}
+
+// Forwarding impl of Sink from the underlying stream
+impl<S, Fut, F, Item> Sink<Item> for TryFilter<S, Fut, F>
+    where S: TryStream + Sink<Item>,
+          Fut: Future<Output = bool>,
+          F: FnMut(&S::Ok) -> Fut,
+{
+    type SinkError = S::SinkError;
+
+    delegate_sink!(stream, Item);
+}