diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 473493938a4..55f37fac2eb 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -228,7 +228,7 @@ impl Iterator<(uint, uint)> for ElementSwaps { #[inline] fn size_hint(&self) -> (uint, Option) { // For a vector of size n, there are exactly n! permutations. - let n = range(2, self.sdir.len() + 1).product(1); + let n = range(2, self.sdir.len() + 1).product(); (n - self.swaps_made, Some(n - self.swaps_made)) } } diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 662349a4b86..04fc85091fa 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -116,7 +116,7 @@ impl StrVector for [S] { } // `len` calculation may overflow but push_str will check boundaries - let len = self.iter().map(|s| s.as_slice().len()).sum(0); + let len = self.iter().map(|s| s.as_slice().len()).sum(); let mut result = String::with_capacity(len); @@ -140,7 +140,7 @@ impl StrVector for [S] { // this is wrong without the guarantee that `self` is non-empty // `len` calculation may overflow but push_str but will check boundaries let len = sep.len() * (self.len() - 1) - + self.iter().map(|s| s.as_slice().len()).sum(0); + + self.iter().map(|s| s.as_slice().len()).sum(); let mut result = String::with_capacity(len); let mut first = true; @@ -2151,7 +2151,7 @@ mod tests { #[test] fn test_str_container() { fn sum_len(v: &[&str]) -> uint { - v.iter().map(|x| x.len()).sum(0) + v.iter().map(|x| x.len()).sum() } let s = String::from_str("01234"); diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index ae0acc32926..774aa8a66d2 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -63,7 +63,7 @@ use cmp; use cmp::Ord; use mem; use num::{ToPrimitive, Int}; -use ops::{Add, Mul}; +use ops::Add; use option::{Option, Some, None}; use uint; #[deprecated = "renamed to Extend"] pub use self::Extend as Extendable; @@ -402,7 +402,7 @@ pub trait Iterator { /// .inspect(|&x| println!("filtering {}", x)) /// .filter(|&x| x % 2 == 0) /// .inspect(|&x| println!("{} made it through", x)) - /// .sum(0); + /// .sum(); /// println!("{}", sum); /// ``` #[inline] @@ -784,17 +784,33 @@ pub trait AdditiveIterator { /// /// let a = [1i, 2, 3, 4, 5]; /// let mut it = a.iter().map(|&x| x); - /// assert!(it.sum(0) == 15); + /// assert!(it.sum() == 15); /// ``` - fn sum(&mut self, init: A) -> A; + fn sum(&mut self) -> A; } -impl, T: Iterator> AdditiveIterator for T { - #[inline] - fn sum(&mut self, init: A) -> A { - self.fold(init, |s, x| s + x) - } +macro_rules! impl_additive { + ($A:ty, $init:expr) => { + impl> AdditiveIterator<$A> for T { + #[inline] + fn sum(&mut self) -> $A { + self.fold($init, |acc, x| acc + x) + } + } + }; } +impl_additive!(i8, 0) +impl_additive!(i16, 0) +impl_additive!(i32, 0) +impl_additive!(i64, 0) +impl_additive!(int, 0) +impl_additive!(u8, 0) +impl_additive!(u16, 0) +impl_additive!(u32, 0) +impl_additive!(u64, 0) +impl_additive!(uint, 0) +impl_additive!(f32, 0.0) +impl_additive!(f64, 0.0) /// A trait for iterators over elements which can be multiplied together. pub trait MultiplicativeIterator { @@ -806,21 +822,37 @@ pub trait MultiplicativeIterator { /// use std::iter::{count, MultiplicativeIterator}; /// /// fn factorial(n: uint) -> uint { - /// count(1u, 1).take_while(|&i| i <= n).product(1) + /// count(1u, 1).take_while(|&i| i <= n).product() /// } /// assert!(factorial(0) == 1); /// assert!(factorial(1) == 1); /// assert!(factorial(5) == 120); /// ``` - fn product(&mut self, init: A) -> A; + fn product(&mut self) -> A; } -impl, T: Iterator> MultiplicativeIterator for T { - #[inline] - fn product(&mut self, init: A) -> A { - self.fold(init, |p, x| p * x) - } +macro_rules! impl_multiplicative { + ($A:ty, $init:expr) => { + impl> MultiplicativeIterator<$A> for T { + #[inline] + fn product(&mut self) -> $A { + self.fold($init, |acc, x| acc * x) + } + } + }; } +impl_multiplicative!(i8, 1) +impl_multiplicative!(i16, 1) +impl_multiplicative!(i32, 1) +impl_multiplicative!(i64, 1) +impl_multiplicative!(int, 1) +impl_multiplicative!(u8, 1) +impl_multiplicative!(u16, 1) +impl_multiplicative!(u32, 1) +impl_multiplicative!(u64, 1) +impl_multiplicative!(uint, 1) +impl_multiplicative!(f32, 1.0) +impl_multiplicative!(f64, 1.0) /// A trait for iterators over elements which can be compared to one another. pub trait OrdIterator { diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs index 2f11307c461..7764fb26c11 100644 --- a/src/libcoretest/iter.rs +++ b/src/libcoretest/iter.rs @@ -294,17 +294,17 @@ fn test_iterator_len() { #[test] fn test_iterator_sum() { let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - assert_eq!(v[0..4].iter().map(|&x| x).sum(0), 6); - assert_eq!(v.iter().map(|&x| x).sum(0), 55); - assert_eq!(v[0..0].iter().map(|&x| x).sum(0), 0); + assert_eq!(v[0..4].iter().map(|&x| x).sum(), 6); + assert_eq!(v.iter().map(|&x| x).sum(), 55); + assert_eq!(v[0..0].iter().map(|&x| x).sum(), 0); } #[test] fn test_iterator_product() { let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - assert_eq!(v[0..4].iter().map(|&x| x).product(1), 0); - assert_eq!(v[1..5].iter().map(|&x| x).product(1), 24); - assert_eq!(v[0..0].iter().map(|&x| x).product(1), 1); + assert_eq!(v[0..4].iter().map(|&x| x).product(), 0); + assert_eq!(v[1..5].iter().map(|&x| x).product(), 24); + assert_eq!(v[0..0].iter().map(|&x| x).product(), 1); } #[test] diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 34b696a416d..a893f8e8959 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -70,7 +70,7 @@ impl<'a> fmt::Show for Matrix<'a> { pretty_printed_matrix.iter().map(|row| row[col].len()).max().unwrap_or(0u) }).collect(); - let total_width = column_widths.iter().map(|n| *n).sum(0) + column_count * 3 + 1; + let total_width = column_widths.iter().map(|n| *n).sum() + column_count * 3 + 1; let br = String::from_char(total_width, '+'); try!(write!(f, "{}\n", br)); for row in pretty_printed_matrix.into_iter() { diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index 1f7ad8120dc..7b0ebe631e0 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -756,7 +756,7 @@ fn pick_column_to_specialize(def_map: &DefMap, m: &[Match]) -> Option { let total_score = m.iter() .map(|row| row.pats[col]) .map(|pat| pat_score(def_map, pat)) - .sum(0); + .sum(); // Irrefutable columns always go first, they'd only be duplicated in the branches. if total_score == 0 { diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 88a681a85e9..ec289a2d806 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -1194,7 +1194,7 @@ fn ty_of_method_or_bare_fn<'tcx, AC: AstConv<'tcx>>( lifetimes_for_params.push((input_pat, accumulator)); } - if lifetimes_for_params.iter().map(|&(_, ref x)| x.len()).sum(0) == 1 { + if lifetimes_for_params.iter().map(|&(_, ref x)| x.len()).sum() == 1 { implied_output_region = Some(lifetimes_for_params.iter() .filter_map(|&(_, ref x)| diff --git a/src/librustdoc/stability_summary.rs b/src/librustdoc/stability_summary.rs index b6b082fe14c..b0e1aeea3a1 100644 --- a/src/librustdoc/stability_summary.rs +++ b/src/librustdoc/stability_summary.rs @@ -15,7 +15,6 @@ use std::ops::Add; use std::num::Zero; -use std::iter::AdditiveIterator; use syntax::attr::{Deprecated, Experimental, Unstable, Stable, Frozen, Locked}; use syntax::ast::Public; @@ -152,14 +151,14 @@ fn summarize_item(item: &Item) -> (Counts, Option) { let subcounts = subitems.iter().filter(|i| visible(*i)) .map(summarize_item) .map(|s| s.val0()) - .sum(Counts::zero()); + .fold(Counts::zero(), |acc, x| acc + x); (item_counts + subcounts, None) } // `pub` automatically EnumItem(Enum { variants: ref subitems, .. }) => { let subcounts = subitems.iter().map(summarize_item) .map(|s| s.val0()) - .sum(Counts::zero()); + .fold(Counts::zero(), |acc, x| acc + x); (item_counts + subcounts, None) } TraitItem(Trait { @@ -177,7 +176,7 @@ fn summarize_item(item: &Item) -> (Counts, Option) { .map(extract_item) .map(summarize_item) .map(|s| s.val0()) - .sum(Counts::zero()); + .fold(Counts::zero(), |acc, x| acc + x); (item_counts + subcounts, None) } ModuleItem(Module { ref items, .. }) => { diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index cdc18a19f51..9918e939097 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -356,7 +356,7 @@ impl Path { Some(vec![SEP_BYTE]) } else { let n = if is_abs { comps.len() } else { comps.len() - 1} + - comps.iter().map(|v| v.len()).sum(0); + comps.iter().map(|v| v.len()).sum(); let mut v = Vec::with_capacity(n); let mut it = comps.into_iter(); if !is_abs { diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index 8c4d3e1ab4f..3a5350f0a29 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -781,7 +781,7 @@ impl Path { let prefix_ = s.slice_to(prefix_len(prefix)); let n = prefix_.len() + if is_abs { comps.len() } else { comps.len() - 1} + - comps.iter().map(|v| v.len()).sum(0); + comps.iter().map(|v| v.len()).sum(); let mut s = String::with_capacity(n); match prefix { Some(DiskPrefix) => { diff --git a/src/libunicode/u_str.rs b/src/libunicode/u_str.rs index 674633c9422..50f257c9c85 100644 --- a/src/libunicode/u_str.rs +++ b/src/libunicode/u_str.rs @@ -153,7 +153,7 @@ impl UnicodeStrPrelude for str { #[inline] fn width(&self, is_cjk: bool) -> uint { - self.chars().map(|c| c.width(is_cjk).unwrap_or(0)).sum(0) + self.chars().map(|c| c.width(is_cjk).unwrap_or(0)).sum() } #[inline] diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs index 75f7a21ce0d..c5f2fbb1890 100644 --- a/src/test/bench/shootout-spectralnorm.rs +++ b/src/test/bench/shootout-spectralnorm.rs @@ -105,7 +105,7 @@ fn A(i: uint, j: uint) -> f64 { } fn dot(v: &[f64], u: &[f64]) -> f64 { - v.iter().zip(u.iter()).map(|(a, b)| *a * *b).sum(0.0) + v.iter().zip(u.iter()).map(|(a, b)| *a * *b).sum() } // Executes a closure in parallel over the given mutable slice. The closure `f` diff --git a/src/test/run-pass/issue-15673.rs b/src/test/run-pass/issue-15673.rs index e45c81f1a0c..051d98aa1d8 100644 --- a/src/test/run-pass/issue-15673.rs +++ b/src/test/run-pass/issue-15673.rs @@ -11,5 +11,5 @@ use std::iter::AdditiveIterator; fn main() { let x: [u64, ..3] = [1, 2, 3]; - assert_eq!(6, range(0, 3).map(|i| x[i]).sum(0)); + assert_eq!(6, range(0, 3).map(|i| x[i]).sum()); }