Merge #221

221: adds stream::filter combinator r=stjepang a=montekki

Ref: #129 
Stdlib: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter

Co-authored-by: Fedor Sakharov <fedor.sakharov@gmail.com>

src/stream/stream/filter.rs

@@ -0,0 +1,49 @@
+use std::marker::PhantomData;
+use std::pin::Pin;
+
+use crate::stream::Stream;
+use crate::task::{Context, Poll};
+
+/// A stream to filter elements of another stream with a predicate.
+#[derive(Debug)]
+pub struct Filter<S, P, T> {
+    stream: S,
+    predicate: P,
+    __t: PhantomData<T>,
+}
+
+impl<S, P, T> Filter<S, P, T> {
+    pin_utils::unsafe_pinned!(stream: S);
+    pin_utils::unsafe_unpinned!(predicate: P);
+
+    pub(super) fn new(stream: S, predicate: P) -> Self {
+        Filter {
+            stream,
+            predicate,
+            __t: PhantomData,
+        }
+    }
+}
+
+impl<S, P> futures_core::stream::Stream for Filter<S, P, S::Item>
+where
+    S: Stream,
+    P: FnMut(&S::Item) -> bool,
+{
+    type Item = S::Item;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let next = futures_core::ready!(self.as_mut().stream().poll_next(cx));
+
+        match next {
+            Some(v) => match (self.as_mut().predicate())(&v) {
+                true => Poll::Ready(Some(v)),
+                false => {
+                    cx.waker().wake_by_ref();
+                    Poll::Pending
+                }
+            },
+            None => Poll::Ready(None),
+        }
+    }
+}

src/stream/stream/mod.rs

@@ -24,6 +24,7 @@
 mod all;
 mod any;
 mod enumerate;
+mod filter;
 mod filter_map;
 mod find;
 mod find_map;
@@ -37,6 +38,7 @@ mod skip;
 mod take;
 mod zip;
 
+pub use filter::Filter;
 pub use fuse::Fuse;
 pub use scan::Scan;
 pub use skip::Skip;
@@ -284,6 +286,34 @@ pub trait Stream {
             done: false,
         }
     }
+    /// Creates a stream that uses a predicate to determine if an element
+    /// should be yeilded.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    ///```
+    /// # fn main() { async_std::task::block_on(async {
+    /// #
+    /// use std::collections::VecDeque;
+    /// use async_std::stream::Stream;
+    ///
+    /// let s: VecDeque<usize> = vec![1, 2, 3, 4].into_iter().collect();
+    /// let mut s = s.filter(|i| i % 2 == 0);
+    ///
+    /// assert_eq!(s.next().await, Some(2));
+    /// assert_eq!(s.next().await, Some(4));
+    /// assert_eq!(s.next().await, None);
+    /// #
+    /// # }) }
+    fn filter<P>(self, predicate: P) -> Filter<Self, P, Self::Item>
+    where
+        Self: Sized,
+        P: FnMut(&Self::Item) -> bool,
+    {
+        Filter::new(self, predicate)
+    }
 
     /// Both filters and maps a stream.
     ///