Clean up the APIs, assuming some things land in rust HEAD

de.rs

@@ -1,6 +1,7 @@
 extern crate collections;
 
 use std::hash::Hash;
+use std::result;
 use collections::HashMap;
 
 #[deriving(Clone, Eq)]
@@ -79,10 +80,9 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
     >(&mut self) -> Result<C, E> {
         try!(self.expect_collection_start());
 
-        let mut err = None;
+        let iter = self.by_ref().batch(|d| {
+            let d = d.iter();
 
-        let values: C = FromIterator::from_iter(
-            Batch::new(self, |d| {
             let token = match d.next() {
                 Some(token) => token,
                 None => { return None; }
@@ -91,34 +91,21 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
             match token {
                 Ok(CollectionSep) => {
                     let value: Result<T, E> = Deserializable::deserialize(d);
-                        match value {
+                    Some(value)
-                            Ok(value) => Some(value),
-                            Err(e) => {
-                                err = Some(e);
-                                None
-                            }
-                        }
                 }
                 Ok(CollectionEnd) => {
                     None
                 }
                 Ok(_) => {
-                        err = Some(d.syntax_error());
+                    Some(Err(d.syntax_error()))
-                        None
                 }
                 Err(e) => {
-                        err = Some(e);
+                    Some(Err(e))
-                        None
                 }
             }
+        });
 
-            })
+        result::collect(iter)
-        );
-
-        match err {
-            None => Ok(values),
-            Some(err) => Err(err),
-        }
     }
 
     #[inline]
@@ -312,30 +299,6 @@ impl<
 
 //////////////////////////////////////////////////////////////////////////////
 
-struct Batch<'a, A, B, T> {
-    iter: &'a mut T,
-    f: |&mut T|: 'a -> Option<B>,
-}
-
-impl<'a, A, B, T: Iterator<A>> Batch<'a, A, B, T> {
-    #[inline]
-    fn new(iter: &'a mut T, f: |&mut T|: 'a -> Option<B>) -> Batch<'a, A, B, T> {
-        Batch {
-            iter: iter,
-            f: f,
-        }
-    }
-}
-
-impl<'a, A, B, T: Iterator<A>> Iterator<B> for Batch<'a, A, B, T> {
-    #[inline]
-    fn next(&mut self) -> Option<B> {
-        (self.f)(self.iter)
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
 #[cfg(test)]
 mod tests {
     extern crate serialize;