Refactor FilterResults and FilterMapResults

Also remove calls to Result::transpose() to stay compatible to Rust
1.24.

src/adaptors/mod.rs

@@ -1161,25 +1161,21 @@ impl<I, F, T, E> Iterator for FilterResults<I, F>
         self.iter.size_hint()
     }
 
-    fn fold<Acc, Fold>(self, init: Acc, mut fold_f: Fold) -> Acc
+    fn fold<Acc, Fold>(self, init: Acc, fold_f: Fold) -> Acc
         where Fold: FnMut(Acc, Self::Item) -> Acc,
     {
         let mut f = self.f;
-        self.iter.fold(init, move |acc, v| {
-            if v.as_ref().map(&mut f).unwrap_or(true) {
-                fold_f(acc, v)
-            } else {
-                acc
-            }
-        })
+        self.iter.filter(|v| {
+            v.as_ref().map_or(true, &mut f)
+        }).fold(init, fold_f)
     }
 
     fn collect<C>(self) -> C
         where C: FromIterator<Self::Item>
     {
         let mut f = self.f;
-        self.iter.filter(move |v| {
-            v.as_ref().map(&mut f).unwrap_or(true)
+        self.iter.filter(|v| {
+            v.as_ref().map_or(true, &mut f)
         }).collect()
     }
 }
@@ -1193,6 +1189,14 @@ pub struct FilterMapResults<I, F> {
     f: F
 }
 
+fn transpose_result<T, E>(result: Result<Option<T>, E>) -> Option<Result<T, E>> {
+    match result {
+        Ok(Some(v)) => Some(Ok(v)),
+        Ok(None) => None,
+        Err(e) => Some(Err(e)),
+    }
+}
+
 /// Create a new `FilterResults` iterator.
 pub fn filter_map_results<I, F, T, U, E>(iter: I, f: F) -> FilterMapResults<I, F>
     where I: Iterator<Item = Result<T, E>>,
@@ -1228,24 +1232,22 @@ impl<I, F, T, U, E> Iterator for FilterMapResults<I, F>
         (0, self.iter.size_hint().1)
     }
 
-    fn fold<Acc, Fold>(self, init: Acc, mut fold_f: Fold) -> Acc
+    fn fold<Acc, Fold>(self, init: Acc, fold_f: Fold) -> Acc
         where Fold: FnMut(Acc, Self::Item) -> Acc,
     {
         let mut f = self.f;
-        self.iter.fold(init, move |acc, v| {
-            if let Some(v) = v.map(&mut f).transpose() {
-                fold_f(acc, v)
-            } else {
-                acc
-            }
-        })
+        self.iter.filter_map(|v| {
+            transpose_result(v.map(&mut f))
+        }).fold(init, fold_f)
     }
 
     fn collect<C>(self) -> C
         where C: FromIterator<Self::Item>
     {
         let mut f = self.f;
-        self.iter.filter_map(move |v| v.map(&mut f).transpose()).collect()
+        self.iter.filter_map(|v| {
+            transpose_result(v.map(&mut f))
+        }).collect()
     }
 }