Adaptor .while_some()

src/adaptors.rs

@@ -880,6 +880,40 @@ impl<'a, I, F> Iterator for TakeWhileRef<'a, I, F> where
     }
 }
 
+/// An iterator adaptor that filters **Option\<A\>** iterator elements
+/// and produces **A**. Stops on the first **None** encountered.
+///
+/// See [*.while_some()*](trait.Itertools.html#method.while_some) for more information.
+#[derive(Clone)]
+pub struct WhileSome<I> {
+    iter: I,
+}
+
+impl<I> WhileSome<I> {
+    /// Create a new **WhileSome\<I\>**.
+    pub fn new(iter: I) -> Self {
+        WhileSome { iter: iter }
+    }
+}
+
+impl<I, A> Iterator for WhileSome<I> where
+    I: Iterator<Item=Option<A>>
+{
+    type Item = A;
+
+    fn next(&mut self) -> Option<A> {
+        match self.iter.next() {
+            None | Some(None) => None,
+            Some(elt) => elt,
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let sh = self.iter.size_hint();
+        (0, sh.1)
+    }
+}
+
 /// An iterator to iterate through all the combinations of pairs in a **Clone**-able iterator.
 ///
 /// See [*.combinations()*](trait.Itertools.html#method.combinations) for more information.

src/lib.rs

@@ -50,6 +50,7 @@ pub use adaptors::{
     Merge,
     MultiPeek,
     TakeWhileRef,
+    WhileSome,
     Coalesce,
     CoalesceFn,
     Combinations,
@@ -674,6 +675,16 @@ pub trait Itertools : Iterator {
         TakeWhileRef::new(self, f)
     }
 
+    /// Return an iterator adaptor that filters **Option\<A\>** iterator elements
+    /// and produces **A**. Stops on the first **None** encountered.
+    ///
+    /// Iterator element type is **A**, the unwrapped element.
+    fn while_some<A>(self) -> WhileSome<Self> where
+        Self: Sized + Iterator<Item=Option<A>>,
+    {
+        WhileSome::new(self)
+    }
+
     /// Return an iterator adaptor that iterates over the combinations of
     /// the elements from an iterator.
     ///

tests/tests.rs

@@ -594,3 +594,7 @@ fn pad_using() {
     let r: Vec<_> = v.into_iter().pad_using(1, |_| panic!()).collect();
     assert_eq!(r, vec![0, 1, 2]);
 }
+
+#[test]
+fn while_some() {
+}