From 7ae17e0964b9f869881f4122cd0e1ccc19bee0d4 Mon Sep 17 00:00:00 2001 From: blake2-ppc Date: Fri, 26 Jul 2013 00:55:05 +0200 Subject: [PATCH] Remove dummy type parameters from iterator adaptors With the recent fixes to method resolution, we can now remove the dummy type parameters used as crutches in the iterator module. For example, the zip adaptor type is just ZipIterator now. --- src/libextra/dlist.rs | 7 ++- src/libextra/ringbuf.rs | 4 +- src/libextra/smallintmap.rs | 8 ++-- src/libstd/hashmap.rs | 4 +- src/libstd/iterator.rs | 86 +++++++++++++++++-------------------- src/libstd/vec.rs | 4 +- 6 files changed, 51 insertions(+), 62 deletions(-) diff --git a/src/libextra/dlist.rs b/src/libextra/dlist.rs index 77060c4b11e..3cd2d91459f 100644 --- a/src/libextra/dlist.rs +++ b/src/libextra/dlist.rs @@ -356,7 +356,7 @@ impl DList { /// Provide a reverse iterator #[inline] - pub fn rev_iter<'a>(&'a self) -> InvertIterator<&'a T, DListIterator<'a, T>> { + pub fn rev_iter<'a>(&'a self) -> InvertIterator> { self.iter().invert() } @@ -376,8 +376,7 @@ impl DList { } /// Provide a reverse iterator with mutable references #[inline] - pub fn mut_rev_iter<'a>(&'a mut self) -> InvertIterator<&'a mut T, - MutDListIterator<'a, T>> { + pub fn mut_rev_iter<'a>(&'a mut self) -> InvertIterator> { self.mut_iter().invert() } @@ -390,7 +389,7 @@ impl DList { /// Consume the list into an iterator yielding elements by value, in reverse #[inline] - pub fn consume_rev_iter(self) -> InvertIterator> { + pub fn consume_rev_iter(self) -> InvertIterator> { self.consume_iter().invert() } } diff --git a/src/libextra/ringbuf.rs b/src/libextra/ringbuf.rs index f46af664b18..7c940445e77 100644 --- a/src/libextra/ringbuf.rs +++ b/src/libextra/ringbuf.rs @@ -184,7 +184,7 @@ impl RingBuf { } /// Back-to-front iterator. - pub fn rev_iter<'a>(&'a self) -> InvertIterator<&'a T, RingBufIterator<'a, T>> { + pub fn rev_iter<'a>(&'a self) -> InvertIterator> { self.iter().invert() } @@ -195,7 +195,7 @@ impl RingBuf { } /// Back-to-front iterator which returns mutable values. - pub fn mut_rev_iter<'a>(&'a mut self) -> InvertIterator<&'a mut T, RingBufMutIterator<'a, T>> { + pub fn mut_rev_iter<'a>(&'a mut self) -> InvertIterator> { self.mut_iter().invert() } } diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs index bd78f41ddf5..d292ff256c4 100644 --- a/src/libextra/smallintmap.rs +++ b/src/libextra/smallintmap.rs @@ -207,7 +207,7 @@ impl SmallIntMap { /// Empties the hash map, moving all values into the specified closure pub fn consume(&mut self) -> FilterMapIterator<(uint, Option), (uint, V), - EnumerateIterator, VecConsumeIterator>>> + EnumerateIterator>>> { let values = replace(&mut self.v, ~[]); values.consume_iter().enumerate().filter_map(|(i, v)| { @@ -293,8 +293,7 @@ pub struct SmallIntMapIterator<'self, T> { iterator!(impl SmallIntMapIterator -> (uint, &'self T), get_ref) double_ended_iterator!(impl SmallIntMapIterator -> (uint, &'self T), get_ref) -pub type SmallIntMapRevIterator<'self, T> = InvertIterator<(uint, &'self T), - SmallIntMapIterator<'self, T>>; +pub type SmallIntMapRevIterator<'self, T> = InvertIterator>; pub struct SmallIntMapMutIterator<'self, T> { priv front: uint, @@ -304,8 +303,7 @@ pub struct SmallIntMapMutIterator<'self, T> { iterator!(impl SmallIntMapMutIterator -> (uint, &'self mut T), get_mut_ref) double_ended_iterator!(impl SmallIntMapMutIterator -> (uint, &'self mut T), get_mut_ref) -pub type SmallIntMapMutRevIterator<'self, T> = InvertIterator<(uint, &'self mut T), - SmallIntMapMutIterator<'self, T>>; +pub type SmallIntMapMutRevIterator<'self, T> = InvertIterator>; #[cfg(test)] mod test_map { diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs index deeda501942..818c6b69b81 100644 --- a/src/libstd/hashmap.rs +++ b/src/libstd/hashmap.rs @@ -770,7 +770,7 @@ impl HashSet { /// Visit the values representing the symmetric difference pub fn symmetric_difference_iter<'a>(&'a self, other: &'a HashSet) - -> ChainIterator<&'a T, SetAlgebraIter<'a, T>, SetAlgebraIter<'a, T>> { + -> ChainIterator, SetAlgebraIter<'a, T>> { self.difference_iter(other).chain_(other.difference_iter(self)) } @@ -783,7 +783,7 @@ impl HashSet { /// Visit the values representing the union pub fn union_iter<'a>(&'a self, other: &'a HashSet) - -> ChainIterator<&'a T, HashSetIterator<'a, T>, SetAlgebraIter<'a, T>> { + -> ChainIterator, SetAlgebraIter<'a, T>> { self.iter().chain_(other.difference_iter(self)) } diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs index d3b2325fd9d..a6460935a50 100644 --- a/src/libstd/iterator.rs +++ b/src/libstd/iterator.rs @@ -66,37 +66,36 @@ pub trait RandomAccessIterator: Iterator { /// Iterator adaptors provided for every `DoubleEndedIterator` implementation. /// /// In the future these will be default methods instead of a utility trait. -pub trait DoubleEndedIteratorUtil { +pub trait DoubleEndedIteratorUtil { /// Flip the direction of the iterator - fn invert(self) -> InvertIterator; + fn invert(self) -> InvertIterator; } /// Iterator adaptors provided for every `DoubleEndedIterator` implementation. /// /// In the future these will be default methods instead of a utility trait. -impl> DoubleEndedIteratorUtil for T { +impl> DoubleEndedIteratorUtil for T { /// Flip the direction of the iterator #[inline] - fn invert(self) -> InvertIterator { + fn invert(self) -> InvertIterator { InvertIterator{iter: self} } } /// An double-ended iterator with the direction inverted -// FIXME #6967: Dummy A parameter to get around type inference bug #[deriving(Clone)] -pub struct InvertIterator { +pub struct InvertIterator { priv iter: T } -impl> Iterator for InvertIterator { +impl> Iterator for InvertIterator { #[inline] fn next(&mut self) -> Option { self.iter.next_back() } #[inline] fn size_hint(&self) -> (uint, Option) { self.iter.size_hint() } } -impl> DoubleEndedIterator for InvertIterator { +impl> DoubleEndedIterator for InvertIterator { #[inline] fn next_back(&mut self) -> Option { self.iter.next() } } @@ -120,7 +119,7 @@ pub trait IteratorUtil { /// assert_eq!(it.next().get(), &1); /// assert!(it.next().is_none()); /// ~~~ - fn chain_>(self, other: U) -> ChainIterator; + fn chain_>(self, other: U) -> ChainIterator; /// Creates an iterator which iterates over both this and the specified /// iterators simultaneously, yielding the two elements as pairs. When @@ -136,7 +135,7 @@ pub trait IteratorUtil { /// assert_eq!(it.next().get(), (&0, &1)); /// assert!(it.next().is_none()); /// ~~~ - fn zip>(self, other: U) -> ZipIterator; + fn zip>(self, other: U) -> ZipIterator; // FIXME: #5898: should be called map /// Creates a new iterator which will apply the specified function to each @@ -193,7 +192,7 @@ pub trait IteratorUtil { /// assert_eq!(it.next().get(), (1, &200)); /// assert!(it.next().is_none()); /// ~~~ - fn enumerate(self) -> EnumerateIterator; + fn enumerate(self) -> EnumerateIterator; /// Creates an iterator which invokes the predicate on elements until it /// returns false. Once the predicate returns false, all further elements are @@ -238,7 +237,7 @@ pub trait IteratorUtil { /// assert_eq!(it.next().get(), &5); /// assert!(it.next().is_none()); /// ~~~ - fn skip(self, n: uint) -> SkipIterator; + fn skip(self, n: uint) -> SkipIterator; // FIXME: #5898: should be called take /// Creates an iterator which yields the first `n` elements of this @@ -254,7 +253,7 @@ pub trait IteratorUtil { /// assert_eq!(it.next().get(), &3); /// assert!(it.next().is_none()); /// ~~~ - fn take_(self, n: uint) -> TakeIterator; + fn take_(self, n: uint) -> TakeIterator; /// Creates a new iterator which behaves in a similar fashion to foldl. /// There is a state which is passed between each iteration and can be @@ -297,7 +296,7 @@ pub trait IteratorUtil { /// ~~~ // FIXME: #5898: should be called `flat_map` fn flat_map_<'r, B, U: Iterator>(self, f: &'r fn(A) -> U) - -> FlatMapIterator<'r, A, B, Self, U>; + -> FlatMapIterator<'r, A, Self, U>; /// Creates an iterator that calls a function with a reference to each /// element before yielding it. This is often useful for debugging an @@ -464,12 +463,12 @@ pub trait IteratorUtil { /// In the future these will be default methods instead of a utility trait. impl> IteratorUtil for T { #[inline] - fn chain_>(self, other: U) -> ChainIterator { + fn chain_>(self, other: U) -> ChainIterator { ChainIterator{a: self, b: other, flag: false} } #[inline] - fn zip>(self, other: U) -> ZipIterator { + fn zip>(self, other: U) -> ZipIterator { ZipIterator{a: self, b: other} } @@ -490,7 +489,7 @@ impl> IteratorUtil for T { } #[inline] - fn enumerate(self) -> EnumerateIterator { + fn enumerate(self) -> EnumerateIterator { EnumerateIterator{iter: self, count: 0} } @@ -505,13 +504,13 @@ impl> IteratorUtil for T { } #[inline] - fn skip(self, n: uint) -> SkipIterator { + fn skip(self, n: uint) -> SkipIterator { SkipIterator{iter: self, n: n} } // FIXME: #5898: should be called take #[inline] - fn take_(self, n: uint) -> TakeIterator { + fn take_(self, n: uint) -> TakeIterator { TakeIterator{iter: self, n: n} } @@ -523,7 +522,7 @@ impl> IteratorUtil for T { #[inline] fn flat_map_<'r, B, U: Iterator>(self, f: &'r fn(A) -> U) - -> FlatMapIterator<'r, A, B, T, U> { + -> FlatMapIterator<'r, A, T, U> { FlatMapIterator{iter: self, f: f, subiter: None } } @@ -758,8 +757,7 @@ impl> OrdIterator for T { } /// A trait for iterators that are clonable. -// FIXME #6967: Dummy A parameter to get around type inference bug -pub trait ClonableIterator { +pub trait ClonableIterator { /// Repeats an iterator endlessly /// /// # Example @@ -770,24 +768,24 @@ pub trait ClonableIterator { /// assert_eq!(cy.next(), Some(1)); /// assert_eq!(cy.next(), Some(1)); /// ~~~ - fn cycle(self) -> CycleIterator; + fn cycle(self) -> CycleIterator; } -impl> ClonableIterator for T { +impl> ClonableIterator for T { #[inline] - fn cycle(self) -> CycleIterator { + fn cycle(self) -> CycleIterator { CycleIterator{orig: self.clone(), iter: self} } } /// An iterator that repeats endlessly #[deriving(Clone)] -pub struct CycleIterator { +pub struct CycleIterator { priv orig: T, priv iter: T, } -impl> Iterator for CycleIterator { +impl> Iterator for CycleIterator { #[inline] fn next(&mut self) -> Option { match self.iter.next() { @@ -808,15 +806,14 @@ impl> Iterator for CycleIterator { } /// An iterator which strings two iterators together -// FIXME #6967: Dummy A parameter to get around type inference bug #[deriving(Clone)] -pub struct ChainIterator { +pub struct ChainIterator { priv a: T, priv b: U, priv flag: bool } -impl, U: Iterator> Iterator for ChainIterator { +impl, U: Iterator> Iterator for ChainIterator { #[inline] fn next(&mut self) -> Option { if self.flag { @@ -853,7 +850,7 @@ impl, U: Iterator> Iterator for ChainIterator { } impl, U: DoubleEndedIterator> DoubleEndedIterator -for ChainIterator { +for ChainIterator { #[inline] fn next_back(&mut self) -> Option { match self.b.next_back() { @@ -864,7 +861,7 @@ for ChainIterator { } impl, U: RandomAccessIterator> RandomAccessIterator -for ChainIterator { +for ChainIterator { #[inline] fn indexable(&self) -> uint { let (a, b) = (self.a.indexable(), self.b.indexable()); @@ -888,14 +885,13 @@ for ChainIterator { } /// An iterator which iterates two other iterators simultaneously -// FIXME #6967: Dummy A & B parameters to get around type inference bug #[deriving(Clone)] -pub struct ZipIterator { +pub struct ZipIterator { priv a: T, priv b: U } -impl, U: Iterator> Iterator<(A, B)> for ZipIterator { +impl, U: Iterator> Iterator<(A, B)> for ZipIterator { #[inline] fn next(&mut self) -> Option<(A, B)> { match (self.a.next(), self.b.next()) { @@ -1042,14 +1038,13 @@ for FilterMapIterator<'self, A, B, T> { } /// An iterator which yields the current count and the element during iteration -// FIXME #6967: Dummy A parameter to get around type inference bug #[deriving(Clone)] -pub struct EnumerateIterator { +pub struct EnumerateIterator { priv iter: T, priv count: uint } -impl> Iterator<(uint, A)> for EnumerateIterator { +impl> Iterator<(uint, A)> for EnumerateIterator { #[inline] fn next(&mut self) -> Option<(uint, A)> { match self.iter.next() { @@ -1141,14 +1136,13 @@ impl<'self, A, T: Iterator> Iterator for TakeWhileIterator<'self, A, T> { } /// An iterator which skips over `n` elements of `iter`. -// FIXME #6967: Dummy A parameter to get around type inference bug #[deriving(Clone)] -pub struct SkipIterator { +pub struct SkipIterator { priv iter: T, priv n: uint } -impl> Iterator for SkipIterator { +impl> Iterator for SkipIterator { #[inline] fn next(&mut self) -> Option { let mut next = self.iter.next(); @@ -1190,14 +1184,13 @@ impl> Iterator for SkipIterator { } /// An iterator which only iterates over the first `n` iterations of `iter`. -// FIXME #6967: Dummy A parameter to get around type inference bug #[deriving(Clone)] -pub struct TakeIterator { +pub struct TakeIterator { priv iter: T, priv n: uint } -impl> Iterator for TakeIterator { +impl> Iterator for TakeIterator { #[inline] fn next(&mut self) -> Option { let next = self.iter.next(); @@ -1249,15 +1242,14 @@ impl<'self, A, B, T: Iterator, St> Iterator for ScanIterator<'self, A, B, /// An iterator that maps each element to an iterator, /// and yields the elements of the produced iterators /// -// FIXME #6967: Dummy B parameter to get around type inference bug -pub struct FlatMapIterator<'self, A, B, T, U> { +pub struct FlatMapIterator<'self, A, T, U> { priv iter: T, priv f: &'self fn(A) -> U, priv subiter: Option, } impl<'self, A, T: Iterator, B, U: Iterator> Iterator for - FlatMapIterator<'self, A, B, T, U> { + FlatMapIterator<'self, A, T, U> { #[inline] fn next(&mut self) -> Option { loop { diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 8dbae43689d..30f2b692452 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -2168,7 +2168,7 @@ pub struct VecIterator<'self, T> { iterator!{impl VecIterator -> &'self T} double_ended_iterator!{impl VecIterator -> &'self T} random_access_iterator!{impl VecIterator -> &'self T} -pub type VecRevIterator<'self, T> = InvertIterator<&'self T, VecIterator<'self, T>>; +pub type VecRevIterator<'self, T> = InvertIterator>; impl<'self, T> Clone for VecIterator<'self, T> { fn clone(&self) -> VecIterator<'self, T> { *self } @@ -2184,7 +2184,7 @@ pub struct VecMutIterator<'self, T> { iterator!{impl VecMutIterator -> &'self mut T} double_ended_iterator!{impl VecMutIterator -> &'self mut T} random_access_iterator!{impl VecMutIterator -> &'self mut T} -pub type VecMutRevIterator<'self, T> = InvertIterator<&'self mut T, VecMutIterator<'self, T>>; +pub type VecMutRevIterator<'self, T> = InvertIterator>; /// An iterator that moves out of a vector. #[deriving(Clone)]