Add .map_unboxed for now

Author: root

src/lib.rs

@@ -1,3 +1,4 @@
+#![feature(unboxed_closures)]
 #![feature(macro_rules)]
 #![crate_name="itertools"]
 #![crate_type="dylib"]
@@ -32,6 +33,7 @@ pub use adaptors::Product;
 pub use adaptors::PutBack;
 pub use adaptors::FnMap;
 pub use intersperse::Intersperse;
+pub use map::MapMut;
 pub use stride::Stride;
 pub use stride::StrideMut;
 pub use times::Times;
@@ -40,6 +42,7 @@ pub use linspace::{linspace, Linspace};
 mod adaptors;
 mod intersperse;
 mod linspace;
+mod map;
 mod stride;
 mod times;
 
@@ -217,6 +220,13 @@ pub trait Itertools<A> : Iterator<A> {
         FnMap::new(self, map)
     }
 
+    /// Like regular `.map`, but using an unboxed closure instead.
+    ///
+    /// Iterator element type is `B`
+    fn map_unboxed<B, F: FnMut(A) -> B>(self, map: F) -> MapMut<A, B, F, Self> {
+        MapMut::new(self, map)
+    }
+
     /// Alternate elements from two iterators until both
     /// are run out
     ///

src/map.rs

@@ -0,0 +1,48 @@
+
+/// Clonable iterator adaptor to map elementwise
+/// from `Iterator<A>` to `Iterator<B>`
+///
+/// Created with `.map_unboxed(..)` on an iterator
+///
+/// Iterator element type is `B`
+pub struct MapMut<A, B, F, I> {
+    map: F,
+    iter: I,
+}
+
+impl<A, B, F: FnMut(A) -> B, I> MapMut<A, B, F, I>
+{
+    pub fn new(iter: I, map: F) -> MapMut<A, B, F, I> {
+        MapMut{iter: iter, map: map}
+    }
+}
+
+impl<A, B, F: FnMut(A) -> B, I: Iterator<A>> Iterator<B> for MapMut<A, B, F, I>
+{
+    #[inline]
+    fn next(&mut self) -> Option<B> {
+        self.iter.next().map(|a| (self.map)(a))
+    }
+
+    fn size_hint(&self) -> (uint, Option<uint>) {
+        self.iter.size_hint()
+    }
+}
+
+impl<A, B, F: FnMut(A) -> B, I: DoubleEndedIterator<A>> DoubleEndedIterator<B>
+for MapMut<A, B, F, I>
+{
+    #[inline]
+    fn next_back(&mut self) -> Option<B> {
+        self.iter.next_back().map(|a| (self.map)(a))
+    }
+}
+
+impl<A, B, F: Clone + FnMut(A) -> B, I: Clone> Clone for MapMut<A, B, F, I>
+{
+    #[inline]
+    fn clone(&self) -> MapMut<A, B, F, I> {
+        MapMut::new(self.iter.clone(), self.map.clone())
+    }
+}
+

tests/tests.rs

@@ -72,6 +72,20 @@ fn fn_map() {
     assert!(it.zip(jt).all(|(x,y)| x == y));
 }
 
+#[test]
+fn map_unboxed() {
+    let xs = [0, 1, 2i];
+    fn mapper(x: &int) -> String { x.to_string() }
+    let it = xs.iter().map_unboxed(mapper);
+    let jt = it.clone();
+    assert!(it.zip(jt).all(|(x,y)| x == y));
+
+    // NOTE: This doesn't compile :(
+    //let mut sum = 0i;
+    //let it = xs.iter().map_unboxed(|x| sum += *x).drain();
+    //assert_eq!(sum, 3);
+}
+
 #[test]
 fn write_to() {
     let xs = [7i, 9, 8];