From 5d46bcc0e40c51b8acbf708971c2ecc51c57c0a3 Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sat, 29 Jun 2013 00:59:41 +1000 Subject: [PATCH 1/9] Remove vec::{rfind, rfind_between, find_between}, replaced by slices and iterator adapators. --- src/librustc/middle/trans/base.rs | 2 +- src/libstd/vec.rs | 119 ------------------------------ 2 files changed, 1 insertion(+), 120 deletions(-) diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index f210a9eb3b726..90d0ee251976e 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -1263,7 +1263,7 @@ pub fn cleanup_and_leave(bcx: block, let mut skip = 0; let mut dest = None; { - let r = vec::rfind((*inf).cleanup_paths, |cp| cp.target == leave); + let r = (*inf).cleanup_paths.rev_iter().find_(|cp| cp.target == leave); for r.iter().advance |cp| { if cp.size == inf.cleanups.len() { Br(bcx, cp.dest); diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index cff4ac10145c7..07319cbd148c4 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -652,44 +652,6 @@ pub fn contains(v: &[T], x: &T) -> bool { false } -/** - * Search for the first element that matches a given predicate within a range - * - * Apply function `f` to each element of `v` within the range - * [`start`, `end`). When function `f` returns true then an option containing - * the element is returned. If `f` matches no elements then none is returned. - */ -pub fn find_between(v: &[T], start: uint, end: uint, - f: &fn(t: &T) -> bool) -> Option { - position_between(v, start, end, f).map(|i| copy v[*i]) -} - -/** - * Search for the last element that matches a given predicate - * - * Apply function `f` to each element of `v` in reverse order. When function - * `f` returns true then an option containing the element is returned. If `f` - * matches no elements then none is returned. - */ -pub fn rfind(v: &[T], f: &fn(t: &T) -> bool) -> Option { - rfind_between(v, 0u, v.len(), f) -} - -/** - * Search for the last element that matches a given predicate within a range - * - * Apply function `f` to each element of `v` in reverse order within the range - * [`start`, `end`). When function `f` returns true then an option containing - * the element is returned. If `f` matches no elements then none is return. - */ -pub fn rfind_between(v: &[T], - start: uint, - end: uint, - f: &fn(t: &T) -> bool) - -> Option { - rposition_between(v, start, end, f).map(|i| copy v[*i]) -} - /// Find the first index containing a matching value pub fn position_elem(v: &[T], x: &T) -> Option { v.iter().position_(|y| *x == *y) @@ -1422,7 +1384,6 @@ impl<'self,T:Eq> ImmutableEqVector for &'self [T] { #[allow(missing_doc)] pub trait ImmutableCopyableVector { fn filtered(&self, f: &fn(&T) -> bool) -> ~[T]; - fn rfind(&self, f: &fn(t: &T) -> bool) -> Option; fn partitioned(&self, f: &fn(&T) -> bool) -> (~[T], ~[T]); unsafe fn unsafe_get(&self, elem: uint) -> T; } @@ -1441,18 +1402,6 @@ impl<'self,T:Copy> ImmutableCopyableVector for &'self [T] { filtered(*self, f) } - /** - * Search for the last element that matches a given predicate - * - * Apply function `f` to each element of `v` in reverse order. When - * function `f` returns true then an option containing the element is - * returned. If `f` matches no elements then none is returned. - */ - #[inline] - fn rfind(&self, f: &fn(t: &T) -> bool) -> Option { - rfind(*self, f) - } - /** * Partitions the vector into those that satisfies the predicate, and * those that do not. @@ -2964,34 +2913,6 @@ mod tests { assert!(position_between(v, 4u, 4u, f).is_none()); } - #[test] - fn test_find_between() { - assert!(find_between([], 0u, 0u, f).is_none()); - - fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } - let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - - assert!(find_between(v, 0u, 0u, f).is_none()); - assert!(find_between(v, 0u, 1u, f).is_none()); - assert_eq!(find_between(v, 0u, 2u, f), Some((1, 'b'))); - assert_eq!(find_between(v, 0u, 3u, f), Some((1, 'b'))); - assert_eq!(find_between(v, 0u, 4u, f), Some((1, 'b'))); - - assert!(find_between(v, 1u, 1u, f).is_none()); - assert_eq!(find_between(v, 1u, 2u, f), Some((1, 'b'))); - assert_eq!(find_between(v, 1u, 3u, f), Some((1, 'b'))); - assert_eq!(find_between(v, 1u, 4u, f), Some((1, 'b'))); - - assert!(find_between(v, 2u, 2u, f).is_none()); - assert!(find_between(v, 2u, 3u, f).is_none()); - assert_eq!(find_between(v, 2u, 4u, f), Some((3, 'b'))); - - assert!(find_between(v, 3u, 3u, f).is_none()); - assert_eq!(find_between(v, 3u, 4u, f), Some((3, 'b'))); - - assert!(find_between(v, 4u, 4u, f).is_none()); - } - #[test] fn test_rposition() { fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } @@ -3030,46 +2951,6 @@ mod tests { assert!(rposition_between(v, 4u, 4u, f).is_none()); } - #[test] - fn test_rfind() { - assert!(rfind([], f).is_none()); - - fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } - fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } - let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - - assert_eq!(rfind(v, f), Some((3, 'b'))); - assert!(rfind(v, g).is_none()); - } - - #[test] - fn test_rfind_between() { - assert!(rfind_between([], 0u, 0u, f).is_none()); - - fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } - let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - - assert!(rfind_between(v, 0u, 0u, f).is_none()); - assert!(rfind_between(v, 0u, 1u, f).is_none()); - assert_eq!(rfind_between(v, 0u, 2u, f), Some((1, 'b'))); - assert_eq!(rfind_between(v, 0u, 3u, f), Some((1, 'b'))); - assert_eq!(rfind_between(v, 0u, 4u, f), Some((3, 'b'))); - - assert!(rfind_between(v, 1u, 1u, f).is_none()); - assert_eq!(rfind_between(v, 1u, 2u, f), Some((1, 'b'))); - assert_eq!(rfind_between(v, 1u, 3u, f), Some((1, 'b'))); - assert_eq!(rfind_between(v, 1u, 4u, f), Some((3, 'b'))); - - assert!(rfind_between(v, 2u, 2u, f).is_none()); - assert!(rfind_between(v, 2u, 3u, f).is_none()); - assert_eq!(rfind_between(v, 2u, 4u, f), Some((3, 'b'))); - - assert!(rfind_between(v, 3u, 3u, f).is_none()); - assert_eq!(rfind_between(v, 3u, 4u, f), Some((3, 'b'))); - - assert!(rfind_between(v, 4u, 4u, f).is_none()); - } - #[test] fn test_bsearch_elem() { assert_eq!(bsearch_elem([1,2,3,4,5], &5), Some(4)); From 45940ed988ab2d04e1dbecceef440071b04c11a9 Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sat, 29 Jun 2013 01:33:23 +1000 Subject: [PATCH 2/9] Remove vec::[r]position_between, replaced by slices & iterators. --- src/libextra/terminfo/parser/compiled.rs | 9 +- src/libstd/vec.rs | 110 ++--------------------- 2 files changed, 13 insertions(+), 106 deletions(-) diff --git a/src/libextra/terminfo/parser/compiled.rs b/src/libextra/terminfo/parser/compiled.rs index 2f36845d79b75..063d26d1424b7 100644 --- a/src/libextra/terminfo/parser/compiled.rs +++ b/src/libextra/terminfo/parser/compiled.rs @@ -291,12 +291,13 @@ pub fn parse(file: @Reader, longnames: bool) -> Result<~TermInfo, ~str> { // Find the offset of the NUL we want to go to - let nulpos = vec::position_between(string_table, offset as uint, - string_table_bytes as uint, |&b| b == 0); + let nulpos = string_table.slice(offset as uint, string_table_bytes as uint) + .iter().position_(|&b| b == 0); match nulpos { - Some(x) => { + Some(len) => { string_map.insert(name.to_owned(), - string_table.slice(offset as uint, x).to_owned()) + string_table.slice(offset as uint, + offset as uint + len).to_owned()) }, None => { return Err(~"invalid file: missing NUL in string_table"); diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 07319cbd148c4..a704e604aa28a 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -193,11 +193,11 @@ pub fn split(v: &[T], f: &fn(t: &T) -> bool) -> ~[~[T]] { let mut start = 0u; let mut result = ~[]; while start < ln { - match position_between(v, start, ln, |t| f(t)) { + match v.slice(start, ln).iter().position_(|t| f(t)) { None => break, Some(i) => { - result.push(v.slice(start, i).to_owned()); - start = i + 1u; + result.push(v.slice(start, start + i).to_owned()); + start += i + 1u; } } } @@ -217,7 +217,7 @@ pub fn splitn(v: &[T], n: uint, f: &fn(t: &T) -> bool) -> ~[~[T]] { let mut count = n; let mut result = ~[]; while start < ln && count > 0u { - match position_between(v, start, ln, |t| f(t)) { + match v.slice(start, ln).iter().position_(|t| f(t)) { None => break, Some(i) => { result.push(v.slice(start, i).to_owned()); @@ -242,7 +242,7 @@ pub fn rsplit(v: &[T], f: &fn(t: &T) -> bool) -> ~[~[T]] { let mut end = ln; let mut result = ~[]; while end > 0 { - match rposition_between(v, 0, end, |t| f(t)) { + match v.slice(0, end).rposition(|t| f(t)) { None => break, Some(i) => { result.push(v.slice(i + 1, end).to_owned()); @@ -267,7 +267,7 @@ pub fn rsplitn(v: &[T], n: uint, f: &fn(t: &T) -> bool) -> ~[~[T]] { let mut count = n; let mut result = ~[]; while end > 0u && count > 0u { - match rposition_between(v, 0u, end, |t| f(t)) { + match v.slice(0, end).rposition(|t| f(t)) { None => break, Some(i) => { result.push(v.slice(i + 1u, end).to_owned()); @@ -657,25 +657,6 @@ pub fn position_elem(v: &[T], x: &T) -> Option { v.iter().position_(|y| *x == *y) } -/** - * Find the first index matching some predicate within a range - * - * Apply function `f` to each element of `v` between the range - * [`start`, `end`). When function `f` returns true then an option containing - * the index is returned. If `f` matches no elements then none is returned. - */ -pub fn position_between(v: &[T], - start: uint, - end: uint, - f: &fn(t: &T) -> bool) - -> Option { - assert!(start <= end); - assert!(end <= v.len()); - let mut i = start; - while i < end { if f(&v[i]) { return Some::(i); } i += 1u; } - None -} - /// Find the last index containing a matching value pub fn rposition_elem(v: &[T], x: &T) -> Option { rposition(v, |y| *x == *y) @@ -689,31 +670,12 @@ pub fn rposition_elem(v: &[T], x: &T) -> Option { * matches no elements then none is returned. */ pub fn rposition(v: &[T], f: &fn(t: &T) -> bool) -> Option { - rposition_between(v, 0u, v.len(), f) -} - -/** - * Find the last index matching some predicate within a range - * - * Apply function `f` to each element of `v` in reverse order between the - * range [`start`, `end`). When function `f` returns true then an option - * containing the index is returned. If `f` matches no elements then none is - * returned. - */ -pub fn rposition_between(v: &[T], start: uint, end: uint, - f: &fn(t: &T) -> bool) -> Option { - assert!(start <= end); - assert!(end <= v.len()); - let mut i = end; - while i > start { - if f(&v[i - 1u]) { return Some::(i - 1u); } - i -= 1u; + for v.rev_iter().enumerate().advance |(i, t)| { + if f(t) { return Some(v.len() - i - 1); } } None } - - /** * Binary search a sorted vector with a comparator function. * @@ -2885,34 +2847,6 @@ mod tests { assert!(position_elem(v1, &4).is_none()); } - #[test] - fn test_position_between() { - assert!(position_between([], 0u, 0u, f).is_none()); - - fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } - let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - - assert!(position_between(v, 0u, 0u, f).is_none()); - assert!(position_between(v, 0u, 1u, f).is_none()); - assert_eq!(position_between(v, 0u, 2u, f), Some(1u)); - assert_eq!(position_between(v, 0u, 3u, f), Some(1u)); - assert_eq!(position_between(v, 0u, 4u, f), Some(1u)); - - assert!(position_between(v, 1u, 1u, f).is_none()); - assert_eq!(position_between(v, 1u, 2u, f), Some(1u)); - assert_eq!(position_between(v, 1u, 3u, f), Some(1u)); - assert_eq!(position_between(v, 1u, 4u, f), Some(1u)); - - assert!(position_between(v, 2u, 2u, f).is_none()); - assert!(position_between(v, 2u, 3u, f).is_none()); - assert_eq!(position_between(v, 2u, 4u, f), Some(3u)); - - assert!(position_between(v, 3u, 3u, f).is_none()); - assert_eq!(position_between(v, 3u, 4u, f), Some(3u)); - - assert!(position_between(v, 4u, 4u, f).is_none()); - } - #[test] fn test_rposition() { fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } @@ -2923,34 +2857,6 @@ mod tests { assert!(rposition(v, g).is_none()); } - #[test] - fn test_rposition_between() { - assert!(rposition_between([], 0u, 0u, f).is_none()); - - fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } - let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - - assert!(rposition_between(v, 0u, 0u, f).is_none()); - assert!(rposition_between(v, 0u, 1u, f).is_none()); - assert_eq!(rposition_between(v, 0u, 2u, f), Some(1u)); - assert_eq!(rposition_between(v, 0u, 3u, f), Some(1u)); - assert_eq!(rposition_between(v, 0u, 4u, f), Some(3u)); - - assert!(rposition_between(v, 1u, 1u, f).is_none()); - assert_eq!(rposition_between(v, 1u, 2u, f), Some(1u)); - assert_eq!(rposition_between(v, 1u, 3u, f), Some(1u)); - assert_eq!(rposition_between(v, 1u, 4u, f), Some(3u)); - - assert!(rposition_between(v, 2u, 2u, f).is_none()); - assert!(rposition_between(v, 2u, 3u, f).is_none()); - assert_eq!(rposition_between(v, 2u, 4u, f), Some(3u)); - - assert!(rposition_between(v, 3u, 3u, f).is_none()); - assert_eq!(rposition_between(v, 3u, 4u, f), Some(3u)); - - assert!(rposition_between(v, 4u, 4u, f).is_none()); - } - #[test] fn test_bsearch_elem() { assert_eq!(bsearch_elem([1,2,3,4,5], &5), Some(4)); From a890c2cbf1dd92d79ade5bd8f04142ae5511943f Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sat, 29 Jun 2013 02:08:32 +1000 Subject: [PATCH 3/9] Convert vec::{rposition, rposition_elem, position_elem, contains} to methods. --- src/libextra/smallintmap.rs | 10 ++- src/librustc/metadata/cstore.rs | 3 +- src/librustc/middle/check_match.rs | 2 +- src/librustc/middle/ty.rs | 6 +- src/librustc/middle/typeck/check/mod.rs | 4 +- src/librustc/middle/typeck/infer/resolve.rs | 3 +- src/librustpkg/tests.rs | 12 ++-- src/libstd/hashmap.rs | 10 +-- src/libstd/os.rs | 4 +- src/libstd/vec.rs | 68 ++++++++------------- src/test/bench/graph500-bfs.rs | 2 +- 11 files changed, 50 insertions(+), 74 deletions(-) diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs index e32c688da379a..b07c05ad76a03 100644 --- a/src/libextra/smallintmap.rs +++ b/src/libextra/smallintmap.rs @@ -383,8 +383,6 @@ mod test_set { use super::SmallIntSet; - use std::vec; - #[test] fn test_disjoint() { let mut xs = SmallIntSet::new(); @@ -456,7 +454,7 @@ mod test_set { let mut i = 0; let expected = [3, 5, 11, 77]; for a.intersection(&b) |x| { - assert!(vec::contains(expected, x)); + assert!(expected.contains(x)); i += 1 } assert_eq!(i, expected.len()); @@ -479,7 +477,7 @@ mod test_set { let mut i = 0; let expected = [1, 5, 11]; for a.difference(&b) |x| { - assert!(vec::contains(expected, x)); + assert!(expected.contains(x)); i += 1 } assert_eq!(i, expected.len()); @@ -504,7 +502,7 @@ mod test_set { let mut i = 0; let expected = [1, 5, 11, 14, 22]; for a.symmetric_difference(&b) |x| { - assert!(vec::contains(expected, x)); + assert!(expected.contains(x)); i += 1 } assert_eq!(i, expected.len()); @@ -533,7 +531,7 @@ mod test_set { let mut i = 0; let expected = [1, 3, 5, 9, 11, 13, 16, 19, 24]; for a.union(&b) |x| { - assert!(vec::contains(expected, x)); + assert!(expected.contains(x)); i += 1 } assert_eq!(i, expected.len()); diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index af5cc9136bdf7..3413cd341ba42 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -17,7 +17,6 @@ use metadata::cstore; use metadata::decoder; use std::hashmap::HashMap; -use std::vec; use extra; use syntax::ast; use syntax::parse::token::ident_interner; @@ -91,7 +90,7 @@ pub fn iter_crate_data(cstore: &CStore, } pub fn add_used_crate_file(cstore: &mut CStore, lib: &Path) { - if !vec::contains(cstore.used_crate_files, lib) { + if !cstore.used_crate_files.contains(lib) { cstore.used_crate_files.push(copy *lib); } } diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index ec5f5205760fc..c27b60477c09e 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -363,7 +363,7 @@ pub fn missing_ctor(cx: &MatchCheckCtxt, for m.iter().advance |r| { let r = pat_ctor_id(cx, r[0]); for r.iter().advance |id| { - if !vec::contains(found, id) { + if !found.contains(id) { found.push(/*bad*/copy *id); } } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 4ed21d73f3e78..8a6fff09c730b 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2323,7 +2323,7 @@ pub fn is_instantiable(cx: ctxt, r_ty: t) -> bool { false } - ty_struct(ref did, _) if vec::contains(*seen, did) => { + ty_struct(ref did, _) if seen.contains(did) => { false } @@ -2339,7 +2339,7 @@ pub fn is_instantiable(cx: ctxt, r_ty: t) -> bool { ts.iter().any_(|t| type_requires(cx, seen, r_ty, *t)) } - ty_enum(ref did, _) if vec::contains(*seen, did) => { + ty_enum(ref did, _) if seen.contains(did) => { false } @@ -3266,7 +3266,7 @@ pub fn occurs_check(tcx: ctxt, sp: span, vid: TyVid, rt: t) { if !type_needs_infer(rt) { return; } // Occurs check! - if vec::contains(vars_in_type(rt), &vid) { + if vars_in_type(rt).contains(&vid) { // Maybe this should be span_err -- however, there's an // assertion later on that the type doesn't contain // variables, so in this case we have to be sure to die. diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index f50b38e6f6cf9..d1edc1cd3630d 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -985,7 +985,7 @@ pub fn do_autoderef(fcx: @mut FnCtxt, sp: span, t: ty::t) -> (ty::t, uint) { // concerned with this, as an error will be reported // on the enum definition as well because the enum is // not instantiable. - if vec::contains(enum_dids, did) { + if enum_dids.contains(did) { return (t1, autoderefs); } enum_dids.push(*did); @@ -3156,7 +3156,7 @@ pub fn check_enum_variants(ccx: @mut CrateCtxt, } } } - if vec::contains(*disr_vals, &*disr_val) { + if disr_vals.contains(&*disr_val) { ccx.tcx.sess.span_err(v.span, "discriminator value already exists"); } diff --git a/src/librustc/middle/typeck/infer/resolve.rs b/src/librustc/middle/typeck/infer/resolve.rs index 2326e2e10efe5..941431ce0e3d1 100644 --- a/src/librustc/middle/typeck/infer/resolve.rs +++ b/src/librustc/middle/typeck/infer/resolve.rs @@ -57,7 +57,6 @@ use middle::typeck::infer::unify::{Root, UnifyInferCtxtMethods}; use util::common::{indent, indenter}; use util::ppaux::ty_to_str; -use std::vec; use syntax::ast; pub static resolve_nested_tvar: uint = 0b0000000001; @@ -204,7 +203,7 @@ impl ResolveState { } pub fn resolve_ty_var(&mut self, vid: TyVid) -> ty::t { - if vec::contains(self.v_seen, &vid) { + if self.v_seen.contains(&vid) { self.err = Some(cyclic_ty(vid)); return ty::mk_var(self.infcx.tcx, vid); } else { diff --git a/src/librustpkg/tests.rs b/src/librustpkg/tests.rs index 0e2a4f33c72c3..697a9f53f1b0b 100644 --- a/src/librustpkg/tests.rs +++ b/src/librustpkg/tests.rs @@ -596,9 +596,9 @@ fn rust_path_contents() { let cwd = os::getcwd().push(".rust"); let parent = cwd.pop().pop().push(".rust"); let grandparent = cwd.pop().pop().pop().push(".rust"); - assert!(vec::contains(p, &cwd)); - assert!(vec::contains(p, &parent)); - assert!(vec::contains(p, &grandparent)); + assert!(p.contains(&cwd)); + assert!(p.contains(&parent)); + assert!(p.contains(&grandparent)); for p.iter().advance() |a_path| { assert!(!a_path.components.is_empty()); } @@ -609,9 +609,9 @@ fn rust_path_contents() { fn rust_path_parse() { os::setenv("RUST_PATH", "/a/b/c:/d/e/f:/g/h/i"); let paths = rust_path(); - assert!(vec::contains(paths, &Path("/g/h/i"))); - assert!(vec::contains(paths, &Path("/d/e/f"))); - assert!(vec::contains(paths, &Path("/a/b/c"))); + assert!(paths.contains(&Path("/g/h/i"))); + assert!(paths.contains(&Path("/d/e/f"))); + assert!(paths.contains(&Path("/a/b/c"))); os::unsetenv("RUST_PATH"); } diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs index 35db229b65d30..85dca1154bc09 100644 --- a/src/libstd/hashmap.rs +++ b/src/libstd/hashmap.rs @@ -939,7 +939,7 @@ mod test_map { mod test_set { use super::*; use container::{Container, Map, Set}; - use vec; + use vec::ImmutableEqVector; use uint; #[test] @@ -1030,7 +1030,7 @@ mod test_set { let mut i = 0; let expected = [3, 5, 11, 77]; for a.intersection(&b) |x| { - assert!(vec::contains(expected, x)); + assert!(expected.contains(x)); i += 1 } assert_eq!(i, expected.len()); @@ -1053,7 +1053,7 @@ mod test_set { let mut i = 0; let expected = [1, 5, 11]; for a.difference(&b) |x| { - assert!(vec::contains(expected, x)); + assert!(expected.contains(x)); i += 1 } assert_eq!(i, expected.len()); @@ -1079,7 +1079,7 @@ mod test_set { let mut i = 0; let expected = [-2, 1, 5, 11, 14, 22]; for a.symmetric_difference(&b) |x| { - assert!(vec::contains(expected, x)); + assert!(expected.contains(x)); i += 1 } assert_eq!(i, expected.len()); @@ -1109,7 +1109,7 @@ mod test_set { let mut i = 0; let expected = [-2, 1, 3, 5, 9, 11, 13, 16, 19, 24]; for a.union(&b) |x| { - assert!(vec::contains(expected, x)); + assert!(expected.contains(x)); i += 1 } assert_eq!(i, expected.len()); diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 1fbcda12dce14..6d13c662ee5de 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -1544,10 +1544,10 @@ mod tests { let mut e = env(); setenv(n, "VALUE"); - assert!(!vec::contains(e, &(copy n, ~"VALUE"))); + assert!(!e.contains(&(copy n, ~"VALUE"))); e = env(); - assert!(vec::contains(e, &(n, ~"VALUE"))); + assert!(e.contains(&(n, ~"VALUE"))); } #[test] diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index a704e604aa28a..e2b0c54b9a460 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -220,9 +220,9 @@ pub fn splitn(v: &[T], n: uint, f: &fn(t: &T) -> bool) -> ~[~[T]] { match v.slice(start, ln).iter().position_(|t| f(t)) { None => break, Some(i) => { - result.push(v.slice(start, i).to_owned()); + result.push(v.slice(start, start + i).to_owned()); // Make sure to skip the separator. - start = i + 1u; + start += i + 1u; count -= 1u; } } @@ -646,36 +646,6 @@ impl<'self, T:Copy> VectorVector for &'self [&'self [T]] { } } -/// Return true if a vector contains an element with the given value -pub fn contains(v: &[T], x: &T) -> bool { - for v.iter().advance |elt| { if *x == *elt { return true; } } - false -} - -/// Find the first index containing a matching value -pub fn position_elem(v: &[T], x: &T) -> Option { - v.iter().position_(|y| *x == *y) -} - -/// Find the last index containing a matching value -pub fn rposition_elem(v: &[T], x: &T) -> Option { - rposition(v, |y| *x == *y) -} - -/** - * Find the last index matching some predicate - * - * Apply function `f` to each element of `v` in reverse order. When function - * `f` returns true then an option containing the index is returned. If `f` - * matches no elements then none is returned. - */ -pub fn rposition(v: &[T], f: &fn(t: &T) -> bool) -> Option { - for v.rev_iter().enumerate().advance |(i, t)| { - if f(t) { return Some(v.len() - i - 1); } - } - None -} - /** * Binary search a sorted vector with a comparator function. * @@ -1265,11 +1235,14 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] { * * Apply function `f` to each element of `v` in reverse order. When * function `f` returns true then an option containing the index is - * returned. If `f` matches no elements then none is returned. + * returned. If `f` matches no elements then None is returned. */ #[inline] fn rposition(&self, f: &fn(t: &T) -> bool) -> Option { - rposition(*self, f) + for self.rev_iter().enumerate().advance |(i, t)| { + if f(t) { return Some(self.len() - i - 1); } + } + None } /// Apply a function to each element of a vector and return the results @@ -1327,19 +1300,26 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] { pub trait ImmutableEqVector { fn position_elem(&self, t: &T) -> Option; fn rposition_elem(&self, t: &T) -> Option; + fn contains(&self, x: &T) -> bool; } impl<'self,T:Eq> ImmutableEqVector for &'self [T] { /// Find the first index containing a matching value #[inline] fn position_elem(&self, x: &T) -> Option { - position_elem(*self, x) + self.iter().position_(|y| *x == *y) } /// Find the last index containing a matching value #[inline] fn rposition_elem(&self, t: &T) -> Option { - rposition_elem(*self, t) + self.rposition(|x| *x == *t) + } + + /// Return true if a vector contains an element with the given value + fn contains(&self, x: &T) -> bool { + for self.iter().advance |elt| { if *x == *elt { return true; } } + false } } @@ -2838,13 +2818,13 @@ mod tests { #[test] fn test_position_elem() { - assert!(position_elem([], &1).is_none()); + assert!([].position_elem(&1).is_none()); let v1 = ~[1, 2, 3, 3, 2, 5]; - assert_eq!(position_elem(v1, &1), Some(0u)); - assert_eq!(position_elem(v1, &2), Some(1u)); - assert_eq!(position_elem(v1, &5), Some(5u)); - assert!(position_elem(v1, &4).is_none()); + assert_eq!(v1.position_elem(&1), Some(0u)); + assert_eq!(v1.position_elem(&2), Some(1u)); + assert_eq!(v1.position_elem(&5), Some(5u)); + assert!(v1.position_elem(&4).is_none()); } #[test] @@ -2853,8 +2833,8 @@ mod tests { fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - assert_eq!(rposition(v, f), Some(3u)); - assert!(rposition(v, g).is_none()); + assert_eq!(v.rposition(f), Some(3u)); + assert!(v.rposition(g).is_none()); } #[test] @@ -3417,7 +3397,7 @@ mod tests { fn test_rposition_fail() { let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)]; let mut i = 0; - do rposition(v) |_elt| { + do v.rposition |_elt| { if i == 2 { fail!() } diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index d21888f12ec67..eeff4b71c0d2f 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -341,7 +341,7 @@ fn validate(edges: ~[(node_id, node_id)], } else { while parent != root { - if vec::contains(path, &parent) { + if path.contains(&parent) { status = false; } From 9e83b2fe556aaf779261503c0910bf378e45dce4 Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sat, 29 Jun 2013 02:54:03 +1000 Subject: [PATCH 4/9] Convert vec::{reverse, swap} to methods. --- src/libextra/priority_queue.rs | 2 +- src/libextra/sort.rs | 42 ++++----- src/libextra/test.rs | 2 +- src/libstd/num/strconv.rs | 5 +- src/libstd/rand.rs | 2 +- src/libstd/vec.rs | 86 ++++++++++--------- .../compile-fail/moves-based-on-type-exprs.rs | 4 +- .../run-pass/coerce-reborrow-mut-vec-arg.rs | 12 ++- .../run-pass/coerce-reborrow-mut-vec-rcvr.rs | 12 --- src/test/run-pass/swap-2.rs | 3 +- 10 files changed, 77 insertions(+), 93 deletions(-) diff --git a/src/libextra/priority_queue.rs b/src/libextra/priority_queue.rs index 4c1163f3d50c7..3d1ca4a9818b6 100644 --- a/src/libextra/priority_queue.rs +++ b/src/libextra/priority_queue.rs @@ -107,7 +107,7 @@ impl PriorityQueue { let mut end = q.len(); while end > 1 { end -= 1; - vec::swap(q.data, 0, end); + q.data.swap(0, end); q.siftdown_range(0, end) } q.to_vec() diff --git a/src/libextra/sort.rs b/src/libextra/sort.rs index 36c12f314b70b..f59a2414aaeb7 100644 --- a/src/libextra/sort.rs +++ b/src/libextra/sort.rs @@ -65,17 +65,17 @@ pub fn merge_sort(v: &[T], le: Le) -> ~[T] { fn part(arr: &mut [T], left: uint, right: uint, pivot: uint, compare_func: Le) -> uint { - vec::swap(arr, pivot, right); + arr.swap(pivot, right); let mut storage_index: uint = left; let mut i: uint = left; while i < right { if compare_func(&arr[i], &arr[right]) { - vec::swap(arr, i, storage_index); + arr.swap(i, storage_index); storage_index += 1; } i += 1; } - vec::swap(arr, storage_index, right); + arr.swap(storage_index, right); return storage_index; } @@ -120,29 +120,29 @@ fn qsort3(arr: &mut [T], left: int, right: int) { j -= 1; } if i >= j { break; } - vec::swap(arr, i as uint, j as uint); + arr.swap(i as uint, j as uint); if arr[i] == v { p += 1; - vec::swap(arr, p as uint, i as uint); + arr.swap(p as uint, i as uint); } if v == arr[j] { q -= 1; - vec::swap(arr, j as uint, q as uint); + arr.swap(j as uint, q as uint); } } - vec::swap(arr, i as uint, right as uint); + arr.swap(i as uint, right as uint); j = i - 1; i += 1; let mut k: int = left; while k < p { - vec::swap(arr, k as uint, j as uint); + arr.swap(k as uint, j as uint); k += 1; j -= 1; if k == arr.len() as int { break; } } k = right - 1; while k > q { - vec::swap(arr, i as uint, k as uint); + arr.swap(i as uint, k as uint); k -= 1; i += 1; if k == 0 { break; } @@ -259,7 +259,7 @@ fn binarysort(array: &mut [T], start: uint) { fn reverse_slice(v: &mut [T], start: uint, end:uint) { let mut i = start; while i < end / 2 { - vec::swap(v, i, end - i - 1); + v.swap(i, end - i - 1); i += 1; } } @@ -479,7 +479,7 @@ impl MergeState { let mut len1 = len1; let mut len2 = len2; - vec::swap(array, dest, c2); + array.swap(dest, c2); dest += 1; c2 += 1; len2 -= 1; if len2 == 0 { @@ -501,7 +501,7 @@ impl MergeState { loop { assert!(len1 > 1 && len2 != 0); if array[c2] < tmp[c1] { - vec::swap(array, dest, c2); + array.swap(dest, c2); dest += 1; c2 += 1; len2 -= 1; count2 += 1; count1 = 0; if len2 == 0 { @@ -534,7 +534,7 @@ impl MergeState { dest += count1; c1 += count1; len1 -= count1; if len1 <= 1 { break_outer = true; break; } } - vec::swap(array, dest, c2); + array.swap(dest, c2); dest += 1; c2 += 1; len2 -= 1; if len2 == 0 { break_outer = true; break; } @@ -589,7 +589,7 @@ impl MergeState { let mut len1 = len1; let mut len2 = len2; - vec::swap(array, dest, c1); + array.swap(dest, c1); dest -= 1; c1 -= 1; len1 -= 1; if len1 == 0 { @@ -613,7 +613,7 @@ impl MergeState { loop { assert!(len1 != 0 && len2 > 1); if tmp[c2] < array[c1] { - vec::swap(array, dest, c1); + array.swap(dest, c1); dest -= 1; c1 -= 1; len1 -= 1; count1 += 1; count2 = 0; if len1 == 0 { @@ -666,7 +666,7 @@ impl MergeState { copy_vec(array, dest+1, tmp.slice(c2+1, c2+1+count2)); if len2 <= 1 { break_outer = true; break; } } - vec::swap(array, dest, c1); + array.swap(dest, c1); dest -= 1; c1 -= 1; len1 -= 1; if len1 == 0 { break_outer = true; break; } min_gallop -= 1; @@ -1049,7 +1049,7 @@ mod big_tests { fn makeRange(n: uint) -> ~[uint] { let one = do vec::from_fn(n) |i| { i }; let mut two = copy one; - vec::reverse(two); + two.reverse(); vec::append(two, one) } @@ -1073,7 +1073,7 @@ mod big_tests { tim_sort(arr); // *sort isSorted(arr); - vec::reverse(arr); + arr.reverse(); tim_sort(arr); // \sort isSorted(arr); @@ -1083,7 +1083,7 @@ mod big_tests { for 3.times { let i1 = rng.gen_uint_range(0, n); let i2 = rng.gen_uint_range(0, n); - vec::swap(arr, i1, i2); + arr.swap(i1, i2); } tim_sort(arr); // 3sort isSorted(arr); @@ -1145,7 +1145,7 @@ mod big_tests { tim_sort(arr); // *sort isSorted(arr); - vec::reverse(arr); + arr.reverse(); tim_sort(arr); // \sort isSorted(arr); @@ -1155,7 +1155,7 @@ mod big_tests { for 3.times { let i1 = rng.gen_uint_range(0, n); let i2 = rng.gen_uint_range(0, n); - vec::swap(arr, i1, i2); + arr.swap(i1, i2); } tim_sort(arr); // 3sort isSorted(arr); diff --git a/src/libextra/test.rs b/src/libextra/test.rs index 886bb9293bba4..1e1e53de9e896 100644 --- a/src/libextra/test.rs +++ b/src/libextra/test.rs @@ -449,7 +449,7 @@ fn run_tests(opts: &TestOpts, debug!("using %u test tasks", concurrency); let mut remaining = filtered_tests; - vec::reverse(remaining); + remaining.reverse(); let mut pending = 0; let (p, ch) = stream(); diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs index a062838aacf04..2ddeb02b56af2 100644 --- a/src/libstd/num/strconv.rs +++ b/src/libstd/num/strconv.rs @@ -18,8 +18,7 @@ use char; use str; use str::{StrSlice}; use kinds::Copy; -use vec; -use vec::{CopyableVector, ImmutableVector}; +use vec::{CopyableVector, ImmutableVector, MutableVector}; use vec::OwnedVector; use num::{NumCast, Zero, One, cast, pow_with_uint}; use f64; @@ -257,7 +256,7 @@ pub fn to_str_bytes_common () } - vec::reverse(buf); + buf.reverse(); // Remember start of the fractional digits. // Points one beyond end of buf if none get generated, diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs index 5baff8aee68dd..5f96e38a55af4 100644 --- a/src/libstd/rand.rs +++ b/src/libstd/rand.rs @@ -590,7 +590,7 @@ impl RngUtil for R { // invariant: elements with index >= i have been locked in place. i -= 1u; // lock element i in place. - vec::swap(values, i, self.gen_uint_range(0u, i + 1u)); + values.swap(i, self.gen_uint_range(0u, i + 1u)); } } } diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index e2b0c54b9a460..bb9b12a43cba4 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -251,7 +251,7 @@ pub fn rsplit(v: &[T], f: &fn(t: &T) -> bool) -> ~[~[T]] { } } result.push(v.slice(0u, end).to_owned()); - reverse(result); + result.reverse(); result } @@ -278,7 +278,7 @@ pub fn rsplitn(v: &[T], n: uint, f: &fn(t: &T) -> bool) -> ~[~[T]] { } } result.push(v.slice(0u, end).to_owned()); - reverse(result); + result.reverse(); result } @@ -751,40 +751,10 @@ pub fn zip(mut v: ~[T], mut u: ~[U]) -> ~[(T, U)] { w.push((v.pop(),u.pop())); i -= 1; } - reverse(w); + w.reverse(); w } -/** - * Swaps two elements in a vector - * - * # Arguments - * - * * v The input vector - * * a - The index of the first element - * * b - The index of the second element - */ -#[inline] -pub fn swap(v: &mut [T], a: uint, b: uint) { - unsafe { - // Can't take two mutable loans from one vector, so instead just cast - // them to their raw pointers to do the swap - let pa: *mut T = &mut v[a]; - let pb: *mut T = &mut v[b]; - ptr::swap_ptr(pa, pb); - } -} - -/// Reverse the order of elements in a vector, in place -pub fn reverse(v: &mut [T]) { - let mut i: uint = 0; - let ln = v.len(); - while i < ln / 2 { - swap(v, i, ln - i - 1); - i += 1; - } -} - /// Returns a vector with the order of elements reversed pub fn reversed(v: &[T]) -> ~[T] { let mut rs: ~[T] = ~[]; @@ -840,8 +810,8 @@ pub fn each_permutation(values: &[T], fun: &fn(perm : &[T]) -> bool) -> } // swap indices[k] and indices[l]; sort indices[k+1..] // (they're just reversed) - vec::swap(indices, k, l); - reverse(indices.mut_slice(k+1, length)); + indices.swap(k, l); + indices.mut_slice(k+1, length).reverse(); // fixup permutation based on indices for uint::range(k, length) |i| { permutation[i] = copy values[indices[i]]; @@ -1598,7 +1568,7 @@ impl OwnedVector for ~[T] { self.push(x); let mut j = len; while j > i { - swap(*self, j, j - 1); + self.swap(j, j - 1); j -= 1; } } @@ -1611,7 +1581,7 @@ impl OwnedVector for ~[T] { let mut j = i; while j < len - 1 { - swap(*self, j, j + 1); + self.swap(j, j + 1); j += 1; } self.pop() @@ -1629,7 +1599,7 @@ impl OwnedVector for ~[T] { fail!("vec::swap_remove - index %u >= length %u", index, ln); } if index < ln - 1 { - swap(*self, index, ln - 1); + self.swap(index, ln - 1); } self.pop() } @@ -1660,7 +1630,7 @@ impl OwnedVector for ~[T] { if !f(&self[i]) { deleted += 1; } else if deleted > 0 { - swap(*self, i - deleted, i); + self.swap(i - deleted, i); } } @@ -1772,6 +1742,10 @@ pub trait MutableVector<'self, T> { fn mut_iter(self) -> VecMutIterator<'self, T>; fn mut_rev_iter(self) -> VecMutRevIterator<'self, T>; + fn swap(self, a: uint, b: uint); + + fn reverse(self); + /** * Consumes `src` and moves as many elements as it can into `self` * from the range [start,end). @@ -1823,6 +1797,34 @@ impl<'self,T> MutableVector<'self, T> for &'self mut [T] { } } + /** + * Swaps two elements in a vector + * + * # Arguments + * + * * a - The index of the first element + * * b - The index of the second element + */ + fn swap(self, a: uint, b: uint) { + unsafe { + // Can't take two mutable loans from one vector, so instead just cast + // them to their raw pointers to do the swap + let pa: *mut T = &mut self[a]; + let pb: *mut T = &mut self[b]; + ptr::swap_ptr(pa, pb); + } + } + + /// Reverse the order of elements in a vector, in place + fn reverse(self) { + let mut i: uint = 0; + let ln = self.len(); + while i < ln / 2 { + self.swap(i, ln - i - 1); + i += 1; + } + } + #[inline] fn move_from(self, mut src: ~[T], start: uint, end: uint) -> uint { for self.mut_iter().zip(src.mut_slice(start, end).mut_iter()).advance |(a, b)| { @@ -2887,7 +2889,7 @@ mod tests { let mut v: ~[int] = ~[10, 20]; assert_eq!(v[0], 10); assert_eq!(v[1], 20); - reverse(v); + v.reverse(); assert_eq!(v[0], 20); assert_eq!(v[1], 10); let v2 = reversed::([10, 20]); @@ -2900,7 +2902,7 @@ mod tests { let v4 = reversed::([]); assert_eq!(v4, ~[]); let mut v3: ~[int] = ~[]; - reverse::(v3); + v3.reverse(); } #[test] @@ -3549,7 +3551,7 @@ mod tests { #[test] fn test_reverse_part() { let mut values = [1,2,3,4,5]; - reverse(values.mut_slice(1, 4)); + values.mut_slice(1, 4).reverse(); assert_eq!(values, [1,4,3,2,5]); } diff --git a/src/test/compile-fail/moves-based-on-type-exprs.rs b/src/test/compile-fail/moves-based-on-type-exprs.rs index 38718006d8b18..fec0f89adbaf8 100644 --- a/src/test/compile-fail/moves-based-on-type-exprs.rs +++ b/src/test/compile-fail/moves-based-on-type-exprs.rs @@ -1,8 +1,6 @@ // Tests that references to move-by-default values trigger moves when // they occur as part of various kinds of expressions. -use std::vec; - struct Foo { f: A } fn guard(_s: ~str) -> bool {fail!()} fn touch(_a: &A) {} @@ -92,7 +90,7 @@ fn f110() { fn f120() { let mut x = ~[~"hi", ~"ho"]; - vec::swap(x, 0, 1); + x.swap(0, 1); touch(&x[0]); touch(&x[1]); } diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs index 3d216c1885f6e..356c159618696 100644 --- a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs +++ b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs @@ -1,13 +1,11 @@ -use std::vec; - -trait Reverser { - fn reverse(&self); +fn reverse(v: &mut [uint]) { + v.reverse(); } fn bar(v: &mut [uint]) { - vec::reverse(v); - vec::reverse(v); - vec::reverse(v); + reverse(v); + reverse(v); + reverse(v); } pub fn main() { diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs index d62ed77fdab32..556d70f3c88a2 100644 --- a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs +++ b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs @@ -1,15 +1,3 @@ -use std::vec; - -trait Reverser { - fn reverse(self); -} - -impl<'self> Reverser for &'self mut [uint] { - fn reverse(self) { - vec::reverse(self); - } -} - fn bar(v: &mut [uint]) { v.reverse(); v.reverse(); diff --git a/src/test/run-pass/swap-2.rs b/src/test/run-pass/swap-2.rs index cf3a465d812de..2ec2eb3c45b57 100644 --- a/src/test/run-pass/swap-2.rs +++ b/src/test/run-pass/swap-2.rs @@ -9,11 +9,10 @@ // except according to those terms. use std::util; -use std::vec; pub fn main() { let mut a: ~[int] = ~[0, 1, 2, 3, 4, 5, 6]; - vec::swap(a, 2, 4); + a.swap(2, 4); assert_eq!(a[2], 4); assert_eq!(a[4], 2); let mut n = 42; From 562dea1820e51f7e87cdeef4024eb9e58c7800d0 Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sat, 29 Jun 2013 11:19:14 +1000 Subject: [PATCH 5/9] etc: update etc/unicode.py for the changes made to std::unicode. --- src/etc/unicode.py | 34 ++++++++++++++++++++++++---------- src/libstd/unicode.rs | 3 +-- 2 files changed, 25 insertions(+), 12 deletions(-) diff --git a/src/etc/unicode.py b/src/etc/unicode.py index afb3d16848085..191338b3cb4f7 100755 --- a/src/etc/unicode.py +++ b/src/etc/unicode.py @@ -122,14 +122,14 @@ def ch_prefix(ix): def emit_bsearch_range_table(f): f.write(""" - pure fn bsearch_range_table(c: char, r: &[(char,char)]) -> bool { - use cmp::{EQ, LT, GT}; + fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool { + use cmp::{Equal, Less, Greater}; use vec::bsearch; use option::None; (do bsearch(r) |&(lo,hi)| { - if lo <= c && c <= hi { EQ } - else if hi < c { LT } - else { GT } + if lo <= c && c <= hi { Equal } + else if hi < c { Less } + else { Greater } }) != None }\n\n """); @@ -140,7 +140,7 @@ def emit_property_module(f, mod, tbl): keys.sort() emit_bsearch_range_table(f); for cat in keys: - f.write(" const %s_table : &[(char,char)] = &[\n" % cat) + f.write(" static %s_table : &'static [(char,char)] = &[\n" % cat) ix = 0 for pair in tbl[cat]: f.write(ch_prefix(ix)) @@ -148,7 +148,7 @@ def emit_property_module(f, mod, tbl): ix += 1 f.write("\n ];\n\n") - f.write(" pub pure fn %s(c: char) -> bool {\n" % cat) + f.write(" pub fn %s(c: char) -> bool {\n" % cat) f.write(" bsearch_range_table(c, %s_table)\n" % cat) f.write(" }\n\n") f.write("}\n") @@ -159,7 +159,7 @@ def emit_property_module_old(f, mod, tbl): keys = tbl.keys() keys.sort() for cat in keys: - f.write(" pure fn %s(c: char) -> bool {\n" % cat) + f.write(" fn %s(c: char) -> bool {\n" % cat) f.write(" ret alt c {\n") prefix = ' ' for pair in tbl[cat]: @@ -236,8 +236,22 @@ def emit_decomp_module(f, canon, compat): (canon_decomp, compat_decomp, gencats) = load_unicode_data("UnicodeData.txt") -# Explain that the source code was generated by this script. -rf.write('// The following code was generated by "src/etc/unicode.py"\n\n') +# Preamble +rf.write('''// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// The following code was generated by "src/etc/unicode.py" + +#[allow(missing_doc)]; + +''') emit_property_module(rf, "general_category", gencats) diff --git a/src/libstd/unicode.rs b/src/libstd/unicode.rs index f8f56c75a295c..fd95588d71297 100644 --- a/src/libstd/unicode.rs +++ b/src/libstd/unicode.rs @@ -1447,10 +1447,8 @@ pub mod general_category { } } - pub mod derived_property { - fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool { use cmp::{Equal, Less, Greater}; use vec::bsearch; @@ -2641,4 +2639,5 @@ pub mod derived_property { pub fn XID_Start(c: char) -> bool { bsearch_range_table(c, XID_Start_table) } + } From faa8f8ff8b7e457f74d74533ebbc0d5a56cf5c72 Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sat, 29 Jun 2013 13:35:25 +1000 Subject: [PATCH 6/9] Convert vec::{bsearch, bsearch_elem} to methods. --- src/etc/unicode.py | 4 +- src/libstd/prelude.rs | 2 +- src/libstd/unicode.rs | 8 +- src/libstd/vec.rs | 167 ++++++++++++++++++++++-------------------- 4 files changed, 95 insertions(+), 86 deletions(-) diff --git a/src/etc/unicode.py b/src/etc/unicode.py index 191338b3cb4f7..2a252f3f1f394 100755 --- a/src/etc/unicode.py +++ b/src/etc/unicode.py @@ -124,9 +124,9 @@ def emit_bsearch_range_table(f): f.write(""" fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool { use cmp::{Equal, Less, Greater}; - use vec::bsearch; + use vec::ImmutableVector; use option::None; - (do bsearch(r) |&(lo,hi)| { + (do r.bsearch |&(lo,hi)| { if lo <= c && c <= hi { Equal } else if hi < c { Less } else { Greater } diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs index 13d19b276f59e..c0049c7505d99 100644 --- a/src/libstd/prelude.rs +++ b/src/libstd/prelude.rs @@ -73,7 +73,7 @@ pub use tuple::{ImmutableTuple2, ImmutableTuple3, ImmutableTuple4, ImmutableTupl pub use tuple::{ImmutableTuple6, ImmutableTuple7, ImmutableTuple8, ImmutableTuple9}; pub use tuple::{ImmutableTuple10, ImmutableTuple11, ImmutableTuple12}; pub use vec::{VectorVector, CopyableVector, ImmutableVector}; -pub use vec::{ImmutableEqVector, ImmutableCopyableVector}; +pub use vec::{ImmutableEqVector, ImmutableTotalOrdVector, ImmutableCopyableVector}; pub use vec::{OwnedVector, OwnedCopyableVector, MutableVector}; pub use io::{Reader, ReaderUtil, Writer, WriterUtil}; diff --git a/src/libstd/unicode.rs b/src/libstd/unicode.rs index fd95588d71297..1e2d5c76feaa0 100644 --- a/src/libstd/unicode.rs +++ b/src/libstd/unicode.rs @@ -16,9 +16,9 @@ pub mod general_category { fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool { use cmp::{Equal, Less, Greater}; - use vec::bsearch; + use vec::ImmutableVector; use option::None; - (do bsearch(r) |&(lo,hi)| { + (do r.bsearch |&(lo,hi)| { if lo <= c && c <= hi { Equal } else if hi < c { Less } else { Greater } @@ -1451,9 +1451,9 @@ pub mod derived_property { fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool { use cmp::{Equal, Less, Greater}; - use vec::bsearch; + use vec::ImmutableVector; use option::None; - (do bsearch(r) |&(lo,hi)| { + (do r.bsearch |&(lo,hi)| { if lo <= c && c <= hi { Equal } else if hi < c { Less } else { Greater } diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index bb9b12a43cba4..d7480617c12e4 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -646,44 +646,6 @@ impl<'self, T:Copy> VectorVector for &'self [&'self [T]] { } } -/** - * Binary search a sorted vector with a comparator function. - * - * The comparator should implement an order consistent with the sort - * order of the underlying vector, returning an order code that indicates - * whether its argument is `Less`, `Equal` or `Greater` the desired target. - * - * Returns the index where the comparator returned `Equal`, or `None` if - * not found. - */ -pub fn bsearch(v: &[T], f: &fn(&T) -> Ordering) -> Option { - let mut base : uint = 0; - let mut lim : uint = v.len(); - - while lim != 0 { - let ix = base + (lim >> 1); - match f(&v[ix]) { - Equal => return Some(ix), - Less => { - base = ix + 1; - lim -= 1; - } - Greater => () - } - lim >>= 1; - } - return None; -} - -/** - * Binary search a sorted vector for a given element. - * - * Returns the index of the element or None if not found. - */ -pub fn bsearch_elem(v: &[T], x: &T) -> Option { - bsearch(v, |p| p.cmp(x)) -} - // FIXME: if issue #586 gets implemented, could have a postcondition // saying the two result lists have the same length -- or, could // return a nominal record with a constraint saying that, instead of @@ -1119,6 +1081,8 @@ pub trait ImmutableVector<'self, T> { fn flat_map(&self, f: &fn(t: &T) -> ~[U]) -> ~[U]; fn filter_mapped(&self, f: &fn(t: &T) -> Option) -> ~[U]; unsafe fn unsafe_ref(&self, index: uint) -> *T; + + fn bsearch(&self, f: &fn(&T) -> Ordering) -> Option; } /// Extension methods for vectors @@ -1264,6 +1228,35 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] { let (ptr, _): (*T, uint) = transmute(*self); ptr.offset(index) } + + /** + * Binary search a sorted vector with a comparator function. + * + * The comparator should implement an order consistent with the sort + * order of the underlying vector, returning an order code that indicates + * whether its argument is `Less`, `Equal` or `Greater` the desired target. + * + * Returns the index where the comparator returned `Equal`, or `None` if + * not found. + */ + fn bsearch(&self, f: &fn(&T) -> Ordering) -> Option { + let mut base : uint = 0; + let mut lim : uint = self.len(); + + while lim != 0 { + let ix = base + (lim >> 1); + match f(&self[ix]) { + Equal => return Some(ix), + Less => { + base = ix + 1; + lim -= 1; + } + Greater => () + } + lim >>= 1; + } + return None; + } } #[allow(missing_doc)] @@ -1293,6 +1286,22 @@ impl<'self,T:Eq> ImmutableEqVector for &'self [T] { } } +#[allow(missing_doc)] +pub trait ImmutableTotalOrdVector { + fn bsearch_elem(&self, x: &T) -> Option; +} + +impl<'self, T: TotalOrd> ImmutableTotalOrdVector for &'self [T] { + /** + * Binary search a sorted vector for a given element. + * + * Returns the index of the element or None if not found. + */ + fn bsearch_elem(&self, x: &T) -> Option { + self.bsearch(|p| p.cmp(x)) + } +} + #[allow(missing_doc)] pub trait ImmutableCopyableVector { fn filtered(&self, f: &fn(&T) -> bool) -> ~[T]; @@ -2841,47 +2850,47 @@ mod tests { #[test] fn test_bsearch_elem() { - assert_eq!(bsearch_elem([1,2,3,4,5], &5), Some(4)); - assert_eq!(bsearch_elem([1,2,3,4,5], &4), Some(3)); - assert_eq!(bsearch_elem([1,2,3,4,5], &3), Some(2)); - assert_eq!(bsearch_elem([1,2,3,4,5], &2), Some(1)); - assert_eq!(bsearch_elem([1,2,3,4,5], &1), Some(0)); - - assert_eq!(bsearch_elem([2,4,6,8,10], &1), None); - assert_eq!(bsearch_elem([2,4,6,8,10], &5), None); - assert_eq!(bsearch_elem([2,4,6,8,10], &4), Some(1)); - assert_eq!(bsearch_elem([2,4,6,8,10], &10), Some(4)); - - assert_eq!(bsearch_elem([2,4,6,8], &1), None); - assert_eq!(bsearch_elem([2,4,6,8], &5), None); - assert_eq!(bsearch_elem([2,4,6,8], &4), Some(1)); - assert_eq!(bsearch_elem([2,4,6,8], &8), Some(3)); - - assert_eq!(bsearch_elem([2,4,6], &1), None); - assert_eq!(bsearch_elem([2,4,6], &5), None); - assert_eq!(bsearch_elem([2,4,6], &4), Some(1)); - assert_eq!(bsearch_elem([2,4,6], &6), Some(2)); - - assert_eq!(bsearch_elem([2,4], &1), None); - assert_eq!(bsearch_elem([2,4], &5), None); - assert_eq!(bsearch_elem([2,4], &2), Some(0)); - assert_eq!(bsearch_elem([2,4], &4), Some(1)); - - assert_eq!(bsearch_elem([2], &1), None); - assert_eq!(bsearch_elem([2], &5), None); - assert_eq!(bsearch_elem([2], &2), Some(0)); - - assert_eq!(bsearch_elem([], &1), None); - assert_eq!(bsearch_elem([], &5), None); - - assert!(bsearch_elem([1,1,1,1,1], &1) != None); - assert!(bsearch_elem([1,1,1,1,2], &1) != None); - assert!(bsearch_elem([1,1,1,2,2], &1) != None); - assert!(bsearch_elem([1,1,2,2,2], &1) != None); - assert_eq!(bsearch_elem([1,2,2,2,2], &1), Some(0)); - - assert_eq!(bsearch_elem([1,2,3,4,5], &6), None); - assert_eq!(bsearch_elem([1,2,3,4,5], &0), None); + assert_eq!([1,2,3,4,5].bsearch_elem(&5), Some(4)); + assert_eq!([1,2,3,4,5].bsearch_elem(&4), Some(3)); + assert_eq!([1,2,3,4,5].bsearch_elem(&3), Some(2)); + assert_eq!([1,2,3,4,5].bsearch_elem(&2), Some(1)); + assert_eq!([1,2,3,4,5].bsearch_elem(&1), Some(0)); + + assert_eq!([2,4,6,8,10].bsearch_elem(&1), None); + assert_eq!([2,4,6,8,10].bsearch_elem(&5), None); + assert_eq!([2,4,6,8,10].bsearch_elem(&4), Some(1)); + assert_eq!([2,4,6,8,10].bsearch_elem(&10), Some(4)); + + assert_eq!([2,4,6,8].bsearch_elem(&1), None); + assert_eq!([2,4,6,8].bsearch_elem(&5), None); + assert_eq!([2,4,6,8].bsearch_elem(&4), Some(1)); + assert_eq!([2,4,6,8].bsearch_elem(&8), Some(3)); + + assert_eq!([2,4,6].bsearch_elem(&1), None); + assert_eq!([2,4,6].bsearch_elem(&5), None); + assert_eq!([2,4,6].bsearch_elem(&4), Some(1)); + assert_eq!([2,4,6].bsearch_elem(&6), Some(2)); + + assert_eq!([2,4].bsearch_elem(&1), None); + assert_eq!([2,4].bsearch_elem(&5), None); + assert_eq!([2,4].bsearch_elem(&2), Some(0)); + assert_eq!([2,4].bsearch_elem(&4), Some(1)); + + assert_eq!([2].bsearch_elem(&1), None); + assert_eq!([2].bsearch_elem(&5), None); + assert_eq!([2].bsearch_elem(&2), Some(0)); + + assert_eq!([].bsearch_elem(&1), None); + assert_eq!([].bsearch_elem(&5), None); + + assert!([1,1,1,1,1].bsearch_elem(&1) != None); + assert!([1,1,1,1,2].bsearch_elem(&1) != None); + assert!([1,1,1,2,2].bsearch_elem(&1) != None); + assert!([1,1,2,2,2].bsearch_elem(&1) != None); + assert_eq!([1,2,2,2,2].bsearch_elem(&1), Some(0)); + + assert_eq!([1,2,3,4,5].bsearch_elem(&6), None); + assert_eq!([1,2,3,4,5].bsearch_elem(&0), None); } #[test] From 2eea642c3064e2de643cf155082f08dc141eafaa Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sat, 29 Jun 2013 13:41:09 +1000 Subject: [PATCH 7/9] Convert vec::dedup to a method. --- src/librustc/middle/check_match.rs | 2 +- src/libstd/prelude.rs | 2 +- src/libstd/vec.rs | 73 ++++++++++++++---------------- 3 files changed, 36 insertions(+), 41 deletions(-) diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index c27b60477c09e..8cb671a97f409 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -417,7 +417,7 @@ pub fn missing_ctor(cx: &MatchCheckCtxt, } } ); - vec::dedup(&mut sorted_vec_lens); + sorted_vec_lens.dedup(); let mut found_slice = false; let mut next = 0; diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs index c0049c7505d99..d560ce621eac9 100644 --- a/src/libstd/prelude.rs +++ b/src/libstd/prelude.rs @@ -74,7 +74,7 @@ pub use tuple::{ImmutableTuple6, ImmutableTuple7, ImmutableTuple8, ImmutableTupl pub use tuple::{ImmutableTuple10, ImmutableTuple11, ImmutableTuple12}; pub use vec::{VectorVector, CopyableVector, ImmutableVector}; pub use vec::{ImmutableEqVector, ImmutableTotalOrdVector, ImmutableCopyableVector}; -pub use vec::{OwnedVector, OwnedCopyableVector, MutableVector}; +pub use vec::{OwnedVector, OwnedCopyableVector,OwnedEqVector, MutableVector}; pub use io::{Reader, ReaderUtil, Writer, WriterUtil}; // Reexported runtime types diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index d7480617c12e4..dab379962a0c0 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -343,41 +343,6 @@ pub fn consume_reverse(mut v: ~[T], f: &fn(uint, v: T)) { } } -/** - * Remove consecutive repeated elements from a vector; if the vector is - * sorted, this removes all duplicates. - */ -pub fn dedup(v: &mut ~[T]) { - unsafe { - if v.len() < 1 { return; } - let mut last_written = 0; - let mut next_to_read = 1; - do as_mut_buf(*v) |p, ln| { - // last_written < next_to_read <= ln - while next_to_read < ln { - // last_written < next_to_read < ln - if *ptr::mut_offset(p, next_to_read) == - *ptr::mut_offset(p, last_written) { - ptr::replace_ptr(ptr::mut_offset(p, next_to_read), - intrinsics::uninit()); - } else { - last_written += 1; - // last_written <= next_to_read < ln - if next_to_read != last_written { - ptr::swap_ptr(ptr::mut_offset(p, last_written), - ptr::mut_offset(p, next_to_read)); - } - } - // last_written <= next_to_read < ln - next_to_read += 1; - // last_written < next_to_read <= ln - } - } - // last_written < next_to_read == ln - raw::set_len(v, last_written + 1); - } -} - // Appending /// Iterates over the `rhs` vector, copying each element and appending it to the @@ -1734,14 +1699,44 @@ impl OwnedCopyableVector for ~[T] { } #[allow(missing_doc)] -trait OwnedEqVector { +pub trait OwnedEqVector { fn dedup(&mut self); } impl OwnedEqVector for ~[T] { - #[inline] - fn dedup(&mut self) { - dedup(self) + /** + * Remove consecutive repeated elements from a vector; if the vector is + * sorted, this removes all duplicates. + */ + pub fn dedup(&mut self) { + unsafe { + if self.len() == 0 { return; } + let mut last_written = 0; + let mut next_to_read = 1; + do as_mut_buf(*self) |p, ln| { + // last_written < next_to_read <= ln + while next_to_read < ln { + // last_written < next_to_read < ln + if *ptr::mut_offset(p, next_to_read) == + *ptr::mut_offset(p, last_written) { + ptr::replace_ptr(ptr::mut_offset(p, next_to_read), + intrinsics::uninit()); + } else { + last_written += 1; + // last_written <= next_to_read < ln + if next_to_read != last_written { + ptr::swap_ptr(ptr::mut_offset(p, last_written), + ptr::mut_offset(p, next_to_read)); + } + } + // last_written <= next_to_read < ln + next_to_read += 1; + // last_written < next_to_read <= ln + } + } + // last_written < next_to_read == ln + raw::set_len(self, last_written + 1); + } } } From a396e1e2e95acc07f2804be2079d5b692753d4bb Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sat, 29 Jun 2013 14:02:20 +1000 Subject: [PATCH 8/9] Convert vec::{grow, grow_fn, grow_set} to methods. --- src/libextra/smallintmap.rs | 3 +- src/libstd/vec.rs | 109 +++++++++++++----------------- src/test/run-pass/issue-3563-3.rs | 4 +- 3 files changed, 48 insertions(+), 68 deletions(-) diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs index b07c05ad76a03..9cfe7cf5e4a1b 100644 --- a/src/libextra/smallintmap.rs +++ b/src/libextra/smallintmap.rs @@ -20,7 +20,6 @@ use std::cmp; use std::container::{Container, Mutable, Map, Set}; use std::uint; use std::util::replace; -use std::vec; #[allow(missing_doc)] pub struct SmallIntMap { @@ -86,7 +85,7 @@ impl Map for SmallIntMap { let exists = self.contains_key(&key); let len = self.v.len(); if len <= key { - vec::grow_fn(&mut self.v, key - len + 1, |_| None); + self.v.grow_fn(key - len + 1, |_| None); } self.v[key] = Some(value); !exists diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index dab379962a0c0..976a67ef4227b 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -363,63 +363,6 @@ pub fn append_one(lhs: ~[T], x: T) -> ~[T] { v } -/** - * Expands a vector in place, initializing the new elements to a given value - * - * # Arguments - * - * * v - The vector to grow - * * n - The number of elements to add - * * initval - The value for the new elements - */ -pub fn grow(v: &mut ~[T], n: uint, initval: &T) { - let new_len = v.len() + n; - v.reserve_at_least(new_len); - let mut i: uint = 0u; - - while i < n { - v.push(copy *initval); - i += 1u; - } -} - -/** - * Expands a vector in place, initializing the new elements to the result of - * a function - * - * Function `init_op` is called `n` times with the values [0..`n`) - * - * # Arguments - * - * * v - The vector to grow - * * n - The number of elements to add - * * init_op - A function to call to retreive each appended element's - * value - */ -pub fn grow_fn(v: &mut ~[T], n: uint, op: &fn(uint) -> T) { - let new_len = v.len() + n; - v.reserve_at_least(new_len); - let mut i: uint = 0u; - while i < n { - v.push(op(i)); - i += 1u; - } -} - -/** - * Sets the value of a vector element at a given index, growing the vector as - * needed - * - * Sets the element at position `index` to `val`. If `index` is past the end - * of the vector, expands the vector by replicating `initval` to fill the - * intervening space. - */ -pub fn grow_set(v: &mut ~[T], index: uint, initval: &T, val: T) { - let l = v.len(); - if index >= l { grow(&mut *v, index - l + 1u, initval); } - v[index] = val; -} - // Functional utilities /// Apply a function to each element of a vector and return the results @@ -1648,9 +1591,26 @@ impl OwnedVector for ~[T] { (lefts, rights) } - #[inline] + /** + * Expands a vector in place, initializing the new elements to the result of + * a function + * + * Function `init_op` is called `n` times with the values [0..`n`) + * + * # Arguments + * + * * n - The number of elements to add + * * init_op - A function to call to retreive each appended element's + * value + */ fn grow_fn(&mut self, n: uint, op: &fn(uint) -> T) { - grow_fn(self, n, op); + let new_len = self.len() + n; + self.reserve_at_least(new_len); + let mut i: uint = 0u; + while i < n { + self.push(op(i)); + i += 1u; + } } } @@ -1687,14 +1647,37 @@ impl OwnedCopyableVector for ~[T] { } } - #[inline] + /** + * Expands a vector in place, initializing the new elements to a given value + * + * # Arguments + * + * * n - The number of elements to add + * * initval - The value for the new elements + */ fn grow(&mut self, n: uint, initval: &T) { - grow(self, n, initval); + let new_len = self.len() + n; + self.reserve_at_least(new_len); + let mut i: uint = 0u; + + while i < n { + self.push(copy *initval); + i += 1u; + } } - #[inline] + /** + * Sets the value of a vector element at a given index, growing the vector as + * needed + * + * Sets the element at position `index` to `val`. If `index` is past the end + * of the vector, expands the vector by replicating `initval` to fill the + * intervening space. + */ fn grow_set(&mut self, index: uint, initval: &T, val: T) { - grow_set(self, index, initval, val); + let l = self.len(); + if index >= l { self.grow(index - l + 1u, initval); } + self[index] = val; } } diff --git a/src/test/run-pass/issue-3563-3.rs b/src/test/run-pass/issue-3563-3.rs index e574502a9fb7d..a24800e4dbb25 100644 --- a/src/test/run-pass/issue-3563-3.rs +++ b/src/test/run-pass/issue-3563-3.rs @@ -69,9 +69,7 @@ fn AsciiArt(width: uint, height: uint, fill: char) -> AsciiArt { // blank characters for each position in our canvas. let mut lines = do vec::build_sized(height) |push| { for height.times { - let mut line = ~[]; - vec::grow_set(&mut line, width-1, &'.', '.'); - push(line); + push(vec::from_elem(width, '.')); } }; From c0a20d2929a7c0d6af0de899198df4f26453d877 Mon Sep 17 00:00:00 2001 From: Huon Wilson Date: Sat, 29 Jun 2013 15:05:50 +1000 Subject: [PATCH 9/9] Remove vec::{map, mapi, zip_map} and the methods, except for .map, since this is very common, and the replacement (.iter().transform().collect()) is very ugly. --- src/compiletest/runtest.rs | 4 +- src/libextra/fileinput.rs | 9 +- src/libextra/getopts.rs | 6 +- src/libextra/num/bigint.rs | 10 +- src/libextra/par.rs | 6 +- src/libextra/semver.rs | 4 +- src/librustc/back/rpath.rs | 8 +- src/librustc/front/config.rs | 2 +- src/librustc/front/test.rs | 2 +- src/librustc/metadata/encoder.rs | 3 +- src/librustc/middle/check_match.rs | 4 +- src/librustc/middle/const_eval.rs | 9 +- src/librustc/middle/lint.rs | 7 +- src/librustc/middle/trans/adt.rs | 4 +- src/librustc/middle/trans/build.rs | 6 +- src/librustc/middle/trans/cabi.rs | 3 +- src/librustc/middle/trans/common.rs | 16 ++- src/librustc/middle/trans/expr.rs | 5 +- src/librustc/middle/trans/monomorphize.rs | 25 ++-- src/librustc/middle/ty.rs | 12 +- src/librustc/middle/typeck/astconv.rs | 4 +- src/librustc/middle/typeck/check/mod.rs | 6 +- src/librustc/middle/typeck/collect.rs | 4 +- .../middle/typeck/infer/region_inference.rs | 4 +- src/librustdoc/attr_pass.rs | 17 ++- src/librustdoc/extract.rs | 10 +- src/librustdoc/fold.rs | 30 ++-- src/librustdoc/tystr_pass.rs | 9 +- src/libstd/io.rs | 4 +- src/libstd/iterator.rs | 3 +- src/libstd/tuple.rs | 6 +- src/libstd/vec.rs | 131 +++--------------- src/libsyntax/ast_util.rs | 2 +- src/libsyntax/ext/deriving/decodable.rs | 8 +- src/libsyntax/ext/deriving/generic.rs | 11 +- src/libsyntax/ext/deriving/rand.rs | 4 +- src/libsyntax/ext/pipes/pipec.rs | 12 +- src/libsyntax/ext/source_util.rs | 5 +- src/libsyntax/ext/tt/macro_parser.rs | 3 +- src/libsyntax/fold.rs | 13 +- src/test/bench/graph500-bfs.rs | 10 +- src/test/bench/shootout-chameneos-redux.rs | 4 +- src/test/bench/shootout-k-nucleotide-pipes.rs | 15 +- src/test/compile-fail/lint-unused-imports.rs | 6 +- src/test/run-pass/block-arg.rs | 2 +- src/test/run-pass/block-vec-map_zip.rs | 20 --- src/test/run-pass/trait-to-str.rs | 6 +- 47 files changed, 184 insertions(+), 310 deletions(-) delete mode 100644 src/test/run-pass/block-vec-map_zip.rs diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index 0e04be34c795a..715f6d91e09dd 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -345,9 +345,9 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError], fatal(~"process did not return an error status"); } - let prefixes = vec::map(expected_errors, |ee| { + let prefixes = expected_errors.iter().transform(|ee| { fmt!("%s:%u:", testfile.to_str(), ee.line) - }); + }).collect::<~[~str]>(); // Scan and extract our error/warning messages, // which look like: diff --git a/src/libextra/fileinput.rs b/src/libextra/fileinput.rs index 5367da2fa8d4f..f91260f475288 100644 --- a/src/libextra/fileinput.rs +++ b/src/libextra/fileinput.rs @@ -100,7 +100,6 @@ total line count). use std::io::ReaderUtil; use std::io; use std::os; -use std::vec; /** A summary of the internal state of a `FileInput` object. `line_num` @@ -353,13 +352,13 @@ a literal `-`. */ // XXX: stupid, unclear name pub fn pathify(vec: &[~str], stdin_hyphen : bool) -> ~[Option] { - vec::map(vec, |&str : & ~str| { - if stdin_hyphen && str == ~"-" { + vec.iter().transform(|str| { + if stdin_hyphen && "-" == *str { None } else { - Some(Path(str)) + Some(Path(*str)) } - }) + }).collect() } /** diff --git a/src/libextra/getopts.rs b/src/libextra/getopts.rs index 21fe676ef7929..1a494f36c6469 100644 --- a/src/libextra/getopts.rs +++ b/src/libextra/getopts.rs @@ -592,9 +592,9 @@ pub mod groups { */ pub fn usage(brief: &str, opts: &[OptGroup]) -> ~str { - let desc_sep = ~"\n" + " ".repeat(24); + let desc_sep = "\n" + " ".repeat(24); - let rows = vec::map(opts, |optref| { + let mut rows = opts.iter().transform(|optref| { let OptGroup{short_name: short_name, long_name: long_name, hint: hint, @@ -669,7 +669,7 @@ pub mod groups { return str::to_owned(brief) + "\n\nOptions:\n" + - rows.connect("\n") + + rows.collect::<~[~str]>().connect("\n") + "\n\n"; } } // end groups module diff --git a/src/libextra/num/bigint.rs b/src/libextra/num/bigint.rs index fd61c4f6bfc6c..9422ad0c9f2e0 100644 --- a/src/libextra/num/bigint.rs +++ b/src/libextra/num/bigint.rs @@ -283,13 +283,13 @@ impl Mul for BigUint { if n == 1 { return copy *a; } let mut carry = 0; - let prod = do vec::map(a.data) |ai| { + let prod = do a.data.iter().transform |ai| { let (hi, lo) = BigDigit::from_uint( (*ai as uint) * (n as uint) + (carry as uint) ); carry = hi; lo - }; + }.collect::<~[BigDigit]>(); if carry == 0 { return BigUint::new(prod) }; return BigUint::new(prod + [carry]); } @@ -618,13 +618,13 @@ impl BigUint { if n_bits == 0 || self.is_zero() { return copy *self; } let mut carry = 0; - let shifted = do vec::map(self.data) |elem| { + let shifted = do self.data.iter().transform |elem| { let (hi, lo) = BigDigit::from_uint( (*elem as uint) << n_bits | (carry as uint) ); carry = hi; lo - }; + }.collect::<~[BigDigit]>(); if carry == 0 { return BigUint::new(shifted); } return BigUint::new(shifted + [carry]); } @@ -1172,7 +1172,7 @@ mod biguint_tests { #[test] fn test_cmp() { - let data = [ &[], &[1], &[2], &[-1], &[0, 1], &[2, 1], &[1, 1, 1] ] + let data: ~[BigUint] = [ &[], &[1], &[2], &[-1], &[0, 1], &[2, 1], &[1, 1, 1] ] .map(|v| BigUint::from_slice(*v)); for data.iter().enumerate().advance |(i, ni)| { for data.slice(i, data.len()).iter().enumerate().advance |(j0, nj)| { diff --git a/src/libextra/par.rs b/src/libextra/par.rs index 665633eedf856..2878a3ee12215 100644 --- a/src/libextra/par.rs +++ b/src/libextra/par.rs @@ -92,7 +92,7 @@ pub fn map( vec::concat(map_slices(xs, || { let f = fn_factory(); let result: ~fn(uint, &[A]) -> ~[B] = - |_, slice| vec::map(slice, |x| f(x)); + |_, slice| slice.iter().transform(|x| f(x)).collect(); result })) } @@ -104,9 +104,9 @@ pub fn mapi( let slices = map_slices(xs, || { let f = fn_factory(); let result: ~fn(uint, &[A]) -> ~[B] = |base, slice| { - vec::mapi(slice, |i, x| { + slice.iter().enumerate().transform(|(i, x)| { f(i + base, x) - }) + }).collect() }; result }); diff --git a/src/libextra/semver.rs b/src/libextra/semver.rs index 6361de1271934..6c9453a5a3ba1 100644 --- a/src/libextra/semver.rs +++ b/src/libextra/semver.rs @@ -78,12 +78,12 @@ impl ToStr for Version { let s = if self.pre.is_empty() { s } else { - s + "-" + self.pre.map(|i| i.to_str()).connect(".") + fmt!("%s-%s", s, self.pre.map(|i| i.to_str()).connect(".")) }; if self.build.is_empty() { s } else { - s + "+" + self.build.map(|i| i.to_str()).connect(".") + fmt!("%s+%s", s, self.build.map(|i| i.to_str()).connect(".")) } } } diff --git a/src/librustc/back/rpath.rs b/src/librustc/back/rpath.rs index ab107a8bf2509..19dbb941e5566 100644 --- a/src/librustc/back/rpath.rs +++ b/src/librustc/back/rpath.rs @@ -52,7 +52,7 @@ fn get_sysroot_absolute_rt_lib(sess: session::Session) -> Path { } pub fn rpaths_to_flags(rpaths: &[Path]) -> ~[~str] { - vec::map(rpaths, |rpath| fmt!("-Wl,-rpath,%s",rpath.to_str())) + rpaths.iter().transform(|rpath| fmt!("-Wl,-rpath,%s",rpath.to_str())).collect() } fn get_rpaths(os: session::os, @@ -103,9 +103,7 @@ fn get_rpaths(os: session::os, fn get_rpaths_relative_to_output(os: session::os, output: &Path, libs: &[Path]) -> ~[Path] { - vec::map(libs, |a| { - get_rpath_relative_to_output(os, output, a) - }) + libs.iter().transform(|a| get_rpath_relative_to_output(os, output, a)).collect() } pub fn get_rpath_relative_to_output(os: session::os, @@ -163,7 +161,7 @@ pub fn get_relative_to(abs1: &Path, abs2: &Path) -> Path { } fn get_absolute_rpaths(libs: &[Path]) -> ~[Path] { - vec::map(libs, |a| get_absolute_rpath(a) ) + libs.iter().transform(|a| get_absolute_rpath(a)).collect() } pub fn get_absolute_rpath(lib: &Path) -> Path { diff --git a/src/librustc/front/config.rs b/src/librustc/front/config.rs index 7d9fac5c6ae01..b1d4820f062eb 100644 --- a/src/librustc/front/config.rs +++ b/src/librustc/front/config.rs @@ -90,7 +90,7 @@ fn fold_foreign_mod( ast::foreign_mod { sort: nm.sort, abis: nm.abis, - view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(*x)), + view_items: filtered_view_items.iter().transform(|x| fld.fold_view_item(*x)).collect(), items: filtered_items } } diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index cfd4df7403f69..6998410bae0e5 100644 --- a/src/librustc/front/test.rs +++ b/src/librustc/front/test.rs @@ -117,7 +117,7 @@ fn fold_mod(cx: @mut TestCtxt, let mod_nomain = ast::_mod { view_items: /*bad*/copy m.view_items, - items: vec::map(m.items, |i| nomain(cx, *i)), + items: m.items.iter().transform(|i| nomain(cx, *i)).collect(), }; fold::noop_fold_mod(&mod_nomain, fld) diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 71d7bea0af7bc..77a8d1792dbc8 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -1441,8 +1441,7 @@ fn encode_crate_deps(ecx: &EncodeContext, expected_cnum += 1; } - // mut -> immutable hack for vec::map - deps.slice(0, deps.len()).to_owned() + deps } // We're just going to write a list of crate 'name-hash-version's, with diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 8cb671a97f409..72896258b2d32 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -642,13 +642,13 @@ pub fn specialize(cx: &MatchCheckCtxt, ty_to_str(cx.tcx, left_ty))); } } - let args = vec::map(class_fields, |class_field| { + let args = class_fields.iter().transform(|class_field| { match flds.iter().find_(|f| f.ident == class_field.ident) { Some(f) => f.pat, _ => wild() } - }); + }).collect(); Some(vec::append(args, vec::to_owned(r.tail()))) } } diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 9d94a2de69334..bf91b6771dcd8 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -19,7 +19,6 @@ use syntax::ast::*; use std::float; use std::hashmap::{HashMap, HashSet}; -use std::vec; // // This pass classifies expressions by their constant-ness. @@ -70,8 +69,8 @@ pub fn join(a: constness, b: constness) -> constness { } } -pub fn join_all(cs: &[constness]) -> constness { - cs.iter().fold(integral_const, |a, b| join(a, *b)) +pub fn join_all>(mut cs: It) -> constness { + cs.fold(integral_const, |a, b| join(a, b)) } pub fn classify(e: &expr, @@ -104,7 +103,7 @@ pub fn classify(e: &expr, ast::expr_tup(ref es) | ast::expr_vec(ref es, ast::m_imm) => { - join_all(vec::map(*es, |e| classify(*e, tcx))) + join_all(es.iter().transform(|e| classify(*e, tcx))) } ast::expr_vstore(e, vstore) => { @@ -118,7 +117,7 @@ pub fn classify(e: &expr, } ast::expr_struct(_, ref fs, None) => { - let cs = do vec::map((*fs)) |f| { + let cs = do fs.iter().transform |f| { classify(f.node.expr, tcx) }; join_all(cs) diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index d0fd516778bb6..ce09f790ef45f 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -740,11 +740,10 @@ fn check_item_ctypes(cx: &Context, it: &ast::item) { } fn check_foreign_fn(cx: &Context, decl: &ast::fn_decl) { - let tys = vec::map(decl.inputs, |a| a.ty ); - let r = vec::append_one(tys, decl.output); - for r.iter().advance |ty| { - check_ty(cx, *ty); + for decl.inputs.iter().advance |in| { + check_ty(cx, in.ty); } + check_ty(cx, decl.output) } match it.node { diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs index 5417d6f6cc661..ab813c0ffc546 100644 --- a/src/librustc/middle/trans/adt.rs +++ b/src/librustc/middle/trans/adt.rs @@ -519,10 +519,10 @@ pub fn trans_const(ccx: &mut CrateContext, r: &Repr, discr: int, C_struct(build_const_struct(ccx, nonnull, vals)) } else { assert_eq!(vals.len(), 0); - let vals = do nonnull.fields.mapi |i, &ty| { + let vals = do nonnull.fields.iter().enumerate().transform |(i, &ty)| { let llty = type_of::sizing_type_of(ccx, ty); if i == ptrfield { C_null(llty) } else { C_undef(llty) } - }; + }.collect::<~[ValueRef]>(); C_struct(build_const_struct(ccx, nonnull, vals)) } } diff --git a/src/librustc/middle/trans/build.rs b/src/librustc/middle/trans/build.rs index 46a8cb306f8b1..8535c84c5cb5e 100644 --- a/src/librustc/middle/trans/build.rs +++ b/src/librustc/middle/trans/build.rs @@ -615,12 +615,12 @@ pub fn GEPi(cx: block, base: ValueRef, ixs: &[uint]) -> ValueRef { // we care about. if ixs.len() < 16 { let mut small_vec = [ C_i32(0), ..16 ]; - for ixs.iter().enumerate().advance |(i, &ix)| { - small_vec[i] = C_i32(ix as i32) + for small_vec.mut_iter().zip(ixs.iter()).advance |(small_vec_e, &ix)| { + *small_vec_e = C_i32(ix as i32); } InBoundsGEP(cx, base, small_vec.slice(0, ixs.len())) } else { - let v = do vec::map(ixs) |i| { C_i32(*i as i32) }; + let v = do ixs.iter().transform |i| { C_i32(*i as i32) }.collect::<~[ValueRef]>(); count_insn(cx, "gepi"); InBoundsGEP(cx, base, v) } diff --git a/src/librustc/middle/trans/cabi.rs b/src/librustc/middle/trans/cabi.rs index 4cbc9cd417f27..d00479194308b 100644 --- a/src/librustc/middle/trans/cabi.rs +++ b/src/librustc/middle/trans/cabi.rs @@ -17,7 +17,6 @@ use middle::trans::type_::Type; use std::libc::c_uint; use std::option; -use std::vec; pub trait ABIInfo { fn compute_info(&self, atys: &[Type], rty: Type, ret_def: bool) -> FnType; @@ -37,7 +36,7 @@ pub struct FnType { impl FnType { pub fn decl_fn(&self, decl: &fn(fnty: Type) -> ValueRef) -> ValueRef { - let atys = vec::map(self.arg_tys, |t| t.ty); + let atys = self.arg_tys.iter().transform(|t| t.ty).collect::<~[Type]>(); let rty = self.ret_ty.ty; let fnty = Type::func(atys, &rty); let llfn = decl(fnty); diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index 539397c8b1a4d..5be8c63dba10d 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -980,9 +980,9 @@ pub fn node_id_type_params(bcx: block, id: ast::node_id) -> ~[ty::t] { match bcx.fcx.param_substs { Some(substs) => { - do vec::map(params) |t| { + do params.iter().transform |t| { ty::subst_tps(tcx, substs.tys, substs.self_ty, *t) - } + }.collect() } _ => params } @@ -1006,9 +1006,11 @@ pub fn resolve_vtables_under_param_substs(tcx: ty::ctxt, param_substs: Option<@param_substs>, vts: typeck::vtable_res) -> typeck::vtable_res { - @vec::map(*vts, |ds| - @vec::map(**ds, |d| - resolve_vtable_under_param_substs(tcx, param_substs, copy *d))) + @vts.iter().transform(|ds| + @ds.iter().transform( + |d| resolve_vtable_under_param_substs(tcx, param_substs, copy *d)) + .collect::<~[typeck::vtable_origin]>()) + .collect::<~[typeck::vtable_param_res]>() } @@ -1029,9 +1031,9 @@ pub fn resolve_vtable_under_param_substs(tcx: ty::ctxt, typeck::vtable_static(trait_id, tys, sub) => { let tys = match param_substs { Some(substs) => { - do vec::map(tys) |t| { + do tys.iter().transform |t| { ty::subst_tps(tcx, substs.tys, substs.self_ty, *t) - } + }.collect() } _ => tys }; diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 1511f25414071..df197ded629ea 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -588,8 +588,9 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr, } ast::expr_tup(ref args) => { let repr = adt::represent_type(bcx.ccx(), expr_ty(bcx, expr)); - return trans_adt(bcx, repr, 0, args.mapi(|i, arg| (i, *arg)), - None, dest); + let numbered_fields: ~[(uint, @ast::expr)] = + args.iter().enumerate().transform(|(i, arg)| (i, *arg)).collect(); + return trans_adt(bcx, repr, 0, numbered_fields, None, dest); } ast::expr_lit(@codemap::spanned {node: ast::lit_str(s), _}) => { return tvec::trans_lit_str(bcx, expr, s, dest); diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs index 4ae8554d7143c..ad48c30747edc 100644 --- a/src/librustc/middle/trans/monomorphize.rs +++ b/src/librustc/middle/trans/monomorphize.rs @@ -30,7 +30,6 @@ use middle::ty::{FnSig}; use middle::typeck; use util::ppaux::{Repr,ty_to_str}; -use std::vec; use syntax::ast; use syntax::ast_map; use syntax::ast_map::path_name; @@ -62,12 +61,12 @@ pub fn monomorphic_fn(ccx: @mut CrateContext, assert!(real_substs.tps.iter().all(|t| !ty::type_needs_infer(*t))); let _icx = push_ctxt("monomorphic_fn"); let mut must_cast = false; - let substs = vec::map(real_substs.tps, |t| { + let substs = real_substs.tps.iter().transform(|t| { match normalize_for_monomorphization(ccx.tcx, *t) { Some(t) => { must_cast = true; t } None => *t } - }); + }).collect::<~[ty::t]>(); for real_substs.tps.iter().advance |s| { assert!(!ty::type_has_params(*s)); } for substs.iter().advance |s| { assert!(!ty::type_has_params(*s)); } @@ -325,22 +324,22 @@ pub fn make_mono_id(ccx: @mut CrateContext, vtables: Option, impl_did_opt: Option, param_uses: Option<@~[type_use::type_uses]>) -> mono_id { - let precise_param_ids = match vtables { + // FIXME (possibly #5801): Need a lot of type hints to get + // .collect() to work. + let precise_param_ids: ~[(ty::t, Option<@~[mono_id]>)] = match vtables { Some(vts) => { debug!("make_mono_id vtables=%s substs=%s", vts.repr(ccx.tcx), substs.repr(ccx.tcx)); - vec::map_zip(*vts, substs, |vtable, subst| { + vts.iter().zip(substs.iter()).transform(|(vtable, subst)| { let v = vtable.map(|vt| meth::vtable_id(ccx, vt)); (*subst, if !v.is_empty() { Some(@v) } else { None }) - }) - } - None => { - vec::map(substs, |subst| (*subst, None)) + }).collect() } + None => substs.iter().transform(|subst| (*subst, None::<@~[mono_id]>)).collect() }; let param_ids = match param_uses { Some(ref uses) => { - vec::map_zip(precise_param_ids, **uses, |id, uses| { + precise_param_ids.iter().zip(uses.iter()).transform(|(id, uses)| { if ccx.sess.no_monomorphic_collapse() { match copy *id { (a, b) => mono_precise(a, b) @@ -377,13 +376,13 @@ pub fn make_mono_id(ccx: @mut CrateContext, } } } - }) + }).collect() } None => { - precise_param_ids.map(|x| { + precise_param_ids.iter().transform(|x| { let (a, b) = copy *x; mono_precise(a, b) - }) + }).collect() } }; @mono_id_ {def: item, params: param_ids, impl_did_opt: impl_did_opt} diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 8a6fff09c730b..bbf548d2659a1 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -3674,15 +3674,15 @@ pub fn substd_enum_variants(cx: ctxt, id: ast::def_id, substs: &substs) -> ~[VariantInfo] { - do vec::map(*enum_variants(cx, id)) |variant_info| { - let substd_args = vec::map(variant_info.args, - |aty| subst(cx, substs, *aty)); + do enum_variants(cx, id).iter().transform |variant_info| { + let substd_args = variant_info.args.iter() + .transform(|aty| subst(cx, substs, *aty)).collect(); let substd_ctor_ty = subst(cx, substs, variant_info.ctor_ty); @VariantInfo_{args: substd_args, ctor_ty: substd_ctor_ty, ../*bad*/copy **variant_info} - } + }.collect() } pub fn item_path_str(cx: ctxt, id: ast::def_id) -> ~str { @@ -3815,7 +3815,7 @@ pub fn enum_variants(cx: ctxt, id: ast::def_id) -> @~[VariantInfo] { _ }, _) => { let mut disr_val = -1; - @vec::map(enum_definition.variants, |variant| { + @enum_definition.variants.iter().transform(|variant| { match variant.node.kind { ast::tuple_variant_kind(ref args) => { let ctor_ty = node_id_to_type(cx, variant.node.id); @@ -3848,7 +3848,7 @@ pub fn enum_variants(cx: ctxt, id: ast::def_id) -> @~[VariantInfo] { fail!("struct variant kinds unimpl in enum_variants") } } - }) + }).collect() } _ => cx.sess.bug("tag_variants: id not bound to an enum") } diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 1d9895d295038..4d2849c521058 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -718,14 +718,14 @@ pub fn ty_of_closure( let bound_lifetime_names = bound_lifetimes(this, lifetimes); let rb = in_binding_rscope(rscope, RegionParamNames(copy bound_lifetime_names)); - let input_tys = do decl.inputs.mapi |i, a| { + let input_tys = do decl.inputs.iter().enumerate().transform |(i, a)| { let expected_arg_ty = do expected_sig.chain_ref |e| { // no guarantee that the correct number of expected args // were supplied if i < e.inputs.len() {Some(e.inputs[i])} else {None} }; ty_of_arg(this, &rb, *a, expected_arg_ty) - }; + }.collect(); let expected_ret_ty = expected_sig.map(|e| e.output); let output_ty = match decl.output.node { diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index d1edc1cd3630d..91b8f01f33623 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -1781,7 +1781,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, _ => () } - let tps = vec::map(tys, |ty| fcx.to_ty(*ty)); + let tps = tys.iter().transform(|ty| fcx.to_ty(*ty)).collect::<~[ty::t]>(); match method::lookup(fcx, expr, base, @@ -2766,7 +2766,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, let mut bot_field = false; let mut err_field = false; - let elt_ts = do elts.mapi |i, e| { + let elt_ts = do elts.iter().enumerate().transform |(i, e)| { let opt_hint = match flds { Some(ref fs) if i < fs.len() => Some(fs[i]), _ => None @@ -2776,7 +2776,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, err_field = err_field || ty::type_is_error(t); bot_field = bot_field || ty::type_is_bot(t); t - }; + }.collect(); if bot_field { fcx.write_bot(id); } else if err_field { diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index 3a4fa82906d16..85bd2bc2d75ea 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -712,7 +712,7 @@ pub fn convert_methods(ccx: &CrateCtxt, -> ~[ConvertedMethod] { let tcx = ccx.tcx; - return vec::map(ms, |m| { + return ms.iter().transform(|m| { let num_rcvr_ty_params = rcvr_ty_generics.type_param_defs.len(); let m_ty_generics = ty_generics(ccx, rcvr_ty_generics.region_param, &m.generics, @@ -742,7 +742,7 @@ pub fn convert_methods(ccx: &CrateCtxt, tcx.methods.insert(mty.def_id, mty); ConvertedMethod {mty: mty, id: m.id, span: m.span, body_id: m.body.node.id} - }); + }).collect(); fn ty_of_method(ccx: &CrateCtxt, m: &ast::method, diff --git a/src/librustc/middle/typeck/infer/region_inference.rs b/src/librustc/middle/typeck/infer/region_inference.rs index bad4cb2fe8772..db17405fc2663 100644 --- a/src/librustc/middle/typeck/infer/region_inference.rs +++ b/src/librustc/middle/typeck/infer/region_inference.rs @@ -1478,7 +1478,7 @@ impl RegionVarBindings { // overlapping locations. let mut dup_vec = graph.nodes.map(|_| uint::max_value); - graph.nodes.mapi(|idx, node| { + graph.nodes.iter().enumerate().transform(|(idx, node)| { match node.value { Value(_) => { /* Inference successful */ @@ -1528,7 +1528,7 @@ impl RegionVarBindings { } node.value - }) + }).collect() } pub fn report_error_for_expanding_node(&mut self, diff --git a/src/librustdoc/attr_pass.rs b/src/librustdoc/attr_pass.rs index 3efebe854e48a..2a9442fbe525b 100644 --- a/src/librustdoc/attr_pass.rs +++ b/src/librustdoc/attr_pass.rs @@ -26,7 +26,6 @@ use fold::Fold; use fold; use pass::Pass; -use std::vec; use syntax::ast; use syntax::ast_map; @@ -124,7 +123,7 @@ fn fold_enum( let doc = fold::default_seq_fold_enum(fold, doc); doc::EnumDoc { - variants: do vec::map(doc.variants) |variant| { + variants: do doc.variants.iter().transform |variant| { let variant = copy *variant; let desc = { let variant = copy variant; @@ -153,7 +152,7 @@ fn fold_enum( desc: desc, .. variant } - }, + }.collect(), .. doc } } @@ -183,7 +182,7 @@ fn merge_method_attrs( ast_map::node_item(@ast::item { node: ast::item_trait(_, _, ref methods), _ }, _) => { - vec::map(*methods, |method| { + methods.iter().transform(|method| { match copy *method { ast::required(ty_m) => { (to_str(ty_m.ident), @@ -193,21 +192,21 @@ fn merge_method_attrs( (to_str(m.ident), attr_parser::parse_desc(copy m.attrs)) } } - }) + }).collect() } ast_map::node_item(@ast::item { node: ast::item_impl(_, _, _, ref methods), _ }, _) => { - vec::map(*methods, |method| { + methods.iter().transform(|method| { (to_str(method.ident), attr_parser::parse_desc(copy method.attrs)) - }) + }).collect() } _ => fail!("unexpected item") } }; - do vec::map_zip(docs, attrs) |doc, attrs| { + do docs.iter().zip(attrs.iter()).transform |(doc, attrs)| { assert!(doc.name == attrs.first()); let desc = attrs.second(); @@ -215,7 +214,7 @@ fn merge_method_attrs( desc: desc, .. copy *doc } - } + }.collect() } diff --git a/src/librustdoc/extract.rs b/src/librustdoc/extract.rs index c2127eae62535..d5d2b4ce6286c 100644 --- a/src/librustdoc/extract.rs +++ b/src/librustdoc/extract.rs @@ -186,7 +186,7 @@ fn enumdoc_from_enum( fn variantdocs_from_variants( variants: ~[ast::variant] ) -> ~[doc::VariantDoc] { - vec::map(variants, variantdoc_from_variant) + variants.iter().transform(variantdoc_from_variant).collect() } fn variantdoc_from_variant(variant: &ast::variant) -> doc::VariantDoc { @@ -203,7 +203,7 @@ fn traitdoc_from_trait( ) -> doc::TraitDoc { doc::TraitDoc { item: itemdoc, - methods: do vec::map(methods) |method| { + methods: do methods.iter().transform |method| { match copy *method { ast::required(ty_m) => { doc::MethodDoc { @@ -226,7 +226,7 @@ fn traitdoc_from_trait( } } } - } + }.collect() } } @@ -239,7 +239,7 @@ fn impldoc_from_impl( bounds_str: None, trait_types: ~[], self_ty: None, - methods: do vec::map(methods) |method| { + methods: do methods.iter().transform |method| { doc::MethodDoc { name: to_str(method.ident), brief: None, @@ -248,7 +248,7 @@ fn impldoc_from_impl( sig: None, implementation: doc::Provided, } - } + }.collect() } } diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs index efb3e61e807fa..6510384ef01dd 100644 --- a/src/librustdoc/fold.rs +++ b/src/librustdoc/fold.rs @@ -13,8 +13,6 @@ use doc; #[cfg(test)] use extract; #[cfg(test)] use parse; -use std::vec; - pub struct Fold { ctxt: T, fold_doc: FoldDoc, @@ -155,7 +153,7 @@ pub fn default_par_fold(ctxt: T) -> Fold { pub fn default_seq_fold_doc(fold: &Fold, doc: doc::Doc) -> doc::Doc { doc::Doc { - pages: do vec::map(doc.pages) |page| { + pages: do doc.pages.iter().transform |page| { match copy *page { doc::CratePage(doc) => { doc::CratePage((fold.fold_crate)(fold, doc)) @@ -164,7 +162,7 @@ pub fn default_seq_fold_doc(fold: &Fold, doc: doc::Doc) -> doc::Doc { doc::ItemPage(fold_ItemTag(fold, doc)) } } - }, + }.collect(), .. doc } } @@ -191,9 +189,9 @@ pub fn default_any_fold_mod( ) -> doc::ModDoc { doc::ModDoc { item: (fold.fold_item)(fold, copy doc.item), - items: vec::map(doc.items, |ItemTag| { + items: doc.items.iter().transform(|ItemTag| { fold_ItemTag(fold, copy *ItemTag) - }), + }).collect(), .. doc } } @@ -204,9 +202,9 @@ pub fn default_seq_fold_mod( ) -> doc::ModDoc { doc::ModDoc { item: (fold.fold_item)(fold, copy doc.item), - items: vec::map(doc.items, |ItemTag| { + items: doc.items.iter().transform(|ItemTag| { fold_ItemTag(fold, copy *ItemTag) - }), + }).collect(), .. doc } } @@ -217,9 +215,9 @@ pub fn default_par_fold_mod( ) -> doc::ModDoc { doc::ModDoc { item: (fold.fold_item)(fold, copy doc.item), - items: vec::map(doc.items, |ItemTag| { + items: doc.items.iter().transform(|ItemTag| { fold_ItemTag(fold, copy *ItemTag) - }), + }).collect(), .. doc } } @@ -230,9 +228,9 @@ pub fn default_any_fold_nmod( ) -> doc::NmodDoc { doc::NmodDoc { item: (fold.fold_item)(fold, copy doc.item), - fns: vec::map(doc.fns, |FnDoc| { + fns: doc.fns.iter().transform(|FnDoc| { (fold.fold_fn)(fold, copy *FnDoc) - }), + }).collect(), .. doc } } @@ -243,9 +241,9 @@ pub fn default_seq_fold_nmod( ) -> doc::NmodDoc { doc::NmodDoc { item: (fold.fold_item)(fold, copy doc.item), - fns: vec::map(doc.fns, |FnDoc| { + fns: doc.fns.iter().transform(|FnDoc| { (fold.fold_fn)(fold, copy *FnDoc) - }), + }).collect(), .. doc } } @@ -256,9 +254,9 @@ pub fn default_par_fold_nmod( ) -> doc::NmodDoc { doc::NmodDoc { item: (fold.fold_item)(fold, copy doc.item), - fns: vec::map(doc.fns, |FnDoc| { + fns: doc.fns.iter().transform(|FnDoc| { (fold.fold_fn)(fold, copy *FnDoc) - }), + }).collect(), .. doc } } diff --git a/src/librustdoc/tystr_pass.rs b/src/librustdoc/tystr_pass.rs index c3b02c91e7494..e40bdb532da93 100644 --- a/src/librustdoc/tystr_pass.rs +++ b/src/librustdoc/tystr_pass.rs @@ -20,7 +20,6 @@ use fold::Fold; use fold; use pass::Pass; -use std::vec; use syntax::ast; use syntax::print::pprust; use syntax::parse::token; @@ -114,7 +113,7 @@ fn fold_enum( let srv = fold.ctxt.clone(); doc::EnumDoc { - variants: do vec::map(doc.variants) |variant| { + variants: do doc.variants.iter().transform |variant| { let sig = { let variant = copy *variant; do astsrv::exec(srv.clone()) |ctxt| { @@ -139,7 +138,7 @@ fn fold_enum( sig: Some(sig), .. copy *variant } - }, + }.collect(), .. doc } } @@ -159,12 +158,12 @@ fn merge_methods( item_id: doc::AstId, docs: ~[doc::MethodDoc] ) -> ~[doc::MethodDoc] { - do vec::map(docs) |doc| { + do docs.iter().transform |doc| { doc::MethodDoc { sig: get_method_sig(srv.clone(), item_id, copy doc.name), .. copy *doc } - } + }.collect() } fn get_method_sig( diff --git a/src/libstd/io.rs b/src/libstd/io.rs index 40793ff1af7b1..bdcad15f45c44 100644 --- a/src/libstd/io.rs +++ b/src/libstd/io.rs @@ -1912,7 +1912,9 @@ mod tests { if len <= ivals.len() { assert_eq!(res.len(), len); } - assert!(ivals.slice(0u, res.len()) == vec::map(res, |x| *x as int)); + for ivals.iter().zip(res.iter()).advance |(iv, c)| { + assert!(*iv == *c as int) + } } } let mut i = 0; diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs index 55eae8f8fae18..77befbf19aa92 100644 --- a/src/libstd/iterator.rs +++ b/src/libstd/iterator.rs @@ -85,8 +85,7 @@ pub trait IteratorUtil { // 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. This - /// similar to the `vec::map` function. + /// element returned by the first, yielding the mapped element instead. /// /// # Example /// diff --git a/src/libstd/tuple.rs b/src/libstd/tuple.rs index fefd55c354158..4570254627833 100644 --- a/src/libstd/tuple.rs +++ b/src/libstd/tuple.rs @@ -14,6 +14,8 @@ use kinds::Copy; use vec; +use vec::ImmutableVector; +use iterator::IteratorUtil; pub use self::inner::*; @@ -96,7 +98,7 @@ impl<'self,A:Copy,B:Copy> ExtendedTupleOps for (&'self [A], &'self [B]) { fn map(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C] { match *self { (ref a, ref b) => { - vec::map_zip(*a, *b, f) + a.iter().zip(b.iter()).transform(|(aa, bb)| f(aa, bb)).collect() } } } @@ -116,7 +118,7 @@ impl ExtendedTupleOps for (~[A], ~[B]) { fn map(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C] { match *self { (ref a, ref b) => { - vec::map_zip(*a, *b, f) + a.iter().zip(b.iter()).transform(|(aa, bb)| f(aa, bb)).collect() } } } diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 976a67ef4227b..65f962c36ef8c 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -365,15 +365,6 @@ pub fn append_one(lhs: ~[T], x: T) -> ~[T] { // Functional utilities -/// Apply a function to each element of a vector and return the results -pub fn map(v: &[T], f: &fn(t: &T) -> U) -> ~[U] { - let mut result = with_capacity(v.len()); - for v.iter().advance |elem| { - result.push(f(elem)); - } - result -} - /// Consumes a vector, mapping it into a different vector. This function takes /// ownership of the supplied vector `v`, moving each element into the closure /// provided to generate a new element. The vector of new elements is then @@ -388,16 +379,6 @@ pub fn map_consume(v: ~[T], f: &fn(v: T) -> U) -> ~[U] { } result } - -/// Apply a function to each element of a vector and return the results -pub fn mapi(v: &[T], f: &fn(uint, t: &T) -> U) -> ~[U] { - let mut i = 0; - do map(v) |e| { - i += 1; - f(i - 1, e) - } -} - /** * Apply a function to each element of a vector and return a concatenation * of each result vector @@ -408,23 +389,6 @@ pub fn flat_map(v: &[T], f: &fn(t: &T) -> ~[U]) -> ~[U] { result } -/** - * Apply a function to each pair of elements and return the results. - * Equivalent to `map(zip(v0, v1), f)`. - */ -pub fn map_zip(v0: &[T], v1: &[U], - f: &fn(t: &T, v: &U) -> V) -> ~[V] { - let v0_len = v0.len(); - if v0_len != v1.len() { fail!(); } - let mut u: ~[V] = ~[]; - let mut i = 0u; - while i < v0_len { - u.push(f(&v0[i], &v1[i])); - i += 1u; - } - u -} - pub fn filter_map( v: ~[T], f: &fn(t: T) -> Option) -> ~[U] @@ -983,14 +947,13 @@ pub trait ImmutableVector<'self, T> { fn last(&self) -> &'self T; fn last_opt(&self) -> Option<&'self T>; fn rposition(&self, f: &fn(t: &T) -> bool) -> Option; - fn map(&self, f: &fn(t: &T) -> U) -> ~[U]; - fn mapi(&self, f: &fn(uint, t: &T) -> U) -> ~[U]; - fn map_r(&self, f: &fn(x: &T) -> U) -> ~[U]; fn flat_map(&self, f: &fn(t: &T) -> ~[U]) -> ~[U]; fn filter_mapped(&self, f: &fn(t: &T) -> Option) -> ~[U]; unsafe fn unsafe_ref(&self, index: uint) -> *T; fn bsearch(&self, f: &fn(&T) -> Ordering) -> Option; + + fn map(&self, &fn(t: &T) -> U) -> ~[U]; } /// Extension methods for vectors @@ -1087,29 +1050,6 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] { None } - /// Apply a function to each element of a vector and return the results - #[inline] - fn map(&self, f: &fn(t: &T) -> U) -> ~[U] { map(*self, f) } - - /** - * Apply a function to the index and value of each element in the vector - * and return the results - */ - fn mapi(&self, f: &fn(uint, t: &T) -> U) -> ~[U] { - mapi(*self, f) - } - - #[inline] - fn map_r(&self, f: &fn(x: &T) -> U) -> ~[U] { - let mut r = ~[]; - let mut i = 0; - while i < self.len() { - r.push(f(&self[i])); - i += 1; - } - r - } - /** * Apply a function to each element of a vector and return a concatenation * of each result vector @@ -1165,6 +1105,13 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] { } return None; } + + /// Deprecated, use iterators where possible + /// (`self.iter().transform(f)`). Apply a function to each element + /// of a vector and return the results. + fn map(&self, f: &fn(t: &T) -> U) -> ~[U] { + self.iter().transform(f).collect() + } } #[allow(missing_doc)] @@ -2101,7 +2048,7 @@ pub mod bytes { impl Clone for ~[A] { #[inline] fn clone(&self) -> ~[A] { - self.map(|item| item.clone()) + self.iter().transform(|item| item.clone()).collect() } } @@ -2648,16 +2595,16 @@ mod tests { #[test] fn test_map() { // Test on-stack map. - let mut v = ~[1u, 2u, 3u]; - let mut w = map(v, square_ref); + let v = &[1u, 2u, 3u]; + let mut w = v.map(square_ref); assert_eq!(w.len(), 3u); assert_eq!(w[0], 1u); assert_eq!(w[1], 4u); assert_eq!(w[2], 9u); // Test on-heap map. - v = ~[1u, 2u, 3u, 4u, 5u]; - w = map(v, square_ref); + let v = ~[1u, 2u, 3u, 4u, 5u]; + w = v.map(square_ref); assert_eq!(w.len(), 5u); assert_eq!(w[0], 1u); assert_eq!(w[1], 4u); @@ -2666,17 +2613,6 @@ mod tests { assert_eq!(w[4], 25u); } - #[test] - fn test_map_zip() { - fn times(x: &int, y: &int) -> int { *x * *y } - let f = times; - let v0 = ~[1, 2, 3, 4, 5]; - let v1 = ~[5, 4, 3, 2, 1]; - let u = map_zip::(v0, v1, f); - let mut i = 0; - while i < 5 { assert!(v0[i] * v1[i] == u[i]); i += 1; } - } - #[test] fn test_filter_mapped() { // Test on-stack filter-map. @@ -2708,7 +2644,7 @@ mod tests { let mix: ~[int] = ~[9, 2, 6, 7, 1, 0, 0, 3]; let mix_dest: ~[int] = ~[1, 3, 0, 0]; assert!(filter_mapped(all_even, halve) == - map(all_even, halve_for_sure)); + all_even.map(halve_for_sure)); assert_eq!(filter_mapped(all_odd1, halve), ~[]); assert_eq!(filter_mapped(all_odd2, halve), ~[]); assert_eq!(filter_mapped(mix, halve), mix_dest); @@ -2746,7 +2682,7 @@ mod tests { let mix: ~[int] = ~[9, 2, 6, 7, 1, 0, 0, 3]; let mix_dest: ~[int] = ~[1, 3, 0, 0]; assert!(filter_map(all_even, halve) == - map(all_even0, halve_for_sure)); + all_even0.map(halve_for_sure)); assert_eq!(filter_map(all_odd1, halve), ~[]); assert_eq!(filter_map(all_odd2, halve), ~[]); assert_eq!(filter_map(mix, halve), mix_dest); @@ -3278,7 +3214,7 @@ mod tests { fn test_map_fail() { let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)]; let mut i = 0; - do map(v) |_elt| { + do v.map |_elt| { if i == 2 { fail!() } @@ -3302,44 +3238,13 @@ mod tests { }; } - #[test] - #[ignore(windows)] - #[should_fail] - fn test_mapi_fail() { - let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)]; - let mut i = 0; - do mapi(v) |_i, _elt| { - if i == 2 { - fail!() - } - i += 0; - ~[(~0, @0)] - }; - } - #[test] #[ignore(windows)] #[should_fail] fn test_flat_map_fail() { let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)]; let mut i = 0; - do map(v) |_elt| { - if i == 2 { - fail!() - } - i += 0; - ~[(~0, @0)] - }; - } - - #[test] - #[ignore(windows)] - #[should_fail] - #[allow(non_implicitly_copyable_typarams)] - fn test_map_zip_fail() { - let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)]; - let mut i = 0; - do map_zip(v, v) |_elt1, _elt2| { + do flat_map(v) |_elt| { if i == 2 { fail!() } diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index ee7c7180f8db2..529d5bfe70b49 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -814,7 +814,7 @@ mod test { // convert a list of uints to an @[ident] // (ignores the interner completely) fn uints_to_idents (uints: &~[uint]) -> @~[ident] { - @uints.map(|u|{ ident {name:*u, ctxt: empty_ctxt} }) + @uints.map(|u| ident {name:*u, ctxt: empty_ctxt}) } fn id (u : uint, s: SyntaxContext) -> ident { diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs index 77dbd96255d12..405f9e3438beb 100644 --- a/src/libsyntax/ext/deriving/decodable.rs +++ b/src/libsyntax/ext/deriving/decodable.rs @@ -91,9 +91,9 @@ fn decodable_substructure(cx: @ExtCtxt, span: span, } } Right(ref fields) => { - let fields = do fields.mapi |i, f| { + let fields = do fields.iter().enumerate().transform |(i, f)| { cx.field_imm(span, *f, getarg(cx.str_of(*f), i)) - }; + }.collect(); cx.expr_struct_ident(span, substr.type_ident, fields) } }; @@ -133,9 +133,9 @@ fn decodable_substructure(cx: @ExtCtxt, span: span, } } Right(ref fields) => { - let fields = do fields.mapi |i, f| { + let fields = do fields.iter().enumerate().transform |(i, f)| { cx.field_imm(span, *f, getarg(i)) - }; + }.collect(); cx.expr_struct_ident(span, name, fields) } }; diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs index 10d9f878bc451..0e4fc9d96fa87 100644 --- a/src/libsyntax/ext/deriving/generic.rs +++ b/src/libsyntax/ext/deriving/generic.rs @@ -591,14 +591,14 @@ impl<'self> MethodDef<'self> { // transpose raw_fields let fields = match raw_fields { [self_arg, .. rest] => { - do self_arg.mapi |i, &(opt_id, field)| { + do self_arg.iter().enumerate().transform |(i, &(opt_id, field))| { let other_fields = do rest.map |l| { match &l[i] { &(_, ex) => ex } }; (opt_id, field, other_fields) - } + }.collect() } [] => { cx.span_bug(span, "No self arguments to non-static \ method in generic `deriving`") } @@ -745,10 +745,11 @@ impl<'self> MethodDef<'self> { } } let field_tuples = - do vec::map_zip(*self_vec, - enum_matching_fields) |&(id, self_f), &other| { + do self_vec.iter() + .zip(enum_matching_fields.iter()) + .transform |(&(id, self_f), &other)| { (id, self_f, other) - }; + }.collect(); substructure = EnumMatching(variant_index, variant, field_tuples); } None => { diff --git a/src/libsyntax/ext/deriving/rand.rs b/src/libsyntax/ext/deriving/rand.rs index 19aa29a62a9c0..cc2050d9bd7a0 100644 --- a/src/libsyntax/ext/deriving/rand.rs +++ b/src/libsyntax/ext/deriving/rand.rs @@ -91,7 +91,7 @@ fn rand_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr { let rand_variant = cx.expr_binary(span, ast::rem, rv_call, variant_count); - let mut arms = do variants.mapi |i, id_sum| { + let mut arms = do variants.iter().enumerate().transform |(i, id_sum)| { let i_expr = cx.expr_uint(span, i); let pat = cx.pat_lit(span, i_expr); @@ -102,7 +102,7 @@ fn rand_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr { rand_thing(cx, span, ident, summary, || rand_call())) } } - }; + }.collect::<~[ast::arm]>(); // _ => {} at the end. Should never occur arms.push(cx.arm_unreachable(span)); diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs index 3044cd50b344c..0e24725ea990c 100644 --- a/src/libsyntax/ext/pipes/pipec.rs +++ b/src/libsyntax/ext/pipes/pipec.rs @@ -54,8 +54,9 @@ impl gen_send for message { let next = this.proto.get_state(next_state.state); assert!(next_state.tys.len() == next.generics.ty_params.len()); - let arg_names = tys.mapi(|i, _ty| cx.ident_of(~"x_"+i.to_str())); - let args_ast = vec::map_zip(arg_names, *tys, |n, t| cx.arg(span, *n, *t)); + let arg_names = vec::from_fn(tys.len(), |i| cx.ident_of("x_"+i.to_str())); + let args_ast: ~[ast::arg] = arg_names.iter().zip(tys.iter()) + .transform(|(n, t)| cx.arg(span, *n, *t)).collect(); let pipe_ty = cx.ty_path( path(~[this.data_name()], span) @@ -133,11 +134,10 @@ impl gen_send for message { message(ref _id, span, ref tys, this, None) => { debug!("pipec: no next state"); - let arg_names = tys.mapi(|i, _ty| (~"x_" + i.to_str())); + let arg_names = vec::from_fn(tys.len(), |i| "x_" + i.to_str()); - let args_ast = do vec::map_zip(arg_names, *tys) |n, t| { - cx.arg(span, cx.ident_of(*n), *t) - }; + let args_ast: ~[ast::arg] = arg_names.iter().zip(tys.iter()) + .transform(|(n, t)| cx.arg(span, cx.ident_of(*n), *t)).collect(); let args_ast = vec::append( ~[cx.arg(span, diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 71dc82be41436..f6325c2eb2c12 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -21,7 +21,6 @@ use print::pprust; use std::io; use std::result; -use std::vec; // These macros all relate to the file system; they either return // the column/row/filename of the expression, or they include @@ -106,9 +105,7 @@ pub fn expand_include_bin(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) let file = get_single_str_from_tts(cx, sp, tts, "include_bin!"); match io::read_whole_file(&res_rel_file(cx, sp, &Path(file))) { result::Ok(src) => { - let u8_exprs = vec::map(src, |char| { - cx.expr_u8(sp, *char) - }); + let u8_exprs: ~[@ast::expr] = src.iter().transform(|char| cx.expr_u8(sp, *char)).collect(); base::MRExpr(cx.expr_vec(sp, u8_exprs)) } result::Err(ref e) => { diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 7c69bdd01c815..cddba3583734d 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -326,8 +326,7 @@ pub fn parse( cur_eis.push(new_ei); } - let matches = vec::map(ei.matches, // fresh, same size: - |_m| ~[]); + let matches = vec::from_elem(ei.matches.len(), ~[]); let ei_t = ei; cur_eis.push(~MatcherPos { elts: copy *matchers, diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 2fc111da453cf..4e1451239962f 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -699,7 +699,7 @@ pub fn noop_fold_ty(t: &ty_, fld: @ast_fold) -> ty_ { // ...nor do modules pub fn noop_fold_mod(m: &_mod, fld: @ast_fold) -> _mod { ast::_mod { - view_items: vec::map(m.view_items, |x| fld.fold_view_item(*x)), + view_items: m.view_items.iter().transform(|x| fld.fold_view_item(*x)).collect(), items: vec::filter_mapped(m.items, |x| fld.fold_item(*x)), } } @@ -708,8 +708,8 @@ fn noop_fold_foreign_mod(nm: &foreign_mod, fld: @ast_fold) -> foreign_mod { ast::foreign_mod { sort: nm.sort, abis: nm.abis, - view_items: vec::map(nm.view_items, |x| fld.fold_view_item(*x)), - items: vec::map(nm.items, |x| fld.fold_foreign_item(*x)), + view_items: nm.view_items.iter().transform(|x| fld.fold_view_item(*x)).collect(), + items: nm.items.iter().transform(|x| fld.fold_foreign_item(*x)).collect(), } } @@ -728,8 +728,8 @@ fn noop_fold_variant(v: &variant_, fld: @ast_fold) -> variant_ { } struct_variant_kind(struct_def) => { kind = struct_variant_kind(@ast::struct_def { - fields: vec::map(struct_def.fields, - |f| fld.fold_struct_field(*f)), + fields: struct_def.fields.iter() + .transform(|f| fld.fold_struct_field(*f)).collect(), ctor_id: struct_def.ctor_id.map(|c| fld.new_id(*c)) }) } @@ -824,8 +824,7 @@ impl ast_fold for AstFoldFns { @view_item { @ast::view_item { node: (self.fold_view_item)(&x.node, self as @ast_fold), - attrs: vec::map(x.attrs, |a| - fold_attribute_(*a, self as @ast_fold)), + attrs: x.attrs.iter().transform(|a| fold_attribute_(*a, self as @ast_fold)).collect(), vis: x.vis, span: (self.new_span)(x.span), } diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index eeff4b71c0d2f..bc5efc5fca1f0 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -191,13 +191,13 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result { // Do the BFS. info!("PBFS iteration %?", i); i += 1; - colors = do colors.mapi() |i, c| { + colors = do colors.iter().enumerate().transform |(i, c)| { let c : color = *c; match c { white => { let i = i as node_id; - let neighbors = copy graph[i]; + let neighbors = &graph[i]; let mut color = white; @@ -214,17 +214,17 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result { gray(parent) => { black(parent) } black(parent) => { black(parent) } } - } + }.collect() } // Convert the results. - do vec::map(colors) |c| { + do colors.iter().transform |c| { match *c { white => { -1i64 } black(parent) => { parent } _ => { fail!("Found remaining gray nodes in BFS") } } - } + }.collect() } /// A parallel version of the bfs function. diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs index 49a3a3ec5d7d3..deb2d4b300bc6 100644 --- a/src/test/bench/shootout-chameneos-redux.rs +++ b/src/test/bench/shootout-chameneos-redux.rs @@ -152,7 +152,7 @@ fn rendezvous(nn: uint, set: ~[color]) { // these channels will allow us to talk to each creature by 'name'/index let to_creature: ~[Chan>] = - vec::mapi(set, |ii, col| { + set.iter().enumerate().transform(|(ii, col)| { // create each creature as a listener with a port, and // give us a channel to talk to each let ii = ii; @@ -166,7 +166,7 @@ fn rendezvous(nn: uint, set: ~[color]) { to_rendezvous_log.clone()); } to_creature - }); + }).collect(); let mut creatures_met = 0; diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index d26fe80e8a124..974cdb0a0ef63 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// xfail-pretty (extra blank line is inserted in vec::mapi call) +// xfail-pretty the `let to_child` line gets an extra newline // multi tasking k-nucleotide extern mod extra; @@ -163,14 +163,13 @@ fn main() { - // initialize each sequence sorter - let sizes = ~[1,2,3,4,6,12,18]; - let streams = vec::map(sizes, |_sz| Some(stream())); - let mut streams = streams; + // initialize each sequence sorter + let sizes = ~[1u,2,3,4,6,12,18]; + let mut streams = vec::from_fn(sizes.len(), |_| Some(stream::<~str>())); let mut from_child = ~[]; - let to_child = vec::mapi(sizes, |ii, sz| { + let to_child = do sizes.iter().zip(streams.mut_iter()).transform |(sz, stream_ref)| { let sz = *sz; - let stream = util::replace(&mut streams[ii], None); + let stream = util::replace(stream_ref, None); let (from_child_, to_parent_) = stream.unwrap(); from_child.push(from_child_); @@ -182,7 +181,7 @@ fn main() { }; to_child - }); + }.collect::<~[Chan<~[u8]>]>(); // latch stores true after we've started diff --git a/src/test/compile-fail/lint-unused-imports.rs b/src/test/compile-fail/lint-unused-imports.rs index 4a748cc56700a..e61de0ac11f4c 100644 --- a/src/test/compile-fail/lint-unused-imports.rs +++ b/src/test/compile-fail/lint-unused-imports.rs @@ -30,7 +30,7 @@ use std::io::WriterUtil; // Make sure this import is warned about when at least one of its imported names // is unused -use std::vec::{filter, map}; //~ ERROR unused import +use std::vec::{filter, from_elem}; //~ ERROR unused import mod foo { pub struct Point{x: int, y: int} @@ -58,7 +58,5 @@ fn main() { let a = 3; ignore(a); io::stdout().write_str("a"); - let _a = do map([2]) |&x| { - x + 2 - }; + let _a = from_elem(0, 0); } diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs index ff5d0e9f05c65..8ea2a88fa09a7 100644 --- a/src/test/run-pass/block-arg.rs +++ b/src/test/run-pass/block-arg.rs @@ -28,7 +28,7 @@ pub fn main() { assert!(any_negative); // Higher precedence than unary operations: - let abs_v = do vec::map(v) |e| { e.abs() }; + let abs_v = do v.iter().transform |e| { e.abs() }.collect::<~[float]>(); assert!(do abs_v.iter().all |e| { e.is_positive() }); assert!(!do abs_v.iter().any_ |e| { e.is_negative() }); diff --git a/src/test/run-pass/block-vec-map_zip.rs b/src/test/run-pass/block-vec-map_zip.rs deleted file mode 100644 index 739dbab4d3af4..0000000000000 --- a/src/test/run-pass/block-vec-map_zip.rs +++ /dev/null @@ -1,20 +0,0 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use std::vec; - -pub fn main() { - let v = - vec::map_zip(~[1, 2, 3, 4, 5], - ~[true, false, false, true, true], - |i, b| if *b { -(*i) } else { *i } ); - error!(v.clone()); - assert_eq!(v, ~[-1, 2, 3, -4, -5]); -} diff --git a/src/test/run-pass/trait-to-str.rs b/src/test/run-pass/trait-to-str.rs index 4029bd18338c3..3e4cfdc105cad 100644 --- a/src/test/run-pass/trait-to-str.rs +++ b/src/test/run-pass/trait-to-str.rs @@ -15,7 +15,9 @@ extern mod std; use std::str::StrVector; -use std::{int, vec}; +use std::vec::ImmutableVector; +use std::iterator::IteratorUtil; +use std::int; trait to_str { fn to_str(&self) -> ~str; @@ -27,7 +29,7 @@ impl to_str for int { impl to_str for ~[T] { fn to_str(&self) -> ~str { - ~"[" + vec::map(*self, |e| e.to_str()).connect(", ") + "]" + fmt!("[%s]", self.iter().transform(|e| e.to_str()).collect::<~[~str]>().connect(", ")) } }