core: add the `IntoIterator` trait

diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs
index f717fc6075d4679b3c883e80b4791a4caee2a32d..fb4c326e10a1b5c8cd21771d1090bd0d9a636082 100644 (file)
--- a/src/libcollections/binary_heap.rs
+++ b/src/libcollections/binary_heap.rs
@@ -153,7 +153,7 @@
 use core::prelude::*;
 
 use core::default::Default;
-use core::iter::FromIterator;
+use core::iter::{FromIterator, IntoIterator};
 use core::mem::{zeroed, replace, swap};
 use core::ptr;
 
@@ -655,6 +655,22 @@ fn from_iter<Iter: Iterator<Item=T>>(iter: Iter) -> BinaryHeap<T> {
     }
 }
 
+impl<T> IntoIterator for BinaryHeap<T> {
+    type Iter = IntoIter<T>;
+
+    fn into_iter(self) -> IntoIter<T> {
+        self.into_iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a BinaryHeap<T> where T: Ord {
+    type Iter = Iter<'a, T>;
+
+    fn into_iter(self) -> Iter<'a, T> {
+        self.iter()
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Ord> Extend<T> for BinaryHeap<T> {
     fn extend<Iter: Iterator<Item=T>>(&mut self, mut iter: Iter) {

diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs
index c627574057969d93a479d779b19bf1d2d37d0ce4..d676cfca9294e6ab2a0f07a03c94aeed28a36055 100644 (file)
--- a/src/libcollections/bit.rs
+++ b/src/libcollections/bit.rs
@@ -89,7 +89,7 @@
 use core::hash;
 use core::iter::RandomAccessIterator;
 use core::iter::{Chain, Enumerate, Repeat, Skip, Take, repeat, Cloned};
-use core::iter::{self, FromIterator};
+use core::iter::{self, FromIterator, IntoIterator};
 use core::num::Int;
 use core::ops::Index;
 use core::slice;
@@ -1070,6 +1070,14 @@ fn idx(&mut self, index: uint) -> Option<bool> {
     }
 }
 
+impl<'a> IntoIterator for &'a Bitv {
+    type Iter = Iter<'a>;
+
+    fn into_iter(self) -> Iter<'a> {
+        self.iter()
+    }
+}
+
 /// An implementation of a set using a bit vector as an underlying
 /// representation for holding unsigned numerical elements.
 ///
@@ -1873,6 +1881,13 @@ impl<'a> Iterator for SymmetricDifference<'a> {
     #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
 }
 
+impl<'a> IntoIterator for &'a BitvSet {
+    type Iter = SetIter<'a>;
+
+    fn into_iter(self) -> SetIter<'a> {
+        self.iter()
+    }
+}
 
 #[cfg(test)]
 mod tests {

diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs
index 4f2c2cb60287eebd1266feec69e4eb169228935a..27783ff941a4152ea6fb4afa4af162642a9bfdc1 100644 (file)
--- a/src/libcollections/btree/map.rs
+++ b/src/libcollections/btree/map.rs
@@ -24,7 +24,7 @@
 use core::default::Default;
 use core::fmt::Debug;
 use core::hash::{Hash, Hasher};
-use core::iter::{Map, FromIterator};
+use core::iter::{Map, FromIterator, IntoIterator};
 use core::ops::{Index, IndexMut};
 use core::{iter, fmt, mem};
 use Bound::{self, Included, Excluded, Unbounded};
@@ -478,6 +478,30 @@ pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V> where Q: BorrowFrom<K>
     }
 }
 
+impl<K, V> IntoIterator for BTreeMap<K, V> {
+    type Iter = IntoIter<K, V>;
+
+    fn into_iter(self) -> IntoIter<K, V> {
+        self.into_iter()
+    }
+}
+
+impl<'a, K, V> IntoIterator for &'a BTreeMap<K, V> {
+    type Iter = Iter<'a, K, V>;
+
+    fn into_iter(self) -> Iter<'a, K, V> {
+        self.iter()
+    }
+}
+
+impl<'a, K, V> IntoIterator for &'a mut BTreeMap<K, V> {
+    type Iter = IterMut<'a, K, V>;
+
+    fn into_iter(mut self) -> IterMut<'a, K, V> {
+        self.iter_mut()
+    }
+}
+
 /// A helper enum useful for deciding whether to continue a loop since we can't
 /// return from a closure
 enum Continuation<A, B> {

diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs
index a090e4f24ce1d35ba16d7827e1f270fb8e6c2f0d..e6d7d2a37eb78a435fc539e3fa4b7abe7e35fb44 100644 (file)
--- a/src/libcollections/btree/set.rs
+++ b/src/libcollections/btree/set.rs
@@ -18,7 +18,7 @@
 use core::default::Default;
 use core::fmt::Debug;
 use core::fmt;
-use core::iter::{Peekable, Map, FromIterator};
+use core::iter::{Peekable, Map, FromIterator, IntoIterator};
 use core::ops::{BitOr, BitAnd, BitXor, Sub};
 
 use btree_map::{BTreeMap, Keys};
@@ -480,6 +480,22 @@ fn from_iter<Iter: Iterator<Item=T>>(iter: Iter) -> BTreeSet<T> {
     }
 }
 
+impl<T> IntoIterator for BTreeSet<T> {
+    type Iter = IntoIter<T>;
+
+    fn into_iter(self) -> IntoIter<T> {
+        self.into_iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a BTreeSet<T> {
+    type Iter = Iter<'a, T>;
+
+    fn into_iter(self) -> Iter<'a, T> {
+        self.iter()
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Ord> Extend<T> for BTreeSet<T> {
     #[inline]

diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs
index aded4b8a7ac9e7fabfd28fbc659e0037b95efb58..48bf820e6f6a233991a3e26c724012a41ad2a638 100644 (file)
--- a/src/libcollections/dlist.rs
+++ b/src/libcollections/dlist.rs
@@ -28,7 +28,7 @@
 use core::default::Default;
 use core::fmt;
 use core::hash::{Writer, Hasher, Hash};
-use core::iter::{self, FromIterator};
+use core::iter::{self, FromIterator, IntoIterator};
 use core::mem;
 use core::ptr;
 
@@ -830,6 +830,30 @@ fn from_iter<T: Iterator<Item=A>>(iterator: T) -> DList<A> {
     }
 }
 
+impl<T> IntoIterator for DList<T> {
+    type Iter = IntoIter<T>;
+
+    fn into_iter(self) -> IntoIter<T> {
+        self.into_iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a DList<T> {
+    type Iter = Iter<'a, T>;
+
+    fn into_iter(self) -> Iter<'a, T> {
+        self.iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a mut DList<T> {
+    type Iter = IterMut<'a, T>;
+
+    fn into_iter(mut self) -> IterMut<'a, T> {
+        self.iter_mut()
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A> Extend<A> for DList<A> {
     fn extend<T: Iterator<Item=A>>(&mut self, mut iterator: T) {

diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs
index b542259eba0dddd7efe1cb1e1da51a69cee34f13..a9e64a5c282ea4e8bfdb3cd69276f74a89742426 100644 (file)
--- a/src/libcollections/enum_set.rs
+++ b/src/libcollections/enum_set.rs
@@ -16,7 +16,7 @@
 use core::prelude::*;
 use core::fmt;
 use core::num::Int;
-use core::iter::FromIterator;
+use core::iter::{FromIterator, IntoIterator};
 use core::ops::{Sub, BitOr, BitAnd, BitXor};
 
 // FIXME(contentions): implement union family of methods? (general design may be wrong here)
@@ -256,6 +256,14 @@ fn from_iter<I:Iterator<Item=E>>(iterator: I) -> EnumSet<E> {
     }
 }
 
+impl<'a, E> IntoIterator for &'a EnumSet<E> where E: CLike {
+    type Iter = Iter<E>;
+
+    fn into_iter(self) -> Iter<E> {
+        self.iter()
+    }
+}
+
 impl<E:CLike> Extend<E> for EnumSet<E> {
     fn extend<I: Iterator<Item=E>>(&mut self, mut iterator: I) {
         for element in iterator {

diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs
index 34910f59fe03677231db083b1bb74d314e8d022b..5b5e3be12e35fb5688ca3d2d03aeb2e7cf863c99 100644 (file)
--- a/src/libcollections/ring_buf.rs
+++ b/src/libcollections/ring_buf.rs
@@ -19,7 +19,7 @@
 use core::cmp::Ordering;
 use core::default::Default;
 use core::fmt;
-use core::iter::{self, repeat, FromIterator, RandomAccessIterator};
+use core::iter::{self, repeat, FromIterator, IntoIterator, RandomAccessIterator};
 use core::marker;
 use core::mem;
 use core::num::{Int, UnsignedInt};
@@ -1609,6 +1609,30 @@ fn from_iter<T: Iterator<Item=A>>(iterator: T) -> RingBuf<A> {
     }
 }
 
+impl<T> IntoIterator for RingBuf<T> {
+    type Iter = IntoIter<T>;
+
+    fn into_iter(self) -> IntoIter<T> {
+        self.into_iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a RingBuf<T> {
+    type Iter = Iter<'a, T>;
+
+    fn into_iter(self) -> Iter<'a, T> {
+        self.iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a mut RingBuf<T> {
+    type Iter = IterMut<'a, T>;
+
+    fn into_iter(mut self) -> IterMut<'a, T> {
+        self.iter_mut()
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A> Extend<A> for RingBuf<A> {
     fn extend<T: Iterator<Item=A>>(&mut self, mut iterator: T) {

diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index 5dd88dbb02524134f9445d58e2a35999fe078053..ac6d7936f280840cf07aec83853e86ffaf0db212 100644 (file)
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -56,7 +56,7 @@
 use core::default::Default;
 use core::fmt;
 use core::hash::{self, Hash};
-use core::iter::{repeat, FromIterator};
+use core::iter::{repeat, FromIterator, IntoIterator};
 use core::marker::{ContravariantLifetime, InvariantType};
 use core::mem;
 use core::nonzero::NonZero;
@@ -65,6 +65,7 @@
 use core::ops;
 use core::ptr;
 use core::raw::Slice as RawSlice;
+use core::slice;
 use core::uint;
 
 /// A growable list type, written `Vec<T>` but pronounced 'vector.'
@@ -1404,6 +1405,30 @@ fn from_iter<I:Iterator<Item=T>>(mut iterator: I) -> Vec<T> {
     }
 }
 
+impl<T> IntoIterator for Vec<T> {
+    type Iter = IntoIter<T>;
+
+    fn into_iter(self) -> IntoIter<T> {
+        self.into_iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a Vec<T> {
+    type Iter = slice::Iter<'a, T>;
+
+    fn into_iter(self) -> slice::Iter<'a, T> {
+        self.iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a mut Vec<T> {
+    type Iter = slice::IterMut<'a, T>;
+
+    fn into_iter(mut self) -> slice::IterMut<'a, T> {
+        self.iter_mut()
+    }
+}
+
 #[unstable(feature = "collections", reason = "waiting on Extend stability")]
 impl<T> Extend<T> for Vec<T> {
     #[inline]

diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs
index 9f83b91fc9bbd972c81c8b0f5616c37a7bfd4add..2846414bb9accd8df3c5fa838e2b6961c2fd873b 100644 (file)
--- a/src/libcollections/vec_map.rs
+++ b/src/libcollections/vec_map.rs
@@ -19,7 +19,7 @@
 use core::default::Default;
 use core::fmt;
 use core::hash::{Hash, Writer, Hasher};
-use core::iter::{Enumerate, FilterMap, Map, FromIterator};
+use core::iter::{Enumerate, FilterMap, Map, FromIterator, IntoIterator};
 use core::iter;
 use core::mem::replace;
 use core::ops::{Index, IndexMut};
@@ -536,6 +536,30 @@ fn from_iter<Iter: Iterator<Item=(uint, V)>>(iter: Iter) -> VecMap<V> {
     }
 }
 
+impl<T> IntoIterator for VecMap<T> {
+    type Iter = IntoIter<T>;
+
+    fn into_iter(self) -> IntoIter<T> {
+        self.into_iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a VecMap<T> {
+    type Iter = Iter<'a, T>;
+
+    fn into_iter(self) -> Iter<'a, T> {
+        self.iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a mut VecMap<T> {
+    type Iter = IterMut<'a, T>;
+
+    fn into_iter(mut self) -> IterMut<'a, T> {
+        self.iter_mut()
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<V> Extend<(uint, V)> for VecMap<V> {
     fn extend<Iter: Iterator<Item=(uint, V)>>(&mut self, mut iter: Iter) {

diff --git a/src/libcore/array.rs b/src/libcore/array.rs
index a81615944fb46056c126c0e7f9c7017eb3b1011a..ec3d9783255cb77a13c09e24d45fc606bb7c57d9 100644 (file)
--- a/src/libcore/array.rs
+++ b/src/libcore/array.rs
@@ -18,12 +18,14 @@
 use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
 use fmt;
 use hash::{Hash, Hasher, self};
+use iter::IntoIterator;
 use marker::Copy;
 #[cfg(stage0)]
 use ops::{Deref, FullRange};
 #[cfg(not(stage0))]
 use ops::Deref;
 use option::Option;
+use slice::{Iter, IterMut, SliceExt};
 
 // macro for implementing n-ary tuple functions and operations
 macro_rules! array_impls {
@@ -49,6 +51,22 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 }
             }
 
+            impl<'a, T> IntoIterator for &'a [T; $N] {
+                type Iter = Iter<'a, T>;
+
+                fn into_iter(self) -> Iter<'a, T> {
+                    self.iter()
+                }
+            }
+
+            impl<'a, T> IntoIterator for &'a mut [T; $N] {
+                type Iter = IterMut<'a, T>;
+
+                fn into_iter(self) -> IterMut<'a, T> {
+                    self.iter_mut()
+                }
+            }
+
             #[stable(feature = "rust1", since = "1.0.0")]
             impl<A, B> PartialEq<[B; $N]> for [A; $N] where A: PartialEq<B> {
                 #[inline]

diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index b6b2f9c57fe7b77a26dd071e2c4c8c8a2ae1138a..f9c6e0758e6e87b18403a7f870ddf7d63ca6d59f 100644 (file)
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -122,6 +122,23 @@ pub trait FromIterator<A> {
     fn from_iter<T: Iterator<Item=A>>(iterator: T) -> Self;
 }
 
+/// Conversion into an `Iterator`
+#[unstable]
+pub trait IntoIterator {
+    type Iter: Iterator;
+
+    /// Consumes `Self` and returns an iterator over it
+    fn into_iter(self) -> Self::Iter;
+}
+
+impl<I> IntoIterator for I where I: Iterator {
+    type Iter = I;
+
+    fn into_iter(self) -> I {
+        self
+    }
+}
+
 /// A type growable from an `Iterator` implementation
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Extend<A> {

diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 40e66db3ae5b0eddc95b3fae19280026296851a3..11e3d196f73fac8545eb0cf8c3388c0a7bf00a38 100644 (file)
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -637,6 +637,22 @@ fn default() -> &'a [T] { &[] }
 // Iterators
 //
 
+impl<'a, T> IntoIterator for &'a [T] {
+    type Iter = Iter<'a, T>;
+
+    fn into_iter(self) -> Iter<'a, T> {
+        self.iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a mut [T] {
+    type Iter = IterMut<'a, T>;
+
+    fn into_iter(self) -> IterMut<'a, T> {
+        self.iter_mut()
+    }
+}
+
 // The shared definition of the `Iter` and `IterMut` iterators
 macro_rules! iterator {
     (struct $name:ident -> $ptr:ty, $elem:ty) => {