diff options
Diffstat (limited to 'src/libstd')
| -rw-r--r-- | src/libstd/hashmap.rs | 4 | ||||
| -rw-r--r-- | src/libstd/iterator.rs | 61 | ||||
| -rw-r--r-- | src/libstd/rt/kill.rs | 2 | ||||
| -rw-r--r-- | src/libstd/str.rs | 16 | ||||
| -rw-r--r-- | src/libstd/trie.rs | 4 | ||||
| -rw-r--r-- | src/libstd/tuple.rs | 4 | ||||
| -rw-r--r-- | src/libstd/vec.rs | 6 |
7 files changed, 48 insertions, 49 deletions
diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs index 32b3032c53d..5fe47dc6603 100644 --- a/src/libstd/hashmap.rs +++ b/src/libstd/hashmap.rs @@ -977,7 +977,7 @@ mod test_map { fn test_from_iter() { let xs = ~[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; - let map: HashMap<int, int> = xs.iter().transform(|&x| x).collect(); + let map: HashMap<int, int> = xs.iter().map(|&x| x).collect(); for &(k, v) in xs.iter() { assert_eq!(map.find(&k), Some(&v)); @@ -1169,7 +1169,7 @@ mod test_set { fn test_from_iter() { let xs = ~[1, 2, 3, 4, 5, 6, 7, 8, 9]; - let set: HashSet<int> = xs.iter().transform(|&x| x).collect(); + let set: HashSet<int> = xs.iter().map(|&x| x).collect(); for x in xs.iter() { assert!(set.contains(x)); diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs index 48d058c6f1c..8718bee283e 100644 --- a/src/libstd/iterator.rs +++ b/src/libstd/iterator.rs @@ -88,7 +88,6 @@ pub trait Iterator<A> { Zip{a: self, b: other} } - // FIXME: #5898: should be called map /// Creates a new iterator which will apply the specified function to each /// element returned by the first, yielding the mapped element instead. /// @@ -96,13 +95,13 @@ pub trait Iterator<A> { /// /// ~~~ {.rust} /// let a = [1, 2]; - /// let mut it = a.iter().transform(|&x| 2 * x); + /// let mut it = a.iter().map(|&x| 2 * x); /// assert_eq!(it.next().get(), 2); /// assert_eq!(it.next().get(), 4); /// assert!(it.next().is_none()); /// ~~~ #[inline] - fn transform<'r, B>(self, f: &'r fn(A) -> B) -> Map<'r, A, B, Self> { + fn map<'r, B>(self, f: &'r fn(A) -> B) -> Map<'r, A, B, Self> { Map{iter: self, f: f} } @@ -288,7 +287,7 @@ pub trait Iterator<A> { /// ~~~ {.rust} ///let xs = [1u, 4, 2, 3, 8, 9, 6]; ///let sum = xs.iter() - /// .transform(|&x| x) + /// .map(|&x| x) /// .peek_(|&x| debug!("filtering %u", x)) /// .filter(|&x| x % 2 == 0) /// .peek_(|&x| debug!("%u made it through", x)) @@ -331,7 +330,7 @@ pub trait Iterator<A> { /// /// ~~~ {.rust} /// let a = [1, 2, 3, 4, 5]; - /// let b: ~[int] = a.iter().transform(|&x| x).collect(); + /// let b: ~[int] = a.iter().map(|&x| x).collect(); /// assert!(a == b); /// ~~~ #[inline] @@ -346,7 +345,7 @@ pub trait Iterator<A> { /// /// ~~~ {.rust} /// let a = [1, 2, 3, 4, 5]; - /// let b: ~[int] = a.iter().transform(|&x| x).to_owned_vec(); + /// let b: ~[int] = a.iter().map(|&x| x).to_owned_vec(); /// assert!(a == b); /// ~~~ #[inline] @@ -612,7 +611,7 @@ pub trait AdditiveIterator<A> { /// /// ~~~ {.rust} /// let a = [1, 2, 3, 4, 5]; - /// let mut it = a.iter().transform(|&x| x); + /// let mut it = a.iter().map(|&x| x); /// assert!(it.sum() == 15); /// ~~~ fn sum(&mut self) -> A; @@ -1547,7 +1546,7 @@ mod tests { assert_eq!(i, expected.len()); let ys = count(30u, 10).take_(4); - let mut it = xs.iter().transform(|&x| x).chain_(ys); + let mut it = xs.iter().map(|&x| x).chain_(ys); let mut i = 0; for x in it { assert_eq!(x, expected[i]); @@ -1662,7 +1661,7 @@ mod tests { let mut n = 0; let ys = xs.iter() - .transform(|&x| x) + .map(|&x| x) .peek_(|_| n += 1) .collect::<~[uint]>(); @@ -1731,33 +1730,33 @@ mod tests { #[test] fn test_iterator_sum() { let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - assert_eq!(v.slice(0, 4).iter().transform(|&x| x).sum(), 6); - assert_eq!(v.iter().transform(|&x| x).sum(), 55); - assert_eq!(v.slice(0, 0).iter().transform(|&x| x).sum(), 0); + assert_eq!(v.slice(0, 4).iter().map(|&x| x).sum(), 6); + assert_eq!(v.iter().map(|&x| x).sum(), 55); + assert_eq!(v.slice(0, 0).iter().map(|&x| x).sum(), 0); } #[test] fn test_iterator_product() { let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - assert_eq!(v.slice(0, 4).iter().transform(|&x| x).product(), 0); - assert_eq!(v.slice(1, 5).iter().transform(|&x| x).product(), 24); - assert_eq!(v.slice(0, 0).iter().transform(|&x| x).product(), 1); + assert_eq!(v.slice(0, 4).iter().map(|&x| x).product(), 0); + assert_eq!(v.slice(1, 5).iter().map(|&x| x).product(), 24); + assert_eq!(v.slice(0, 0).iter().map(|&x| x).product(), 1); } #[test] fn test_iterator_max() { let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - assert_eq!(v.slice(0, 4).iter().transform(|&x| x).max(), Some(3)); - assert_eq!(v.iter().transform(|&x| x).max(), Some(10)); - assert_eq!(v.slice(0, 0).iter().transform(|&x| x).max(), None); + assert_eq!(v.slice(0, 4).iter().map(|&x| x).max(), Some(3)); + assert_eq!(v.iter().map(|&x| x).max(), Some(10)); + assert_eq!(v.slice(0, 0).iter().map(|&x| x).max(), None); } #[test] fn test_iterator_min() { let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - assert_eq!(v.slice(0, 4).iter().transform(|&x| x).min(), Some(0)); - assert_eq!(v.iter().transform(|&x| x).min(), Some(0)); - assert_eq!(v.slice(0, 0).iter().transform(|&x| x).min(), None); + assert_eq!(v.slice(0, 4).iter().map(|&x| x).min(), Some(0)); + assert_eq!(v.iter().map(|&x| x).min(), Some(0)); + assert_eq!(v.slice(0, 0).iter().map(|&x| x).min(), None); } #[test] @@ -1775,11 +1774,11 @@ mod tests { assert_eq!(c.take_while(|_| false).size_hint(), (0, None)); assert_eq!(c.skip_while(|_| false).size_hint(), (0, None)); assert_eq!(c.enumerate().size_hint(), (uint::max_value, None)); - assert_eq!(c.chain_(vi.transform(|&i| i)).size_hint(), (uint::max_value, None)); + assert_eq!(c.chain_(vi.map(|&i| i)).size_hint(), (uint::max_value, None)); assert_eq!(c.zip(vi).size_hint(), (10, Some(10))); assert_eq!(c.scan(0, |_,_| Some(0)).size_hint(), (0, None)); assert_eq!(c.filter(|_| false).size_hint(), (0, None)); - assert_eq!(c.transform(|_| 0).size_hint(), (uint::max_value, None)); + assert_eq!(c.map(|_| 0).size_hint(), (uint::max_value, None)); assert_eq!(c.filter_map(|_| Some(0)).size_hint(), (0, None)); assert_eq!(vi.take_(5).size_hint(), (5, Some(5))); @@ -1793,14 +1792,14 @@ mod tests { assert_eq!(vi.zip(v2.iter()).size_hint(), (3, Some(3))); assert_eq!(vi.scan(0, |_,_| Some(0)).size_hint(), (0, Some(10))); assert_eq!(vi.filter(|_| false).size_hint(), (0, Some(10))); - assert_eq!(vi.transform(|i| i+1).size_hint(), (10, Some(10))); + assert_eq!(vi.map(|i| i+1).size_hint(), (10, Some(10))); assert_eq!(vi.filter_map(|_| Some(0)).size_hint(), (0, Some(10))); } #[test] fn test_collect() { let a = ~[1, 2, 3, 4, 5]; - let b: ~[int] = a.iter().transform(|&x| x).collect(); + let b: ~[int] = a.iter().map(|&x| x).collect(); assert_eq!(a, b); } @@ -1864,13 +1863,13 @@ mod tests { let mut it = xs.iter(); it.next(); it.next(); - assert_eq!(it.invert().transform(|&x| x).collect::<~[int]>(), ~[16, 14, 12, 10, 8, 6]); + assert_eq!(it.invert().map(|&x| x).collect::<~[int]>(), ~[16, 14, 12, 10, 8, 6]); } #[test] fn test_double_ended_map() { let xs = [1, 2, 3, 4, 5, 6]; - let mut it = xs.iter().transform(|&x| x * -1); + let mut it = xs.iter().map(|&x| x * -1); assert_eq!(it.next(), Some(-1)); assert_eq!(it.next(), Some(-2)); assert_eq!(it.next_back(), Some(-6)); @@ -2020,7 +2019,7 @@ mod tests { fn test_random_access_peek() { let xs = [1, 2, 3, 4, 5]; - // test .transform and .peek_ that don't implement Clone + // test .map and .peek_ that don't implement Clone let it = xs.iter().peek_(|_| {}); assert_eq!(xs.len(), it.indexable()); for (i, elt) in xs.iter().enumerate() { @@ -2030,11 +2029,11 @@ mod tests { } #[test] - fn test_random_access_transform() { + fn test_random_access_map() { let xs = [1, 2, 3, 4, 5]; - // test .transform and .peek_ that don't implement Clone - let it = xs.iter().transform(|x| *x); + // test .map and .peek_ that don't implement Clone + let it = xs.iter().map(|x| *x); assert_eq!(xs.len(), it.indexable()); for (i, elt) in xs.iter().enumerate() { assert_eq!(Some(*elt), it.idx(i)); diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs index 26c6c9119a1..07b4ea10b6a 100644 --- a/src/libstd/rt/kill.rs +++ b/src/libstd/rt/kill.rs @@ -239,7 +239,7 @@ impl BlockedTask { }; // Even if the task was unkillable before, we use 'Killable' because // multiple pipes will have handles. It does not really mean killable. - handles.move_iter().transform(|x| Killable(x)).collect() + handles.move_iter().map(|x| Killable(x)).collect() } // This assertion has two flavours because the wake involves an atomic op. diff --git a/src/libstd/str.rs b/src/libstd/str.rs index 7f2e5f93bdd..b2c0b5a4fb2 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -185,7 +185,7 @@ impl<'self, S: Str> StrVector for &'self [S] { pub fn concat(&self) -> ~str { if self.is_empty() { return ~""; } - let len = self.iter().transform(|s| s.as_slice().len()).sum(); + let len = self.iter().map(|s| s.as_slice().len()).sum(); let mut s = with_capacity(len); @@ -210,7 +210,7 @@ impl<'self, S: Str> StrVector for &'self [S] { pub fn concat(&self) -> ~str { if self.is_empty() { return ~""; } - let len = self.iter().transform(|s| s.as_slice().len()).sum(); + let len = self.iter().map(|s| s.as_slice().len()).sum(); let mut s = with_capacity(len); @@ -239,7 +239,7 @@ impl<'self, S: Str> StrVector for &'self [S] { // this is wrong without the guarantee that `self` is non-empty let len = sep.len() * (self.len() - 1) - + self.iter().transform(|s| s.as_slice().len()).sum(); + + self.iter().map(|s| s.as_slice().len()).sum(); let mut s = ~""; let mut first = true; @@ -280,7 +280,7 @@ impl<'self, S: Str> StrVector for &'self [S] { // this is wrong without the guarantee that `self` is non-empty let len = sep.len() * (self.len() - 1) - + self.iter().transform(|s| s.as_slice().len()).sum(); + + self.iter().map(|s| s.as_slice().len()).sum(); let mut s = ~""; let mut first = true; @@ -1445,7 +1445,7 @@ impl<'self> StrSlice<'self> for &'self str { /// ~~~ #[inline] fn iter(&self) -> CharIterator<'self> { - self.char_offset_iter().transform(|(_, c)| c) + self.char_offset_iter().map(|(_, c)| c) } /// An iterator over the characters of `self`, in reverse order. @@ -1457,7 +1457,7 @@ impl<'self> StrSlice<'self> for &'self str { /// An iterator over the bytes of `self` #[inline] fn byte_iter(&self) -> ByteIterator<'self> { - self.as_bytes().iter().transform(|&b| b) + self.as_bytes().iter().map(|&b| b) } /// An iterator over the bytes of `self`, in reverse order @@ -1565,7 +1565,7 @@ impl<'self> StrSlice<'self> for &'self str { /// An iterator over the lines of a string, separated by either /// `\n` or (`\r\n`). fn any_line_iter(&self) -> AnyLineIterator<'self> { - do self.line_iter().transform |line| { + do self.line_iter().map |line| { let l = line.len(); if l > 0 && line[l - 1] == '\r' as u8 { line.slice(0, l - 1) } else { line } @@ -3686,7 +3686,7 @@ mod tests { #[test] fn test_str_container() { fn sum_len<S: Container>(v: &[S]) -> uint { - v.iter().transform(|x| x.len()).sum() + v.iter().map(|x| x.len()).sum() } let s = ~"01234"; diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs index fc28e6996ba..0bfee145a3c 100644 --- a/src/libstd/trie.rs +++ b/src/libstd/trie.rs @@ -617,7 +617,7 @@ mod test_map { fn test_from_iter() { let xs = ~[(1u, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; - let map: TrieMap<int> = xs.iter().transform(|&x| x).collect(); + let map: TrieMap<int> = xs.iter().map(|&x| x).collect(); for &(k, v) in xs.iter() { assert_eq!(map.find(&k), Some(&v)); @@ -680,7 +680,7 @@ mod test_set { fn test_from_iter() { let xs = ~[9u, 8, 7, 6, 5, 4, 3, 2, 1]; - let set: TrieSet = xs.iter().transform(|&x| x).collect(); + let set: TrieSet = xs.iter().map(|&x| x).collect(); for x in xs.iter() { assert!(set.contains(x)); diff --git a/src/libstd/tuple.rs b/src/libstd/tuple.rs index 93216a29319..80d1626c084 100644 --- a/src/libstd/tuple.rs +++ b/src/libstd/tuple.rs @@ -102,7 +102,7 @@ impl<'self, fn map<C>(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C] { match *self { (ref a, ref b) => { - a.iter().zip(b.iter()).transform(|(aa, bb)| f(aa, bb)).collect() + a.iter().zip(b.iter()).map(|(aa, bb)| f(aa, bb)).collect() } } } @@ -122,7 +122,7 @@ impl<A:Clone, B:Clone> ExtendedTupleOps<A,B> for (~[A], ~[B]) { fn map<C>(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C] { match *self { (ref a, ref b) => { - a.iter().zip(b.iter()).transform(|(aa, bb)| f(aa, bb)).collect() + a.iter().zip(b.iter()).map(|(aa, bb)| f(aa, bb)).collect() } } } diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 60abe65f94d..c831dd70918 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -1068,10 +1068,10 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] { } /// Deprecated, use iterators where possible - /// (`self.iter().transform(f)`). Apply a function to each element + /// (`self.iter().map(f)`). Apply a function to each element /// of a vector and return the results. fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U] { - self.iter().transform(f).collect() + self.iter().map(f).collect() } /** @@ -2148,7 +2148,7 @@ pub mod bytes { impl<A:Clone> Clone for ~[A] { #[inline] fn clone(&self) -> ~[A] { - self.iter().transform(|item| item.clone()).collect() + self.iter().map(|item| item.clone()).collect() } } |