From 4b45f478818386cfe8554e3a5595c2cf38541b45 Mon Sep 17 00:00:00 2001 From: blake2-ppc Date: Sat, 27 Jul 2013 23:41:20 +0200 Subject: std: Rename Iterator adaptor types to drop the -Iterator suffix Drop the "Iterator" suffix for the the structs in std::iterator. Filter, Zip, Chain etc. are shorter type names for when iterator pipelines need their types written out in full in return value types, so it's easier to read and write. the iterator module already forms enough namespace. --- src/libstd/hashmap.rs | 6 +- src/libstd/iterator.rs | 178 ++++++++++++++++++++++++------------------------- src/libstd/str.rs | 7 +- src/libstd/vec.rs | 4 +- 4 files changed, 97 insertions(+), 98 deletions(-) (limited to 'src/libstd') diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs index d78d0cd8e63..a9a11b611d6 100644 --- a/src/libstd/hashmap.rs +++ b/src/libstd/hashmap.rs @@ -19,7 +19,7 @@ use container::{Container, Mutable, Map, MutableMap, Set, MutableSet}; use clone::Clone; use cmp::{Eq, Equiv}; use hash::Hash; -use iterator::{Iterator, IteratorUtil, FromIterator, ChainIterator}; +use iterator::{Iterator, IteratorUtil, FromIterator, Chain}; use num; use option::{None, Option, Some}; use rand::RngUtil; @@ -751,7 +751,7 @@ impl HashSet { /// Visit the values representing the symmetric difference pub fn symmetric_difference_iter<'a>(&'a self, other: &'a HashSet) - -> ChainIterator, SetAlgebraIter<'a, T>> { + -> Chain, SetAlgebraIter<'a, T>> { self.difference_iter(other).chain_(other.difference_iter(self)) } @@ -764,7 +764,7 @@ impl HashSet { /// Visit the values representing the union pub fn union_iter<'a>(&'a self, other: &'a HashSet) - -> ChainIterator, SetAlgebraIter<'a, T>> { + -> Chain, SetAlgebraIter<'a, T>> { self.iter().chain_(other.difference_iter(self)) } diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs index 2ec8ea41bfb..6828de51622 100644 --- a/src/libstd/iterator.rs +++ b/src/libstd/iterator.rs @@ -74,7 +74,7 @@ pub trait RandomAccessIterator: Iterator { /// In the future these will be default methods instead of a utility trait. pub trait DoubleEndedIteratorUtil { /// Flip the direction of the iterator - fn invert(self) -> InvertIterator; + fn invert(self) -> Invert; } /// Iterator adaptors provided for every `DoubleEndedIterator` implementation. @@ -83,25 +83,25 @@ pub trait DoubleEndedIteratorUtil { impl> DoubleEndedIteratorUtil for T { /// Flip the direction of the iterator #[inline] - fn invert(self) -> InvertIterator { - InvertIterator{iter: self} + fn invert(self) -> Invert { + Invert{iter: self} } } /// An double-ended iterator with the direction inverted #[deriving(Clone)] -pub struct InvertIterator { +pub struct Invert { priv iter: T } -impl> Iterator for InvertIterator { +impl> Iterator for Invert { #[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 Invert { #[inline] fn next_back(&mut self) -> Option { self.iter.next() } } @@ -125,7 +125,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) -> Chain; /// Creates an iterator which iterates over both this and the specified /// iterators simultaneously, yielding the two elements as pairs. When @@ -141,7 +141,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) -> Zip; // FIXME: #5898: should be called map /// Creates a new iterator which will apply the specified function to each @@ -156,7 +156,7 @@ pub trait IteratorUtil { /// assert_eq!(it.next().get(), 4); /// assert!(it.next().is_none()); /// ~~~ - fn transform<'r, B>(self, f: &'r fn(A) -> B) -> MapIterator<'r, A, B, Self>; + fn transform<'r, B>(self, f: &'r fn(A) -> B) -> Map<'r, A, B, Self>; /// Creates an iterator which applies the predicate to each element returned /// by this iterator. Only elements which have the predicate evaluate to @@ -170,7 +170,7 @@ pub trait IteratorUtil { /// assert_eq!(it.next().get(), &2); /// assert!(it.next().is_none()); /// ~~~ - fn filter<'r>(self, predicate: &'r fn(&A) -> bool) -> FilterIterator<'r, A, Self>; + fn filter<'r>(self, predicate: &'r fn(&A) -> bool) -> Filter<'r, A, Self>; /// Creates an iterator which both filters and maps elements. /// If the specified function returns None, the element is skipped. @@ -184,7 +184,7 @@ pub trait IteratorUtil { /// assert_eq!(it.next().get(), 4); /// assert!(it.next().is_none()); /// ~~~ - fn filter_map<'r, B>(self, f: &'r fn(A) -> Option) -> FilterMapIterator<'r, A, B, Self>; + fn filter_map<'r, B>(self, f: &'r fn(A) -> Option) -> FilterMap<'r, A, B, Self>; /// Creates an iterator which yields a pair of the value returned by this /// iterator plus the current index of iteration. @@ -198,7 +198,7 @@ pub trait IteratorUtil { /// assert_eq!(it.next().get(), (1, &200)); /// assert!(it.next().is_none()); /// ~~~ - fn enumerate(self) -> EnumerateIterator; + fn enumerate(self) -> Enumerate; /// Creates an iterator which invokes the predicate on elements until it /// returns false. Once the predicate returns false, all further elements are @@ -214,7 +214,7 @@ pub trait IteratorUtil { /// assert_eq!(it.next().get(), &1); /// assert!(it.next().is_none()); /// ~~~ - fn skip_while<'r>(self, predicate: &'r fn(&A) -> bool) -> SkipWhileIterator<'r, A, Self>; + fn skip_while<'r>(self, predicate: &'r fn(&A) -> bool) -> SkipWhile<'r, A, Self>; /// Creates an iterator which yields elements so long as the predicate /// returns true. After the predicate returns false for the first time, no @@ -229,7 +229,7 @@ pub trait IteratorUtil { /// assert_eq!(it.next().get(), &2); /// assert!(it.next().is_none()); /// ~~~ - fn take_while<'r>(self, predicate: &'r fn(&A) -> bool) -> TakeWhileIterator<'r, A, Self>; + fn take_while<'r>(self, predicate: &'r fn(&A) -> bool) -> TakeWhile<'r, A, Self>; /// Creates an iterator which skips the first `n` elements of this iterator, /// and then it yields all further items. @@ -243,7 +243,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) -> Skip; // FIXME: #5898: should be called take /// Creates an iterator which yields the first `n` elements of this @@ -259,12 +259,12 @@ 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) -> Take; /// 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 /// mutated as necessary. The yielded values from the closure are yielded - /// from the ScanIterator instance when not None. + /// from the Scan instance when not None. /// /// # Example /// @@ -282,7 +282,7 @@ pub trait IteratorUtil { /// assert!(it.next().is_none()); /// ~~~ fn scan<'r, St, B>(self, initial_state: St, f: &'r fn(&mut St, A) -> Option) - -> ScanIterator<'r, A, B, Self, St>; + -> Scan<'r, A, B, Self, St>; /// Creates an iterator that maps each element to an iterator, /// and yields the elements of the produced iterators @@ -302,7 +302,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, Self, U>; + -> FlatMap<'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 @@ -321,7 +321,7 @@ pub trait IteratorUtil { ///println(sum.to_str()); /// ~~~ // FIXME: #5898: should be called `peek` - fn peek_<'r>(self, f: &'r fn(&A)) -> PeekIterator<'r, A, Self>; + fn peek_<'r>(self, f: &'r fn(&A)) -> Peek<'r, A, Self>; /// An adaptation of an external iterator to the for-loop protocol of rust. /// @@ -469,73 +469,73 @@ 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 { - ChainIterator{a: self, b: other, flag: false} + fn chain_>(self, other: U) -> Chain { + Chain{a: self, b: other, flag: false} } #[inline] - fn zip>(self, other: U) -> ZipIterator { - ZipIterator{a: self, b: other} + fn zip>(self, other: U) -> Zip { + Zip{a: self, b: other} } // FIXME: #5898: should be called map #[inline] - fn transform<'r, B>(self, f: &'r fn(A) -> B) -> MapIterator<'r, A, B, T> { - MapIterator{iter: self, f: f} + fn transform<'r, B>(self, f: &'r fn(A) -> B) -> Map<'r, A, B, T> { + Map{iter: self, f: f} } #[inline] - fn filter<'r>(self, predicate: &'r fn(&A) -> bool) -> FilterIterator<'r, A, T> { - FilterIterator{iter: self, predicate: predicate} + fn filter<'r>(self, predicate: &'r fn(&A) -> bool) -> Filter<'r, A, T> { + Filter{iter: self, predicate: predicate} } #[inline] - fn filter_map<'r, B>(self, f: &'r fn(A) -> Option) -> FilterMapIterator<'r, A, B, T> { - FilterMapIterator { iter: self, f: f } + fn filter_map<'r, B>(self, f: &'r fn(A) -> Option) -> FilterMap<'r, A, B, T> { + FilterMap { iter: self, f: f } } #[inline] - fn enumerate(self) -> EnumerateIterator { - EnumerateIterator{iter: self, count: 0} + fn enumerate(self) -> Enumerate { + Enumerate{iter: self, count: 0} } #[inline] - fn skip_while<'r>(self, predicate: &'r fn(&A) -> bool) -> SkipWhileIterator<'r, A, T> { - SkipWhileIterator{iter: self, flag: false, predicate: predicate} + fn skip_while<'r>(self, predicate: &'r fn(&A) -> bool) -> SkipWhile<'r, A, T> { + SkipWhile{iter: self, flag: false, predicate: predicate} } #[inline] - fn take_while<'r>(self, predicate: &'r fn(&A) -> bool) -> TakeWhileIterator<'r, A, T> { - TakeWhileIterator{iter: self, flag: false, predicate: predicate} + fn take_while<'r>(self, predicate: &'r fn(&A) -> bool) -> TakeWhile<'r, A, T> { + TakeWhile{iter: self, flag: false, predicate: predicate} } #[inline] - fn skip(self, n: uint) -> SkipIterator { - SkipIterator{iter: self, n: n} + fn skip(self, n: uint) -> Skip { + Skip{iter: self, n: n} } // FIXME: #5898: should be called take #[inline] - fn take_(self, n: uint) -> TakeIterator { - TakeIterator{iter: self, n: n} + fn take_(self, n: uint) -> Take { + Take{iter: self, n: n} } #[inline] fn scan<'r, St, B>(self, initial_state: St, f: &'r fn(&mut St, A) -> Option) - -> ScanIterator<'r, A, B, T, St> { - ScanIterator{iter: self, f: f, state: initial_state} + -> Scan<'r, A, B, T, St> { + Scan{iter: self, f: f, state: initial_state} } #[inline] fn flat_map_<'r, B, U: Iterator>(self, f: &'r fn(A) -> U) - -> FlatMapIterator<'r, A, T, U> { - FlatMapIterator{iter: self, f: f, subiter: None } + -> FlatMap<'r, A, T, U> { + FlatMap{iter: self, f: f, subiter: None } } // FIXME: #5898: should be called `peek` #[inline] - fn peek_<'r>(self, f: &'r fn(&A)) -> PeekIterator<'r, A, T> { - PeekIterator{iter: self, f: f} + fn peek_<'r>(self, f: &'r fn(&A)) -> Peek<'r, A, T> { + Peek{iter: self, f: f} } /// A shim implementing the `for` loop iteration protocol for iterator objects @@ -774,24 +774,24 @@ pub trait ClonableIterator { /// assert_eq!(cy.next(), Some(1)); /// assert_eq!(cy.next(), Some(1)); /// ~~~ - fn cycle(self) -> CycleIterator; + fn cycle(self) -> Cycle; } impl> ClonableIterator for T { #[inline] - fn cycle(self) -> CycleIterator { - CycleIterator{orig: self.clone(), iter: self} + fn cycle(self) -> Cycle { + Cycle{orig: self.clone(), iter: self} } } /// An iterator that repeats endlessly #[deriving(Clone)] -pub struct CycleIterator { +pub struct Cycle { priv orig: T, priv iter: T, } -impl> Iterator for CycleIterator { +impl> Iterator for Cycle { #[inline] fn next(&mut self) -> Option { match self.iter.next() { @@ -813,13 +813,13 @@ impl> Iterator for CycleIterator { /// An iterator which strings two iterators together #[deriving(Clone)] -pub struct ChainIterator { +pub struct Chain { priv a: T, priv b: U, priv flag: bool } -impl, U: Iterator> Iterator for ChainIterator { +impl, U: Iterator> Iterator for Chain { #[inline] fn next(&mut self) -> Option { if self.flag { @@ -856,7 +856,7 @@ impl, U: Iterator> Iterator for ChainIterator { } impl, U: DoubleEndedIterator> DoubleEndedIterator -for ChainIterator { +for Chain { #[inline] fn next_back(&mut self) -> Option { match self.b.next_back() { @@ -867,7 +867,7 @@ for ChainIterator { } impl, U: RandomAccessIterator> RandomAccessIterator -for ChainIterator { +for Chain { #[inline] fn indexable(&self) -> uint { let (a, b) = (self.a.indexable(), self.b.indexable()); @@ -892,12 +892,12 @@ for ChainIterator { /// An iterator which iterates two other iterators simultaneously #[deriving(Clone)] -pub struct ZipIterator { +pub struct Zip { priv a: T, priv b: U } -impl, U: Iterator> Iterator<(A, B)> for ZipIterator { +impl, U: Iterator> Iterator<(A, B)> for Zip { #[inline] fn next(&mut self) -> Option<(A, B)> { match (self.a.next(), self.b.next()) { @@ -925,12 +925,12 @@ impl, U: Iterator> Iterator<(A, B)> for ZipIterator { +pub struct Map<'self, A, B, T> { priv iter: T, priv f: &'self fn(A) -> B } -impl<'self, A, B, T: Iterator> Iterator for MapIterator<'self, A, B, T> { +impl<'self, A, B, T: Iterator> Iterator for Map<'self, A, B, T> { #[inline] fn next(&mut self) -> Option { match self.iter.next() { @@ -946,7 +946,7 @@ impl<'self, A, B, T: Iterator> Iterator for MapIterator<'self, A, B, T> { } impl<'self, A, B, T: DoubleEndedIterator> DoubleEndedIterator -for MapIterator<'self, A, B, T> { +for Map<'self, A, B, T> { #[inline] fn next_back(&mut self) -> Option { match self.iter.next_back() { @@ -957,12 +957,12 @@ for MapIterator<'self, A, B, T> { } /// An iterator which filters the elements of `iter` with `predicate` -pub struct FilterIterator<'self, A, T> { +pub struct Filter<'self, A, T> { priv iter: T, priv predicate: &'self fn(&A) -> bool } -impl<'self, A, T: Iterator> Iterator for FilterIterator<'self, A, T> { +impl<'self, A, T: Iterator> Iterator for Filter<'self, A, T> { #[inline] fn next(&mut self) -> Option { for self.iter.advance |x| { @@ -982,7 +982,7 @@ impl<'self, A, T: Iterator> Iterator for FilterIterator<'self, A, T> { } } -impl<'self, A, T: DoubleEndedIterator> DoubleEndedIterator for FilterIterator<'self, A, T> { +impl<'self, A, T: DoubleEndedIterator> DoubleEndedIterator for Filter<'self, A, T> { #[inline] fn next_back(&mut self) -> Option { loop { @@ -1001,12 +1001,12 @@ impl<'self, A, T: DoubleEndedIterator> DoubleEndedIterator for FilterItera } /// An iterator which uses `f` to both filter and map elements from `iter` -pub struct FilterMapIterator<'self, A, B, T> { +pub struct FilterMap<'self, A, B, T> { priv iter: T, priv f: &'self fn(A) -> Option } -impl<'self, A, B, T: Iterator> Iterator for FilterMapIterator<'self, A, B, T> { +impl<'self, A, B, T: Iterator> Iterator for FilterMap<'self, A, B, T> { #[inline] fn next(&mut self) -> Option { for self.iter.advance |x| { @@ -1026,7 +1026,7 @@ impl<'self, A, B, T: Iterator> Iterator for FilterMapIterator<'self, A, B, } impl<'self, A, B, T: DoubleEndedIterator> DoubleEndedIterator -for FilterMapIterator<'self, A, B, T> { +for FilterMap<'self, A, B, T> { #[inline] fn next_back(&mut self) -> Option { loop { @@ -1045,12 +1045,12 @@ for FilterMapIterator<'self, A, B, T> { /// An iterator which yields the current count and the element during iteration #[deriving(Clone)] -pub struct EnumerateIterator { +pub struct Enumerate { priv iter: T, priv count: uint } -impl> Iterator<(uint, A)> for EnumerateIterator { +impl> Iterator<(uint, A)> for Enumerate { #[inline] fn next(&mut self) -> Option<(uint, A)> { match self.iter.next() { @@ -1070,13 +1070,13 @@ impl> Iterator<(uint, A)> for EnumerateIterator { } /// An iterator which rejects elements while `predicate` is true -pub struct SkipWhileIterator<'self, A, T> { +pub struct SkipWhile<'self, A, T> { priv iter: T, priv flag: bool, priv predicate: &'self fn(&A) -> bool } -impl<'self, A, T: Iterator> Iterator for SkipWhileIterator<'self, A, T> { +impl<'self, A, T: Iterator> Iterator for SkipWhile<'self, A, T> { #[inline] fn next(&mut self) -> Option { let mut next = self.iter.next(); @@ -1108,13 +1108,13 @@ impl<'self, A, T: Iterator> Iterator for SkipWhileIterator<'self, A, T> { } /// An iterator which only accepts elements while `predicate` is true -pub struct TakeWhileIterator<'self, A, T> { +pub struct TakeWhile<'self, A, T> { priv iter: T, priv flag: bool, priv predicate: &'self fn(&A) -> bool } -impl<'self, A, T: Iterator> Iterator for TakeWhileIterator<'self, A, T> { +impl<'self, A, T: Iterator> Iterator for TakeWhile<'self, A, T> { #[inline] fn next(&mut self) -> Option { if self.flag { @@ -1143,12 +1143,12 @@ impl<'self, A, T: Iterator> Iterator for TakeWhileIterator<'self, A, T> { /// An iterator which skips over `n` elements of `iter`. #[deriving(Clone)] -pub struct SkipIterator { +pub struct Skip { priv iter: T, priv n: uint } -impl> Iterator for SkipIterator { +impl> Iterator for Skip { #[inline] fn next(&mut self) -> Option { let mut next = self.iter.next(); @@ -1191,12 +1191,12 @@ impl> Iterator for SkipIterator { /// An iterator which only iterates over the first `n` iterations of `iter`. #[deriving(Clone)] -pub struct TakeIterator { +pub struct Take { priv iter: T, priv n: uint } -impl> Iterator for TakeIterator { +impl> Iterator for Take { #[inline] fn next(&mut self) -> Option { let next = self.iter.next(); @@ -1224,7 +1224,7 @@ impl> Iterator for TakeIterator { } /// An iterator to maintain state while iterating another iterator -pub struct ScanIterator<'self, A, B, T, St> { +pub struct Scan<'self, A, B, T, St> { priv iter: T, priv f: &'self fn(&mut St, A) -> Option, @@ -1232,7 +1232,7 @@ pub struct ScanIterator<'self, A, B, T, St> { state: St } -impl<'self, A, B, T: Iterator, St> Iterator for ScanIterator<'self, A, B, T, St> { +impl<'self, A, B, T: Iterator, St> Iterator for Scan<'self, A, B, T, St> { #[inline] fn next(&mut self) -> Option { self.iter.next().chain(|a| (self.f)(&mut self.state, a)) @@ -1248,14 +1248,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 /// -pub struct FlatMapIterator<'self, A, T, U> { +pub struct FlatMap<'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, T, U> { + FlatMap<'self, A, T, U> { #[inline] fn next(&mut self) -> Option { loop { @@ -1274,12 +1274,12 @@ impl<'self, A, T: Iterator, B, U: Iterator> Iterator for /// An iterator that calls a function with a reference to each /// element before yielding it. -pub struct PeekIterator<'self, A, T> { +pub struct Peek<'self, A, T> { priv iter: T, priv f: &'self fn(&A) } -impl<'self, A, T: Iterator> Iterator for PeekIterator<'self, A, T> { +impl<'self, A, T: Iterator> Iterator for Peek<'self, A, T> { #[inline] fn next(&mut self) -> Option { let next = self.iter.next(); @@ -1298,7 +1298,7 @@ impl<'self, A, T: Iterator> Iterator for PeekIterator<'self, A, T> { } } -impl<'self, A, T: DoubleEndedIterator> DoubleEndedIterator for PeekIterator<'self, A, T> { +impl<'self, A, T: DoubleEndedIterator> DoubleEndedIterator for Peek<'self, A, T> { #[inline] fn next_back(&mut self) -> Option { let next = self.iter.next_back(); @@ -1313,26 +1313,26 @@ impl<'self, A, T: DoubleEndedIterator> DoubleEndedIterator for PeekIterato } /// An iterator which just modifies the contained state throughout iteration. -pub struct UnfoldrIterator<'self, A, St> { +pub struct Unfoldr<'self, A, St> { priv f: &'self fn(&mut St) -> Option, /// Internal state that will be yielded on the next iteration state: St } -impl<'self, A, St> UnfoldrIterator<'self, A, St> { +impl<'self, A, St> Unfoldr<'self, A, St> { /// Creates a new iterator with the specified closure as the "iterator /// function" and an initial state to eventually pass to the iterator #[inline] pub fn new<'a>(initial_state: St, f: &'a fn(&mut St) -> Option) - -> UnfoldrIterator<'a, A, St> { - UnfoldrIterator { + -> Unfoldr<'a, A, St> { + Unfoldr { f: f, state: initial_state } } } -impl<'self, A, St> Iterator for UnfoldrIterator<'self, A, St> { +impl<'self, A, St> Iterator for Unfoldr<'self, A, St> { #[inline] fn next(&mut self) -> Option { (self.f)(&mut self.state) @@ -1534,7 +1534,7 @@ mod tests { } } - let mut it = UnfoldrIterator::new(0, count); + let mut it = Unfoldr::new(0, count); let mut i = 0; for it.advance |counted| { assert_eq!(counted, i); diff --git a/src/libstd/str.rs b/src/libstd/str.rs index c616689d966..2aa5f586dd8 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -23,7 +23,7 @@ use char::Char; use clone::Clone; use container::{Container, Mutable}; use iter::Times; -use iterator::{Iterator, FromIterator, IteratorUtil, FilterIterator, AdditiveIterator, MapIterator}; +use iterator::{Iterator, FromIterator, IteratorUtil, Filter, AdditiveIterator, Map}; use libc; use num::Zero; use option::{None, Option, Some}; @@ -295,12 +295,11 @@ pub struct CharSplitIterator<'self,Sep> { /// An iterator over the words of a string, separated by an sequence of whitespace pub type WordIterator<'self> = - FilterIterator<'self, &'self str, - CharSplitIterator<'self, extern "Rust" fn(char) -> bool>>; + Filter<'self, &'self str, CharSplitIterator<'self, extern "Rust" fn(char) -> bool>>; /// An iterator over the lines of a string, separated by either `\n` or (`\r\n`). pub type AnyLineIterator<'self> = - MapIterator<'self, &'self str, &'self str, CharSplitIterator<'self, char>>; + Map<'self, &'self str, &'self str, CharSplitIterator<'self, char>>; impl<'self, Sep: CharEq> Iterator<&'self str> for CharSplitIterator<'self, Sep> { #[inline] diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 7c25d091194..fdfe357ae51 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -2166,7 +2166,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 RevIterator<'self, T> = InvertIterator>; +pub type RevIterator<'self, T> = Invert>; impl<'self, T> Clone for VecIterator<'self, T> { fn clone(&self) -> VecIterator<'self, T> { *self } @@ -2182,7 +2182,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 MutRevIterator<'self, T> = InvertIterator>; +pub type MutRevIterator<'self, T> = Invert>; /// An iterator that moves out of a vector. #[deriving(Clone)] -- cgit 1.4.1-3-g733a5