From a65d3f5b98cc94f0a759fbf1a08be9aee0f97883 Mon Sep 17 00:00:00 2001 From: Jorge Aparicio Date: Wed, 7 Jan 2015 22:01:05 -0500 Subject: core: add the `IntoIterator` trait --- src/libcollections/binary_heap.rs | 18 +++++++++++++++++- src/libcollections/bit.rs | 17 ++++++++++++++++- src/libcollections/btree/map.rs | 26 +++++++++++++++++++++++++- src/libcollections/btree/set.rs | 18 +++++++++++++++++- src/libcollections/dlist.rs | 26 +++++++++++++++++++++++++- src/libcollections/enum_set.rs | 10 +++++++++- src/libcollections/ring_buf.rs | 26 +++++++++++++++++++++++++- src/libcollections/vec.rs | 27 ++++++++++++++++++++++++++- src/libcollections/vec_map.rs | 26 +++++++++++++++++++++++++- src/libcore/array.rs | 18 ++++++++++++++++++ src/libcore/iter.rs | 17 +++++++++++++++++ src/libcore/slice.rs | 16 ++++++++++++++++ 12 files changed, 236 insertions(+), 9 deletions(-) diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index f717fc6075d..fb4c326e10a 100644 --- 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 @@ impl FromIterator for BinaryHeap { } } +impl IntoIterator for BinaryHeap { + type Iter = IntoIter; + + fn into_iter(self) -> IntoIter { + self.into_iter() + } +} + +impl<'a, T> IntoIterator for &'a BinaryHeap 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 Extend for BinaryHeap { fn extend>(&mut self, mut iter: Iter) { diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index c6275740579..d676cfca929 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -89,7 +89,7 @@ use core::fmt; 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 @@ impl<'a> RandomAccessIterator for Iter<'a> { } } +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) { 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 4f2c2cb6028..27783ff941a 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -24,7 +24,7 @@ use core::cmp::Ordering; 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 @@ impl BTreeMap { } } +impl IntoIterator for BTreeMap { + type Iter = IntoIter; + + fn into_iter(self) -> IntoIter { + self.into_iter() + } +} + +impl<'a, K, V> IntoIterator for &'a BTreeMap { + 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 { + 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 { diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index a090e4f24ce..e6d7d2a37eb 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -18,7 +18,7 @@ use core::cmp::Ordering::{self, Less, Greater, Equal}; 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 @@ impl FromIterator for BTreeSet { } } +impl IntoIterator for BTreeSet { + type Iter = IntoIter; + + fn into_iter(self) -> IntoIter { + self.into_iter() + } +} + +impl<'a, T> IntoIterator for &'a BTreeSet { + type Iter = Iter<'a, T>; + + fn into_iter(self) -> Iter<'a, T> { + self.iter() + } +} + #[stable(feature = "rust1", since = "1.0.0")] impl Extend for BTreeSet { #[inline] diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index aded4b8a7ac..48bf820e6f6 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -28,7 +28,7 @@ use core::cmp::Ordering; 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 @@ impl FromIterator for DList { } } +impl IntoIterator for DList { + type Iter = IntoIter; + + fn into_iter(self) -> IntoIter { + self.into_iter() + } +} + +impl<'a, T> IntoIterator for &'a DList { + type Iter = Iter<'a, T>; + + fn into_iter(self) -> Iter<'a, T> { + self.iter() + } +} + +impl<'a, T> IntoIterator for &'a mut DList { + type Iter = IterMut<'a, T>; + + fn into_iter(mut self) -> IterMut<'a, T> { + self.iter_mut() + } +} + #[stable(feature = "rust1", since = "1.0.0")] impl Extend for DList { fn extend>(&mut self, mut iterator: T) { diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index b542259eba0..a9e64a5c282 100644 --- 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 @@ impl FromIterator for EnumSet { } } +impl<'a, E> IntoIterator for &'a EnumSet where E: CLike { + type Iter = Iter; + + fn into_iter(self) -> Iter { + self.iter() + } +} + impl Extend for EnumSet { fn extend>(&mut self, mut iterator: I) { for element in iterator { diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 34910f59fe0..5b5e3be12e3 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -19,7 +19,7 @@ use core::prelude::*; 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 @@ impl FromIterator for RingBuf { } } +impl IntoIterator for RingBuf { + type Iter = IntoIter; + + fn into_iter(self) -> IntoIter { + self.into_iter() + } +} + +impl<'a, T> IntoIterator for &'a RingBuf { + type Iter = Iter<'a, T>; + + fn into_iter(self) -> Iter<'a, T> { + self.iter() + } +} + +impl<'a, T> IntoIterator for &'a mut RingBuf { + type Iter = IterMut<'a, T>; + + fn into_iter(mut self) -> IterMut<'a, T> { + self.iter_mut() + } +} + #[stable(feature = "rust1", since = "1.0.0")] impl Extend for RingBuf { fn extend>(&mut self, mut iterator: T) { diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 5dd88dbb025..ac6d7936f28 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -56,7 +56,7 @@ use core::cmp::{Ordering}; 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::{Index, IndexMut, Deref, Add}; use core::ops; use core::ptr; use core::raw::Slice as RawSlice; +use core::slice; use core::uint; /// A growable list type, written `Vec` but pronounced 'vector.' @@ -1404,6 +1405,30 @@ impl FromIterator for Vec { } } +impl IntoIterator for Vec { + type Iter = IntoIter; + + fn into_iter(self) -> IntoIter { + self.into_iter() + } +} + +impl<'a, T> IntoIterator for &'a Vec { + type Iter = slice::Iter<'a, T>; + + fn into_iter(self) -> slice::Iter<'a, T> { + self.iter() + } +} + +impl<'a, T> IntoIterator for &'a mut Vec { + 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 Extend for Vec { #[inline] diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index 9f83b91fc9b..2846414bb9a 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -19,7 +19,7 @@ use core::cmp::Ordering; 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 @@ impl FromIterator<(uint, V)> for VecMap { } } +impl IntoIterator for VecMap { + type Iter = IntoIter; + + fn into_iter(self) -> IntoIter { + self.into_iter() + } +} + +impl<'a, T> IntoIterator for &'a VecMap { + type Iter = Iter<'a, T>; + + fn into_iter(self) -> Iter<'a, T> { + self.iter() + } +} + +impl<'a, T> IntoIterator for &'a mut VecMap { + type Iter = IterMut<'a, T>; + + fn into_iter(mut self) -> IterMut<'a, T> { + self.iter_mut() + } +} + #[stable(feature = "rust1", since = "1.0.0")] impl Extend<(uint, V)> for VecMap { fn extend>(&mut self, mut iter: Iter) { diff --git a/src/libcore/array.rs b/src/libcore/array.rs index a81615944fb..ec3d9783255 100644 --- a/src/libcore/array.rs +++ b/src/libcore/array.rs @@ -18,12 +18,14 @@ use clone::Clone; 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 @@ macro_rules! array_impls { } } + 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 PartialEq<[B; $N]> for [A; $N] where A: PartialEq { #[inline] diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index b6b2f9c57fe..f9c6e0758e6 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -122,6 +122,23 @@ pub trait FromIterator { fn from_iter>(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 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 { diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 40e66db3ae5..11e3d196f73 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -637,6 +637,22 @@ impl<'a, T> Default for &'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) => { -- cgit 1.4.1-3-g733a5