Specialize consume_iter for simple std::iter-like consumers

These consumers all exist as std::iter adaptors too (except for
`update`, but that one is very simple), and so we can specialize
`consume_iter` to call them, to potentially benefit from any internal
iteration optimizations they have.

Part of rayon-rs#465.

The following example gets 8x faster (1.6s before, 0.2s after), on
a 6 core (12 threads) machine:

```

extern crate test;
extern crate rayon;
use rayon::prelude::*;

fn main() {
    let count = (0..std::u32::MAX).into_par_iter().map(test::black_box).count();
    println!("{}", count);
}
```

For the built-in benchmarks, there doesn't seem to be any true
slow-downs (some benchmarks are so variable that it's very hard to
accurately determine the change), and a lot of speed-ups. This affects
the `find` and `collect` benchmarks the most:

```
 name                                find-old.txt ns/iter  find-new.txt ns/iter  diff ns/iter   diff %  speedup
 find::size1::parallel_find_first    19,329                20,003                         674    3.49%   x 0.97
 find::size1::parallel_find_common   24,328                23,183                      -1,145   -4.71%   x 1.05
 find::size1::parallel_find_missing  2,131,717             1,687,769                 -443,948  -20.83%   x 1.26
 find::size1::parallel_find_last     1,606,984             1,201,934                 -405,050  -25.21%   x 1.34
 find::size1::parallel_find_middle   1,242,411             819,751                   -422,660  -34.02%   x 1.52
```

```
 name                                                                collect-old.txt ns/iter  collect-new.txt ns/iter  diff ns/iter   diff %  speedup
 map_collect::i_to_i::with_mutex_vec                                 30,813,044               31,650,037                    836,993    2.72%   x 0.97
 map_collect::i_to_i::with_linked_list_collect_vec_sized             12,769,089               13,077,052                    307,963    2.41%   x 0.98
 map_collect::i_mod_10_to_i::with_mutex_vec                          8,222,478                8,316,029                      93,551    1.14%   x 0.99
 map_collect::i_to_i::with_fold                                      49,522,357               49,662,761                    140,404    0.28%   x 1.00
 map_collect::i_to_i::with_linked_list_collect                       31,901,399               31,558,372                   -343,027   -1.08%   x 1.01
 map_collect::i_mod_10_to_i::with_linked_list_collect                21,974,395               21,622,942                   -351,453   -1.60%   x 1.02
 vec_collect::vec_i::with_fold                                       35,716,513               34,863,214                   -853,299   -2.39%   x 1.02
 map_collect::i_to_i::with_fold_vec                                  51,523,306               50,049,271                 -1,474,035   -2.86%   x 1.03
 map_collect::i_to_i::with_linked_list_collect_vec                   23,086,079               22,443,957                   -642,122   -2.78%   x 1.03
 map_collect::i_mod_10_to_i::with_mutex                              80,962,611               77,863,092                 -3,099,519   -3.83%   x 1.04
 map_collect::i_to_i::with_mutex                                     204,617,301              196,787,223                -7,830,078   -3.83%   x 1.04
 vec_collect::vec_i::with_collect                                    2,535,582                2,437,613                     -97,969   -3.86%   x 1.04
 vec_collect::vec_i::with_collect_into_vec                           2,665,272                2,531,158                    -134,114   -5.03%   x 1.05
 map_collect::i_to_i::with_vec_vec_sized                             14,525,832               13,627,798                   -898,034   -6.18%   x 1.07
 vec_collect::vec_i::with_collect_into_vec_reused                    1,227,069                1,109,099                    -117,970   -9.61%   x 1.11
 vec_collect::vec_i_filtered::with_fold                              41,675,555               36,487,521                 -5,188,034  -12.45%   x 1.14
 map_collect::i_mod_10_to_i::with_collect                            6,068,716                5,130,790                    -937,926  -15.46%   x 1.18
 map_collect::i_mod_10_to_i::with_vec_vec_sized                      6,249,221                5,276,541                    -972,680  -15.56%   x 1.18
 map_collect::i_mod_10_to_i::with_linked_list_collect_vec            5,996,844                5,026,503                    -970,341  -16.18%   x 1.19
 map_collect::i_mod_10_to_i::with_linked_list_map_reduce_vec_sized   5,897,802                4,976,394                    -921,408  -15.62%   x 1.19
 map_collect::i_to_i::with_collect                                   14,137,451               11,812,855                 -2,324,596  -16.44%   x 1.20
 map_collect::i_mod_10_to_i::with_linked_list_collect_vec_sized      6,187,408                4,996,645                  -1,190,763  -19.24%   x 1.24
 map_collect::i_to_i::with_linked_list_map_reduce_vec_sized          14,489,709               11,024,575                 -3,465,134  -23.91%   x 1.31
 map_collect::i_mod_10_to_i::with_fold                               1,690,818                1,265,901                    -424,917  -25.13%   x 1.34
 vec_collect::vec_i::with_linked_list_collect_vec                    23,295,026               16,697,819                 -6,597,207  -28.32%   x 1.40
 map_collect::i_mod_10_to_i::with_fold_vec                           2,652,629                1,707,870                    -944,759  -35.62%   x 1.55
 vec_collect::vec_i::with_linked_list_map_reduce_vec_sized           14,930,174               9,183,037                  -5,747,137  -38.49%   x 1.63
 vec_collect::vec_i::with_vec_vec_sized                              15,782,752               9,705,671                  -6,077,081  -38.50%   x 1.63
 vec_collect::vec_i_filtered::with_linked_list_collect_vec           30,026,717               18,254,188                -11,772,529  -39.21%   x 1.64
 vec_collect::vec_i::with_linked_list_collect_vec_sized              15,408,185               8,607,308                  -6,800,877  -44.14%   x 1.79
 vec_collect::vec_i_filtered::with_vec_vec_sized                     22,714,855               9,594,991                 -13,119,864  -57.76%   x 2.37
 vec_collect::vec_i_filtered::with_linked_list_map_reduce_vec_sized  23,022,071               9,483,549                 -13,538,522  -58.81%   x 2.43
 vec_collect::vec_i_filtered::with_linked_list_collect_vec_sized     23,143,333               9,342,023                 -13,801,310  -59.63%   x 2.48
 vec_collect::vec_i_filtered::with_collect                           24,671,619               6,026,401                 -18,645,218  -75.57%   x 4.09
```

Author: huonw

src/iter/cloned.rs

@@ -205,6 +205,14 @@ where
         }
     }
 
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = &'a T>
+    {
+        self.base = self.base.consume_iter(iter.into_iter().cloned());
+        self
+    }
+
     fn complete(self) -> F::Result {
         self.base.complete()
     }

src/iter/filter.rs

@@ -136,6 +136,15 @@ where
         }
     }
 
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>
+    {
+        self.base = self.base.consume_iter(iter.into_iter().filter(self.filter_op));
+        self
+    }
+
+
     fn complete(self) -> Self::Result {
         self.base.complete()
     }

src/iter/filter_map.rs

@@ -139,6 +139,13 @@ where
             self
         }
     }
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>
+    {
+        self.base = self.base.consume_iter(iter.into_iter().filter_map(self.filter_op));
+        self
+    }
 
     fn complete(self) -> C::Result {
         self.base.complete()

src/iter/find.rs

@@ -86,6 +86,16 @@ where
         self
     }
 
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where I: IntoIterator<Item = T>
+    {
+        self.item = iter.into_iter().find(self.find_op);
+        if self.item.is_some() {
+            self.found.store(true, Ordering::Relaxed)
+        }
+        self
+    }
+
     fn complete(self) -> Self::Result {
         self.item
     }

src/iter/fold.rs

@@ -141,6 +141,14 @@ where
         }
     }
 
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>
+    {
+        self.item = iter.into_iter().fold(self.item, self.fold_op);
+        self
+    }
+
     fn complete(self) -> C::Result {
         self.base.consume(self.item).complete()
     }

src/iter/inspect.rs

@@ -243,6 +243,14 @@ where
         }
     }
 
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>
+    {
+        self.base = self.base.consume_iter(iter.into_iter().inspect(self.inspect_op));
+        self
+    }
+
     fn complete(self) -> C::Result {
         self.base.complete()
     }

src/iter/map.rs

@@ -247,6 +247,14 @@ where
         }
     }
 
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        self.base = self.base.consume_iter(iter.into_iter().map(self.map_op));
+        self
+    }
+
     fn complete(self) -> C::Result {
         self.base.complete()
     }

src/iter/update.rs

@@ -245,6 +245,20 @@ where
         }
     }
 
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>
+    {
+        let update_op = self.update_op;
+        self.base = self.base.consume_iter(
+            iter.into_iter().map(|mut item| {
+                update_op(&mut item);
+                item
+            })
+        );
+        self
+    }
+
     fn complete(self) -> C::Result {
         self.base.complete()
     }