user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

std: Rename Iterator.transform -> .map

Browse source 
cc #5898
This commit is contained in:
Erick Tryzelaar 2013-08-09 20:09:47 -07:00
parent 4062b84f4a
commit 68f40d215e
72 changed files with 188 additions and 189 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/compiletest/header.rs
View file

@ -142,7 +142,7 @@ fn parse_check_line(line: &str) -> Option<~str> {
fn parse_exec_env(line: &str) -> Option<(~str, ~str)> {
do parse_name_value_directive(line, ~"exec-env").map |nv| {
// nv is either FOO or FOO=BAR
let mut strs: ~[~str] = nv.splitn_iter('=', 1).transform(|s| s.to_owned()).collect();
let mut strs: ~[~str] = nv.splitn_iter('=', 1).map(|s| s.to_owned()).collect();
match strs.len() {
1u => (strs.pop(), ~""),

6
src/compiletest/runtest.rs
View file

@ -350,13 +350,13 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
fatal(~"process did not return an error status");
}
let prefixes = expected_errors.iter().transform(|ee| {
let prefixes = expected_errors.iter().map(|ee| {
fmt!("%s:%u:", testfile.to_str(), ee.line)
}).collect::<~[~str]>();
fn to_lower( s : &str ) -> ~str {
let i = s.iter();
let c : ~[char] = i.transform( |c| {
let c : ~[char] = i.map( |c| {
if c.is_ascii() {
c.to_ascii().to_lower().to_char()
} else {
@ -760,7 +760,7 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
let cmdline = make_cmdline("", args.prog, args.args);
// get bare program string
let mut tvec: ~[~str] = args.prog.split_iter('/').transform(|ts| ts.to_owned()).collect();
let mut tvec: ~[~str] = args.prog.split_iter('/').map(|ts| ts.to_owned()).collect();
let prog_short = tvec.pop();
// copy to target

6
src/libextra/bitv.rs
View file

@ -869,7 +869,7 @@ impl BitvSet {
let min = num::min(self.bitv.storage.len(), other.bitv.storage.len());
self.bitv.storage.slice(0, min).iter().enumerate()
.zip(Repeat::new(&other.bitv.storage))
.transform(|((i, &w), o_store)| (i * uint::bits, w, o_store[i]))
.map(|((i, &w), o_store)| (i * uint::bits, w, o_store[i]))
}
/// Visits each word in self or other that extends beyond the other. This
@ -888,11 +888,11 @@ impl BitvSet {
if olen < slen {
self.bitv.storage.slice_from(olen).iter().enumerate()
.zip(Repeat::new(olen))
.transform(|((i, &w), min)| (true, (i + min) * uint::bits, w))
.map(|((i, &w), min)| (true, (i + min) * uint::bits, w))
} else {
other.bitv.storage.slice_from(slen).iter().enumerate()
.zip(Repeat::new(slen))
.transform(|((i, &w), min)| (false, (i + min) * uint::bits, w))
.map(|((i, &w), min)| (false, (i + min) * uint::bits, w))
}
}
}

14
src/libextra/dlist.rs
View file

@ -600,7 +600,7 @@ impl<A: Eq> Eq for DList<A> {
impl<A: Clone> Clone for DList<A> {
fn clone(&self) -> DList<A> {
self.iter().transform(|x| x.clone()).collect()
self.iter().map(|x| x.clone()).collect()
}
}
@ -690,7 +690,7 @@ mod tests {
#[cfg(test)]
fn list_from<T: Clone>(v: &[T]) -> DList<T> {
v.iter().transform(|x| (*x).clone()).collect()
v.iter().map(|x| (*x).clone()).collect()
}
#[test]
@ -1014,7 +1014,7 @@ mod tests {
fn bench_collect_into(b: &mut test::BenchHarness) {
let v = &[0, ..64];
do b.iter {
let _: DList<int> = v.iter().transform(|x| *x).collect();
let _: DList<int> = v.iter().map(|x| *x).collect();
}
}
@ -1075,7 +1075,7 @@ mod tests {
#[bench]
fn bench_iter(b: &mut test::BenchHarness) {
let v = &[0, ..128];
let m: DList<int> = v.iter().transform(|&x|x).collect();
let m: DList<int> = v.iter().map(|&x|x).collect();
do b.iter {
assert!(m.iter().len_() == 128);
}
@ -1083,7 +1083,7 @@ mod tests {
#[bench]
fn bench_iter_mut(b: &mut test::BenchHarness) {
let v = &[0, ..128];
let mut m: DList<int> = v.iter().transform(|&x|x).collect();
let mut m: DList<int> = v.iter().map(|&x|x).collect();
do b.iter {
assert!(m.mut_iter().len_() == 128);
}
@ -1091,7 +1091,7 @@ mod tests {
#[bench]
fn bench_iter_rev(b: &mut test::BenchHarness) {
let v = &[0, ..128];
let m: DList<int> = v.iter().transform(|&x|x).collect();
let m: DList<int> = v.iter().map(|&x|x).collect();
do b.iter {
assert!(m.rev_iter().len_() == 128);
}
@ -1099,7 +1099,7 @@ mod tests {
#[bench]
fn bench_iter_mut_rev(b: &mut test::BenchHarness) {
let v = &[0, ..128];
let mut m: DList<int> = v.iter().transform(|&x|x).collect();
let mut m: DList<int> = v.iter().map(|&x|x).collect();
do b.iter {
assert!(m.mut_rev_iter().len_() == 128);
}

2
src/libextra/fileinput.rs
View file

@ -353,7 +353,7 @@ a literal `-`.
*/
// XXX: stupid, unclear name
pub fn pathify(vec: &[~str], stdin_hyphen : bool) -> ~[Option<Path>] {
vec.iter().transform(|str| {
vec.iter().map(|str| {
if stdin_hyphen && "-" == *str {
None
} else {

2
src/libextra/getopts.rs
View file

@ -647,7 +647,7 @@ pub mod groups {
let desc_sep = "\n" + " ".repeat(24);
let mut rows = opts.iter().transform(|optref| {
let mut rows = opts.iter().map(|optref| {
let OptGroup{short_name: short_name,
long_name: long_name,
hint: hint,

4
src/libextra/num/bigint.rs
View file

@ -287,7 +287,7 @@ impl Mul<BigUint, BigUint> for BigUint {
if n == 1 { return (*a).clone(); }
let mut carry = 0;
let mut prod = do a.data.iter().transform |ai| {
let mut prod = do a.data.iter().map |ai| {
let (hi, lo) = BigDigit::from_uint(
(*ai as uint) * (n as uint) + (carry as uint)
);
@ -625,7 +625,7 @@ impl BigUint {
if n_bits == 0 || self.is_zero() { return (*self).clone(); }
let mut carry = 0;
let mut shifted = do self.data.iter().transform |elem| {
let mut shifted = do self.data.iter().map |elem| {
let (hi, lo) = BigDigit::from_uint(
(*elem as uint) << n_bits | (carry as uint)
);

6
src/libextra/par.rs
View file

@ -77,7 +77,7 @@ fn map_slices<A:Clone + Send,B:Clone + Send>(
info!("num_tasks: %?", (num_tasks, futures.len()));
assert_eq!(num_tasks, futures.len());
do futures.move_iter().transform |ys| {
do futures.move_iter().map |ys| {
let mut ys = ys;
ys.get()
}.collect()
@ -90,7 +90,7 @@ pub fn map<A:Clone + Send,B:Clone + Send>(
vec::concat(map_slices(xs, || {
let f = fn_factory();
let result: ~fn(uint, &[A]) -> ~[B] =
|_, slice| slice.iter().transform(|x| f(x)).collect();
|_, slice| slice.iter().map(|x| f(x)).collect();
result
}))
}
@ -102,7 +102,7 @@ pub fn mapi<A:Clone + Send,B:Clone + Send>(
let slices = map_slices(xs, || {
let f = fn_factory();
let result: ~fn(uint, &[A]) -> ~[B] = |base, slice| {
slice.iter().enumerate().transform(|(i, x)| {
slice.iter().enumerate().map(|(i, x)| {
f(i + base, x)
}).collect()
};

2
src/libextra/priority_queue.rs
View file

@ -367,7 +367,7 @@ mod tests {
fn test_from_iter() {
let xs = ~[9u, 8, 7, 6, 5, 4, 3, 2, 1];
let mut q: PriorityQueue<uint> = xs.rev_iter().transform(|&x| x).collect();
let mut q: PriorityQueue<uint> = xs.rev_iter().map(|&x| x).collect();
for &x in xs.iter() {
assert_eq!(q.pop(), x);

4
src/libextra/ringbuf.rs
View file

@ -692,8 +692,8 @@ mod tests {
fn test_from_iterator() {
use std::iterator;
let v = ~[1,2,3,4,5,6,7];
let deq: RingBuf<int> = v.iter().transform(|&x| x).collect();
let u: ~[int] = deq.iter().transform(|&x| x).collect();
let deq: RingBuf<int> = v.iter().map(|&x| x).collect();
let u: ~[int] = deq.iter().map(|&x| x).collect();
assert_eq!(u, v);
let mut seq = iterator::count(0u, 2).take_(256);

2
src/libextra/terminfo/parm.rs
View file

@ -105,7 +105,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)
*dst = (*src).clone();
}
for c in cap.iter().transform(|&x| x) {
for c in cap.iter().map(|&x| x) {
let cur = c as char;
let mut old_state = state;
match state {

2
src/libextra/terminfo/parser/compiled.rs
View file

@ -214,7 +214,7 @@ pub fn parse(file: @Reader, longnames: bool) -> Result<~TermInfo, ~str> {
}
let names_str = str::from_bytes(file.read_bytes(names_bytes as uint - 1)); // don't read NUL
let term_names: ~[~str] = names_str.split_iter('|').transform(|s| s.to_owned()).collect();
let term_names: ~[~str] = names_str.split_iter('|').map(|s| s.to_owned()).collect();
file.read_byte(); // consume NUL

8
src/libextra/test.rs
View file

@ -526,10 +526,10 @@ impl ConsoleTestState {
pub fn fmt_metrics(mm: &MetricMap) -> ~str {
let v : ~[~str] = mm.iter()
.transform(|(k,v)| fmt!("%s: %f (+/- %f)",
*k,
v.value as float,
v.noise as float))
.map(|(k,v)| fmt!("%s: %f (+/- %f)",
*k,
v.value as float,
v.noise as float))
.collect();
v.connect(", ")
}

4
src/libextra/treemap.rs
View file

@ -1259,7 +1259,7 @@ mod test_treemap {
fn test_from_iter() {
let xs = ~[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
let map: TreeMap<int, int> = xs.iter().transform(|&x| x).collect();
let map: TreeMap<int, int> = xs.iter().map(|&x| x).collect();
for &(k, v) in xs.iter() {
assert_eq!(map.find(&k), Some(&v));
@ -1558,7 +1558,7 @@ mod test_set {
fn test_from_iter() {
let xs = ~[1, 2, 3, 4, 5, 6, 7, 8, 9];
let set: TreeSet<int> = xs.iter().transform(|&x| x).collect();
let set: TreeSet<int> = xs.iter().map(|&x| x).collect();
for x in xs.iter() {
assert!(set.contains(x));

6
src/librustc/back/rpath.rs
View file

@ -49,7 +49,7 @@ fn get_sysroot_absolute_rt_lib(sess: session::Session) -> Path {
}
pub fn rpaths_to_flags(rpaths: &[Path]) -> ~[~str] {
rpaths.iter().transform(|rpath| fmt!("-Wl,-rpath,%s",rpath.to_str())).collect()
rpaths.iter().map(|rpath| fmt!("-Wl,-rpath,%s",rpath.to_str())).collect()
}
fn get_rpaths(os: session::os,
@ -100,7 +100,7 @@ fn get_rpaths(os: session::os,
fn get_rpaths_relative_to_output(os: session::os,
output: &Path,
libs: &[Path]) -> ~[Path] {
libs.iter().transform(|a| get_rpath_relative_to_output(os, output, a)).collect()
libs.iter().map(|a| get_rpath_relative_to_output(os, output, a)).collect()
}
pub fn get_rpath_relative_to_output(os: session::os,
@ -123,7 +123,7 @@ pub fn get_rpath_relative_to_output(os: session::os,
}
fn get_absolute_rpaths(libs: &[Path]) -> ~[Path] {
libs.iter().transform(|a| get_absolute_rpath(a)).collect()
libs.iter().map(|a| get_absolute_rpath(a)).collect()
}
pub fn get_absolute_rpath(lib: &Path) -> Path {

6
src/librustc/driver/driver.rs
View file

@ -120,7 +120,7 @@ pub fn build_configuration(sess: Session, argv0: @str, input: &input) ->
// Convert strings provided as --cfg [cfgspec] into a crate_cfg
fn parse_cfgspecs(cfgspecs: ~[~str],
demitter: diagnostic::Emitter) -> ast::CrateConfig {
do cfgspecs.move_iter().transform |s| {
do cfgspecs.move_iter().map |s| {
let sess = parse::new_parse_sess(Some(demitter));
parse::parse_meta_from_source_str(@"cfgspec", s.to_managed(), ~[], sess)
}.collect::<ast::CrateConfig>()
@ -726,7 +726,7 @@ pub fn build_session_options(binary: @str,
let addl_lib_search_paths = getopts::opt_strs(matches, "L").map(|s| Path(*s));
let linker = getopts::opt_maybe_str(matches, "linker");
let linker_args = getopts::opt_strs(matches, "link-args").flat_map( |a| {
a.split_iter(' ').transform(|arg| arg.to_owned()).collect()
a.split_iter(' ').map(|arg| arg.to_owned()).collect()
});
let cfg = parse_cfgspecs(getopts::opt_strs(matches, "cfg"), demitter);
@ -737,7 +737,7 @@ pub fn build_session_options(binary: @str,
let custom_passes = match getopts::opt_maybe_str(matches, "passes") {
None => ~[],
Some(s) => {
s.split_iter(|c: char| c == ' ' || c == ',').transform(|s| {
s.split_iter(|c: char| c == ' ' || c == ',').map(|s| {
s.trim().to_owned()
}).collect()
}

6
src/librustc/front/config.rs
View file

@ -102,12 +102,12 @@ fn fold_item_underscore(cx: @Context, item: &ast::item_,
let item = match *item {
ast::item_impl(ref a, ref b, ref c, ref methods) => {
let methods = methods.iter().filter(|m| method_in_cfg(cx, **m))
.transform(|x| *x).collect();
.map(|x| *x).collect();
ast::item_impl((*a).clone(), (*b).clone(), (*c).clone(), methods)
}
ast::item_trait(ref a, ref b, ref methods) => {
let methods = methods.iter().filter(|m| trait_method_in_cfg(cx, *m) )
.transform(|x| (*x).clone()).collect();
.map(|x| (*x).clone()).collect();
ast::item_trait((*a).clone(), (*b).clone(), methods)
}
ref item => (*item).clone(),
@ -180,5 +180,5 @@ fn trait_method_in_cfg(cx: @Context, meth: &ast::trait_method) -> bool {
// Determine if an item should be translated in the current crate
// configuration based on the item's attributes
fn in_cfg(cfg: &[@ast::MetaItem], attrs: &[ast::Attribute]) -> bool {
attr::test_cfg(cfg, attrs.iter().transform(|x| *x))
attr::test_cfg(cfg, attrs.iter().map(|x| *x))
}

4
src/librustc/front/test.rs
View file

@ -126,7 +126,7 @@ fn fold_mod(cx: @mut TestCtxt,
let mod_nomain = ast::_mod {
view_items: m.view_items.clone(),
items: m.items.iter().transform(|i| nomain(cx, *i)).collect(),
items: m.items.iter().map(|i| nomain(cx, *i)).collect(),
};
fold::noop_fold_mod(&mod_nomain, fld)
@ -236,7 +236,7 @@ fn is_ignored(cx: @mut TestCtxt, i: @ast::item) -> bool {
do i.attrs.iter().any |attr| {
// check ignore(cfg(foo, bar))
"ignore" == attr.name() && match attr.meta_item_list() {
Some(ref cfgs) => attr::test_cfg(cx.crate.config, cfgs.iter().transform(|x| *x)),
Some(ref cfgs) => attr::test_cfg(cx.crate.config, cfgs.iter().map(|x| *x)),
None => true
}
}

2
src/librustc/metadata/creader.rs
View file

@ -83,7 +83,7 @@ fn warn_if_multiple_versions(e: @mut Env,
*crate_cache[crate_cache.len() - 1].metas
);
let vec: ~[Either<cache_entry, cache_entry>] = crate_cache.iter().transform(|&entry| {
let vec: ~[Either<cache_entry, cache_entry>] = crate_cache.iter().map(|&entry| {
let othername = loader::crate_name_from_metas(*entry.metas);
if name == othername {
Left(entry)

12
src/librustc/middle/cfg/construct.rs
View file

@ -112,23 +112,23 @@ impl CFGBuilder {
ast::pat_enum(_, Some(ref subpats)) |
ast::pat_tup(ref subpats) => {
let pats_exit =
self.pats_all(subpats.iter().transform(|p| *p), pred);
self.pats_all(subpats.iter().map(|p| *p), pred);
self.add_node(pat.id, [pats_exit])
}
ast::pat_struct(_, ref subpats, _) => {
let pats_exit =
self.pats_all(subpats.iter().transform(|f| f.pat), pred);
self.pats_all(subpats.iter().map(|f| f.pat), pred);
self.add_node(pat.id, [pats_exit])
}
ast::pat_vec(ref pre, ref vec, ref post) => {
let pre_exit =
self.pats_all(pre.iter().transform(|p| *p), pred);
self.pats_all(pre.iter().map(|p| *p), pred);
let vec_exit =
self.pats_all(vec.iter().transform(|p| *p), pre_exit);
self.pats_all(vec.iter().map(|p| *p), pre_exit);
let post_exit =
self.pats_all(post.iter().transform(|p| *p), vec_exit);
self.pats_all(post.iter().map(|p| *p), vec_exit);
self.add_node(pat.id, [post_exit])
}
}
@ -376,7 +376,7 @@ impl CFGBuilder {
ast::expr_struct(_, ref fields, base) => {
let base_exit = self.opt_expr(base, pred);
let field_exprs: ~[@ast::expr] =
fields.iter().transform(|f| f.expr).collect();
fields.iter().map(|f| f.expr).collect();
self.straightline(expr, base_exit, field_exprs)
}

2
src/librustc/middle/check_match.rs
View file

@ -657,7 +657,7 @@ pub fn specialize(cx: &MatchCheckCtxt,
ty_to_str(cx.tcx, left_ty)));
}
}
let args = class_fields.iter().transform(|class_field| {
let args = class_fields.iter().map(|class_field| {
match flds.iter().find_(|f|
f.ident == class_field.ident) {
Some(f) => f.pat,

4
src/librustc/middle/const_eval.rs
View file

@ -102,7 +102,7 @@ pub fn classify(e: &expr,
ast::expr_tup(ref es) |
ast::expr_vec(ref es, ast::m_imm) => {
join_all(es.iter().transform(|e| classify(*e, tcx)))
join_all(es.iter().map(|e| classify(*e, tcx)))
}
ast::expr_vstore(e, vstore) => {
@ -116,7 +116,7 @@ pub fn classify(e: &expr,
}
ast::expr_struct(_, ref fs, None) => {
let cs = do fs.iter().transform |f| {
let cs = do fs.iter().map |f| {
classify(f.expr, tcx)
};
join_all(cs)

4
src/librustc/middle/trans/adt.rs
View file

@ -508,7 +508,7 @@ pub fn trans_const(ccx: &mut CrateContext, r: &Repr, discr: uint,
}
General(ref cases) => {
let case = &cases[discr];
let max_sz = cases.iter().transform(|x| x.size).max().unwrap();
let max_sz = cases.iter().map(|x| x.size).max().unwrap();
let discr_ty = C_uint(ccx, discr);
let contents = build_const_struct(ccx, case,
~[discr_ty] + vals);
@ -519,7 +519,7 @@ pub fn trans_const(ccx: &mut CrateContext, r: &Repr, discr: uint,
C_struct(build_const_struct(ccx, nonnull, vals))
} else {
assert_eq!(vals.len(), 0);
let vals = do nonnull.fields.iter().enumerate().transform |(i, &ty)| {
let vals = do nonnull.fields.iter().enumerate().map |(i, &ty)| {
let llty = type_of::sizing_type_of(ccx, ty);
if i == ptrfield { C_null(llty) } else { C_undef(llty) }
}.collect::<~[ValueRef]>();

2
src/librustc/middle/trans/builder.rs
View file

@ -521,7 +521,7 @@ impl Builder {
}
self.inbounds_gep(base, small_vec.slice(0, ixs.len()))
} else {
let v = do ixs.iter().transform |i| { C_i32(*i as i32) }.collect::<~[ValueRef]>();
let v = do ixs.iter().map |i| { C_i32(*i as i32) }.collect::<~[ValueRef]>();
self.count_insn("gepi");
self.inbounds_gep(base, v)
}

2
src/librustc/middle/trans/cabi.rs
View file

@ -37,7 +37,7 @@ pub struct FnType {
impl FnType {
pub fn decl_fn(&self, decl: &fn(fnty: Type) -> ValueRef) -> ValueRef {
let atys = self.arg_tys.iter().transform(|t| t.ty).collect::<~[Type]>();
let atys = self.arg_tys.iter().map(|t| t.ty).collect::<~[Type]>();
let rty = self.ret_ty.ty;
let fnty = Type::func(atys, &rty);
let llfn = decl(fnty);

10
src/librustc/middle/trans/common.rs
View file

@ -316,7 +316,7 @@ pub struct cleanup_path {
pub fn shrink_scope_clean(scope_info: &mut ScopeInfo, size: uint) {
scope_info.landing_pad = None;
scope_info.cleanup_paths = scope_info.cleanup_paths.iter()
.take_while(|&cu| cu.size <= size).transform(|&x|x).collect();
.take_while(|&cu| cu.size <= size).map(|&x|x).collect();
}
pub fn grow_scope_clean(scope_info: &mut ScopeInfo) {
@ -1000,7 +1000,7 @@ pub fn node_id_type_params(bcx: @mut Block, id: ast::NodeId) -> ~[ty::t] {
match bcx.fcx.param_substs {
Some(substs) => {
do params.iter().transform |t| {
do params.iter().map |t| {
ty::subst_tps(tcx, substs.tys, substs.self_ty, *t)
}.collect()
}
@ -1025,7 +1025,7 @@ pub fn resolve_vtables_under_param_substs(tcx: ty::ctxt,
param_substs: Option<@param_substs>,
vts: typeck::vtable_res)
-> typeck::vtable_res {
@vts.iter().transform(|ds|
@vts.iter().map(|ds|
resolve_param_vtables_under_param_substs(tcx,
param_substs,
*ds))
@ -1037,7 +1037,7 @@ pub fn resolve_param_vtables_under_param_substs(
param_substs: Option<@param_substs>,
ds: typeck::vtable_param_res)
-> typeck::vtable_param_res {
@ds.iter().transform(
@ds.iter().map(
|d| resolve_vtable_under_param_substs(tcx,
param_substs,
d))
@ -1063,7 +1063,7 @@ pub fn resolve_vtable_under_param_substs(tcx: ty::ctxt,
typeck::vtable_static(trait_id, ref tys, sub) => {
let tys = match param_substs {
Some(substs) => {
do tys.iter().transform |t| {
do tys.iter().map |t| {
ty::subst_tps(tcx, substs.tys, substs.self_ty, *t)
}.collect()
}

2
src/librustc/middle/trans/consts.rs
View file

@ -499,7 +499,7 @@ fn const_expr_unadjusted(cx: @mut CrateContext, e: &ast::expr) -> ValueRef {
do expr::with_field_tys(tcx, ety, Some(e.id))
|discr, field_tys| {
let cs: ~[ValueRef] = field_tys.iter().enumerate()
.transform(|(ix, &field_ty)| {
.map(|(ix, &field_ty)| {
match fs.iter().find_(|f| field_ty.ident == f.ident) {
Some(f) => const_expr(cx, (*f).expr),
None => {

8
src/librustc/middle/trans/debuginfo.rs
View file

@ -662,7 +662,7 @@ fn enum_metadata(cx: &mut CrateContext,
let enumerators_metadata: ~[DIDescriptor] = variants
.iter()
.transform(|v| {
.map(|v| {
let name: &str = cx.sess.str_of(v.name);
let discriminant_value = v.disr_val as c_ulonglong;
@ -709,7 +709,7 @@ fn enum_metadata(cx: &mut CrateContext,
let variants_member_metadata: ~[DIDescriptor] = do struct_defs
.iter()
.enumerate()
.transform |(i, struct_def)| {
.map |(i, struct_def)| {
let variant_type_metadata = adt_struct_metadata(
cx,
struct_def,
@ -766,7 +766,7 @@ fn enum_metadata(cx: &mut CrateContext,
{
let arg_llvm_types: ~[Type] = do struct_def.fields.map |&ty| { type_of::type_of(cx, ty) };
let arg_metadata: ~[DIType] = do struct_def.fields.iter().enumerate()
.transform |(i, &ty)| {
.map |(i, &ty)| {
match discriminant_type_metadata {
Some(metadata) if i == 0 => metadata,
_ => type_metadata(cx, ty, span)
@ -816,7 +816,7 @@ fn composite_type_metadata(cx: &mut CrateContext,
let member_metadata: ~[DIDescriptor] = member_llvm_types
.iter()
.enumerate()
.transform(|(i, &member_llvm_type)| {
.map(|(i, &member_llvm_type)| {
let (member_size, member_align) = size_and_align_of(cx, member_llvm_type);
let member_offset = machine::llelement_offset(cx, composite_llvm_type, i);
let member_name: &str = member_names[i];

2
src/librustc/middle/trans/expr.rs
View file

@ -582,7 +582,7 @@ fn trans_rvalue_dps_unadjusted(bcx: @mut Block, expr: @ast::expr,
ast::expr_tup(ref args) => {
let repr = adt::represent_type(bcx.ccx(), expr_ty(bcx, expr));
let numbered_fields: ~[(uint, @ast::expr)] =
args.iter().enumerate().transform(|(i, arg)| (i, *arg)).collect();
args.iter().enumerate().map(|(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), _}) => {

8
src/librustc/middle/trans/monomorphize.rs
View file

@ -372,12 +372,12 @@ pub fn make_mono_id(ccx: @mut CrateContext,
debug!("make_mono_id vtables=%s substs=%s",
vts.repr(ccx.tcx), substs.tys.repr(ccx.tcx));
let vts_iter = substs.self_vtables.iter().chain_(vts.iter());
vts_iter.zip(substs_iter).transform(|(vtable, subst)| {
vts_iter.zip(substs_iter).map(|(vtable, subst)| {
let v = vtable.map(|vt| meth::vtable_id(ccx, vt));
(*subst, if !v.is_empty() { Some(@v) } else { None })
}).collect()
}
None => substs_iter.transform(|subst| (*subst, None::<@~[mono_id]>)).collect()
None => substs_iter.map(|subst| (*subst, None::<@~[mono_id]>)).collect()
};
@ -389,7 +389,7 @@ pub fn make_mono_id(ccx: @mut CrateContext,
substs.self_ty.map(|_| type_use::use_repr|type_use::use_tydesc);
let uses_iter = self_use.iter().chain_(uses.iter());
precise_param_ids.iter().zip(uses_iter).transform(|(id, uses)| {
precise_param_ids.iter().zip(uses_iter).map(|(id, uses)| {
if ccx.sess.no_monomorphic_collapse() {
match *id {
(a, b) => mono_precise(a, b)
@ -429,7 +429,7 @@ pub fn make_mono_id(ccx: @mut CrateContext,
}).collect()
}
None => {
precise_param_ids.iter().transform(|x| {
precise_param_ids.iter().map(|x| {
let (a, b) = *x;
mono_precise(a, b)
}).collect()

6
src/librustc/middle/ty.rs
View file

@ -3791,9 +3791,9 @@ pub fn substd_enum_variants(cx: ctxt,
id: ast::def_id,
substs: &substs)
-> ~[@VariantInfo] {
do enum_variants(cx, id).iter().transform |variant_info| {
do enum_variants(cx, id).iter().map |variant_info| {
let substd_args = variant_info.args.iter()
.transform(|aty| subst(cx, substs, *aty)).collect();
.map(|aty| subst(cx, substs, *aty)).collect();
let substd_ctor_ty = subst(cx, substs, variant_info.ctor_ty);
@ -3935,7 +3935,7 @@ pub fn enum_variants(cx: ctxt, id: ast::def_id) -> @~[@VariantInfo] {
_
}, _) => {
let mut last_discriminant: Option<uint> = None;
@enum_definition.variants.iter().transform(|variant| {
@enum_definition.variants.iter().map(|variant| {
let mut discriminant = match last_discriminant {
Some(val) => val + 1,

2
src/librustc/middle/typeck/astconv.rs
View file

@ -724,7 +724,7 @@ pub fn ty_of_closure<AC:AstConv,RS:region_scope + Clone + 'static>(
in_binding_rscope(rscope,
RegionParamNames(bound_lifetime_names.clone()));
let input_tys = do decl.inputs.iter().enumerate().transform |(i, a)| {
let input_tys = do decl.inputs.iter().enumerate().map |(i, a)| {
let expected_arg_ty = do expected_sig.chain_ref |e| {
// no guarantee that the correct number of expected args
// were supplied

2
src/librustc/middle/typeck/check/method.rs
View file

@ -759,7 +759,7 @@ impl<'self> LookupContext<'self> {
-> Option<method_map_entry> {
// XXX(pcwalton): Do we need to clone here?
let relevant_candidates: ~[Candidate] =
candidates.iter().transform(|c| (*c).clone()).
candidates.iter().map(|c| (*c).clone()).
filter(|c| self.is_relevant(rcvr_ty, c)).collect();
let relevant_candidates = self.merge_candidates(relevant_candidates);

4
src/librustc/middle/typeck/check/mod.rs
View file

@ -1818,7 +1818,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
_ => ()
}
let tps : ~[ty::t] = tys.iter().transform(|ty| fcx.to_ty(ty)).collect();
let tps : ~[ty::t] = tys.iter().map(|ty| fcx.to_ty(ty)).collect();
match method::lookup(fcx,
expr,
base,
@ -2644,7 +2644,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.iter().enumerate().transform |(i, e)| {
let elt_ts = do elts.iter().enumerate().map |(i, e)| {
let opt_hint = match flds {
Some(ref fs) if i < fs.len() => Some(fs[i]),
_ => None

2
src/librustc/middle/typeck/check/vtable.rs
View file

@ -100,7 +100,7 @@ fn lookup_vtables(vcx: &VtableContext,
let mut result =
substs.tps.rev_iter()
.zip(type_param_defs.rev_iter())
.transform(|(ty, def)|
.map(|(ty, def)|
lookup_vtables_for_param(vcx, location_info, Some(substs),
&*def.bounds, *ty, is_early))
.to_owned_vec();

2
src/librustc/middle/typeck/coherence.rs
View file

@ -182,7 +182,7 @@ impl CoherenceChecker {
item_impl(_, ref opt_trait, _, _) => {
let opt_trait : ~[trait_ref] =
opt_trait.iter()
.transform(|x| (*x).clone())
.map(|x| (*x).clone())
.collect();
self.check_implementation(item, opt_trait);
}

2
src/librustc/middle/typeck/collect.rs
View file

@ -731,7 +731,7 @@ pub fn convert_methods(ccx: &CrateCtxt,
-> ~[ConvertedMethod]
{
let tcx = ccx.tcx;
return ms.iter().transform(|m| {
return ms.iter().map(|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,

2
src/librustc/rustc.rs
View file

@ -157,7 +157,7 @@ Available lint options:
let lint_dict = lint::get_lint_dict();
let mut lint_dict = lint_dict.move_iter()
.transform(|(k, v)| (v, k))
.map(|(k, v)| (v, k))
.collect::<~[(lint::LintSpec, &'static str)]>();
lint_dict.qsort();

2
src/librustdoc/attr_parser.rs
View file

@ -27,7 +27,7 @@ pub struct CrateAttrs {
fn doc_metas(attrs: ~[ast::Attribute]) -> ~[@ast::MetaItem] {
attrs.iter()
.filter(|at| "doc" == at.name())
.transform(|at| at.desugar_doc().meta())
.map(|at| at.desugar_doc().meta())
.collect()
}

8
src/librustdoc/attr_pass.rs
View file

@ -123,7 +123,7 @@ fn fold_enum(
let doc = fold::default_seq_fold_enum(fold, doc);
doc::EnumDoc {
variants: do doc.variants.iter().transform |variant| {
variants: do doc.variants.iter().map |variant| {
let variant = (*variant).clone();
let desc = {
let variant = variant.clone();
@ -182,7 +182,7 @@ fn merge_method_attrs(
ast_map::node_item(@ast::item {
node: ast::item_trait(_, _, ref methods), _
}, _) => {
methods.iter().transform(|method| {
methods.iter().map(|method| {
match (*method).clone() {
ast::required(ty_m) => {
(to_str(ty_m.ident),
@ -197,7 +197,7 @@ fn merge_method_attrs(
ast_map::node_item(@ast::item {
node: ast::item_impl(_, _, _, ref methods), _
}, _) => {
methods.iter().transform(|method| {
methods.iter().map(|method| {
(to_str(method.ident),
attr_parser::parse_desc(method.attrs.clone()))
}).collect()
@ -206,7 +206,7 @@ fn merge_method_attrs(
}
};
do docs.iter().zip(attrs.iter()).transform |(doc, attrs)| {
do docs.iter().zip(attrs.iter()).map |(doc, attrs)| {
assert!(doc.name == attrs.first());
let desc = attrs.second();

6
src/librustdoc/extract.rs
View file

@ -185,7 +185,7 @@ fn enumdoc_from_enum(
fn variantdocs_from_variants(
variants: ~[ast::variant]
) -> ~[doc::VariantDoc] {
variants.iter().transform(variantdoc_from_variant).collect()
variants.iter().map(variantdoc_from_variant).collect()
}
fn variantdoc_from_variant(variant: &ast::variant) -> doc::VariantDoc {
@ -202,7 +202,7 @@ fn traitdoc_from_trait(
) -> doc::TraitDoc {
doc::TraitDoc {
item: itemdoc,
methods: do methods.iter().transform |method| {
methods: do methods.iter().map |method| {
match (*method).clone() {
ast::required(ty_m) => {
doc::MethodDoc {
@ -238,7 +238,7 @@ fn impldoc_from_impl(
bounds_str: None,
trait_types: ~[],
self_ty: None,
methods: do methods.iter().transform |method| {
methods: do methods.iter().map |method| {
doc::MethodDoc {
name: to_str(method.ident),
brief: None,

14
src/librustdoc/fold.rs
View file

@ -153,7 +153,7 @@ pub fn default_par_fold<T:Clone>(ctxt: T) -> Fold<T> {
pub fn default_seq_fold_doc<T>(fold: &Fold<T>, doc: doc::Doc) -> doc::Doc {
doc::Doc {
pages: do doc.pages.iter().transform |page| {
pages: do doc.pages.iter().map |page| {
match (*page).clone() {
doc::CratePage(doc) => {
doc::CratePage((fold.fold_crate)(fold, doc))
@ -189,7 +189,7 @@ pub fn default_any_fold_mod<T:Clone>(
) -> doc::ModDoc {
doc::ModDoc {
item: (fold.fold_item)(fold, doc.item.clone()),
items: doc.items.iter().transform(|ItemTag| {
items: doc.items.iter().map(|ItemTag| {
fold_ItemTag(fold, (*ItemTag).clone())
}).collect(),
.. doc
@ -202,7 +202,7 @@ pub fn default_seq_fold_mod<T>(
) -> doc::ModDoc {
doc::ModDoc {
item: (fold.fold_item)(fold, doc.item.clone()),
items: doc.items.iter().transform(|ItemTag| {
items: doc.items.iter().map(|ItemTag| {
fold_ItemTag(fold, (*ItemTag).clone())
}).collect(),
.. doc
@ -215,7 +215,7 @@ pub fn default_par_fold_mod<T:Clone>(
) -> doc::ModDoc {
doc::ModDoc {
item: (fold.fold_item)(fold, doc.item.clone()),
items: doc.items.iter().transform(|ItemTag| {
items: doc.items.iter().map(|ItemTag| {
fold_ItemTag(fold, (*ItemTag).clone())
}).collect(),
.. doc
@ -228,7 +228,7 @@ pub fn default_any_fold_nmod<T:Clone>(
) -> doc::NmodDoc {
doc::NmodDoc {
item: (fold.fold_item)(fold, doc.item.clone()),
fns: doc.fns.iter().transform(|FnDoc| {
fns: doc.fns.iter().map(|FnDoc| {
(fold.fold_fn)(fold, (*FnDoc).clone())
}).collect(),
.. doc
@ -241,7 +241,7 @@ pub fn default_seq_fold_nmod<T>(
) -> doc::NmodDoc {
doc::NmodDoc {
item: (fold.fold_item)(fold, doc.item.clone()),
fns: doc.fns.iter().transform(|FnDoc| {
fns: doc.fns.iter().map(|FnDoc| {
(fold.fold_fn)(fold, (*FnDoc).clone())
}).collect(),
.. doc
@ -254,7 +254,7 @@ pub fn default_par_fold_nmod<T:Clone>(
) -> doc::NmodDoc {
doc::NmodDoc {
item: (fold.fold_item)(fold, doc.item.clone()),
fns: doc.fns.iter().transform(|FnDoc| {
fns: doc.fns.iter().map(|FnDoc| {
(fold.fold_fn)(fold, (*FnDoc).clone())
}).collect(),
.. doc

2
src/librustdoc/page_pass.rs
View file

@ -123,7 +123,7 @@ fn strip_mod(doc: doc::ModDoc) -> doc::ModDoc {
doc::ModTag(_) | doc::NmodTag(_) => false,
_ => true
}
}.transform(|x| (*x).clone()).collect::<~[doc::ItemTag]>(),
}.map(|x| (*x).clone()).collect::<~[doc::ItemTag]>(),
.. doc.clone()
}
}

2
src/librustdoc/prune_hidden_pass.rs
View file

@ -43,7 +43,7 @@ fn fold_mod(
doc::ModDoc {
items: do doc.items.iter().filter |item_tag| {
!is_hidden(fold.ctxt.clone(), item_tag.item())
}.transform(|x| (*x).clone()).collect(),
}.map(|x| (*x).clone()).collect(),
.. doc
}
}

4
src/librustdoc/prune_private_pass.rs
View file

@ -91,7 +91,7 @@ fn strip_priv_methods(
ast::private => false,
ast::inherited => item_vis == ast::public
}
}.transform(|x| (*x).clone()).collect();
}.map(|x| (*x).clone()).collect();
doc::ImplDoc {
methods: methods,
@ -126,7 +126,7 @@ fn fold_mod(
is_visible(fold.ctxt.clone(), item_tag.item())
}
}
}).transform(|x| (*x).clone()).collect(),
}).map(|x| (*x).clone()).collect(),
.. doc
}
}

4
src/librustdoc/tystr_pass.rs
View file

@ -124,7 +124,7 @@ fn fold_enum(
let srv = fold.ctxt.clone();
doc::EnumDoc {
variants: do doc.variants.iter().transform |variant| {
variants: do doc.variants.iter().map |variant| {
let sig = {
let variant = (*variant).clone();
do astsrv::exec(srv.clone()) |ctxt| {
@ -169,7 +169,7 @@ fn merge_methods(
item_id: doc::AstId,
docs: ~[doc::MethodDoc]
) -> ~[doc::MethodDoc] {
do docs.iter().transform |doc| {
do docs.iter().map |doc| {
doc::MethodDoc {
sig: get_method_sig(srv.clone(), item_id, doc.name.clone()),
.. (*doc).clone()

2
src/librusti/rusti.rs
View file

@ -453,7 +453,7 @@ pub fn run_line(repl: &mut Repl, input: @io::Reader, out: @io::Writer, line: ~st
if line.starts_with(":") {
// drop the : and the \n (one byte each)
let full = line.slice(1, line.len());
let split: ~[~str] = full.word_iter().transform(|s| s.to_owned()).collect();
let split: ~[~str] = full.word_iter().map(|s| s.to_owned()).collect();
let len = split.len();
if len > 0 {

2
src/librustpkg/rustpkg.rs
View file

@ -158,7 +158,7 @@ impl<'self> PkgScript<'self> {
let output = run::process_output(exe.to_str(), [root.to_str(), ~"configs"]);
// Run the configs() function to get the configs
let cfgs = str::from_bytes_slice(output.output).word_iter()
.transform(|w| w.to_owned()).collect();
.map(|w| w.to_owned()).collect();
(cfgs, output.status)
}
}

4
src/libstd/hashmap.rs
View file

@ -977,7 +977,7 @@ mod test_map {
fn test_from_iter() {
let xs = ~[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
let map: HashMap<int, int> = xs.iter().transform(|&x| x).collect();
let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
for &(k, v) in xs.iter() {
assert_eq!(map.find(&k), Some(&v));
@ -1169,7 +1169,7 @@ mod test_set {
fn test_from_iter() {
let xs = ~[1, 2, 3, 4, 5, 6, 7, 8, 9];
let set: HashSet<int> = xs.iter().transform(|&x| x).collect();
let set: HashSet<int> = xs.iter().map(|&x| x).collect();
for x in xs.iter() {
assert!(set.contains(x));

61
src/libstd/iterator.rs
View file

@ -88,7 +88,6 @@ pub trait Iterator<A> {
Zip{a: self, b: other}
}
// FIXME: #5898: should be called map
/// Creates a new iterator which will apply the specified function to each
/// element returned by the first, yielding the mapped element instead.
///
@ -96,13 +95,13 @@ pub trait Iterator<A> {
///
/// ~~~ {.rust}
/// let a = [1, 2];
/// let mut it = a.iter().transform(|&x| 2 * x);
/// let mut it = a.iter().map(|&x| 2 * x);
/// assert_eq!(it.next().get(), 2);
/// assert_eq!(it.next().get(), 4);
/// assert!(it.next().is_none());
/// ~~~
#[inline]
fn transform<'r, B>(self, f: &'r fn(A) -> B) -> Map<'r, A, B, Self> {
fn map<'r, B>(self, f: &'r fn(A) -> B) -> Map<'r, A, B, Self> {
Map{iter: self, f: f}
}
@ -288,7 +287,7 @@ pub trait Iterator<A> {
/// ~~~ {.rust}
///let xs = [1u, 4, 2, 3, 8, 9, 6];
///let sum = xs.iter()
/// .transform(|&x| x)
/// .map(|&x| x)
/// .peek_(|&x| debug!("filtering %u", x))
/// .filter(|&x| x % 2 == 0)
/// .peek_(|&x| debug!("%u made it through", x))
@ -331,7 +330,7 @@ pub trait Iterator<A> {
///
/// ~~~ {.rust}
/// let a = [1, 2, 3, 4, 5];
/// let b: ~[int] = a.iter().transform(|&x| x).collect();
/// let b: ~[int] = a.iter().map(|&x| x).collect();
/// assert!(a == b);
/// ~~~
#[inline]
@ -346,7 +345,7 @@ pub trait Iterator<A> {
///
/// ~~~ {.rust}
/// let a = [1, 2, 3, 4, 5];
/// let b: ~[int] = a.iter().transform(|&x| x).to_owned_vec();
/// let b: ~[int] = a.iter().map(|&x| x).to_owned_vec();
/// assert!(a == b);
/// ~~~
#[inline]
@ -612,7 +611,7 @@ pub trait AdditiveIterator<A> {
///
/// ~~~ {.rust}
/// let a = [1, 2, 3, 4, 5];
/// let mut it = a.iter().transform(|&x| x);
/// let mut it = a.iter().map(|&x| x);
/// assert!(it.sum() == 15);
/// ~~~
fn sum(&mut self) -> A;
@ -1547,7 +1546,7 @@ mod tests {
assert_eq!(i, expected.len());
let ys = count(30u, 10).take_(4);
let mut it = xs.iter().transform(|&x| x).chain_(ys);
let mut it = xs.iter().map(|&x| x).chain_(ys);
let mut i = 0;
for x in it {
assert_eq!(x, expected[i]);
@ -1662,7 +1661,7 @@ mod tests {
let mut n = 0;
let ys = xs.iter()
.transform(|&x| x)
.map(|&x| x)
.peek_(|_| n += 1)
.collect::<~[uint]>();
@ -1731,33 +1730,33 @@ mod tests {
#[test]
fn test_iterator_sum() {
let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert_eq!(v.slice(0, 4).iter().transform(|&x| x).sum(), 6);
assert_eq!(v.iter().transform(|&x| x).sum(), 55);
assert_eq!(v.slice(0, 0).iter().transform(|&x| x).sum(), 0);
assert_eq!(v.slice(0, 4).iter().map(|&x| x).sum(), 6);
assert_eq!(v.iter().map(|&x| x).sum(), 55);
assert_eq!(v.slice(0, 0).iter().map(|&x| x).sum(), 0);
}
#[test]
fn test_iterator_product() {
let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert_eq!(v.slice(0, 4).iter().transform(|&x| x).product(), 0);
assert_eq!(v.slice(1, 5).iter().transform(|&x| x).product(), 24);
assert_eq!(v.slice(0, 0).iter().transform(|&x| x).product(), 1);
assert_eq!(v.slice(0, 4).iter().map(|&x| x).product(), 0);
assert_eq!(v.slice(1, 5).iter().map(|&x| x).product(), 24);
assert_eq!(v.slice(0, 0).iter().map(|&x| x).product(), 1);
}
#[test]
fn test_iterator_max() {
let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert_eq!(v.slice(0, 4).iter().transform(|&x| x).max(), Some(3));
assert_eq!(v.iter().transform(|&x| x).max(), Some(10));
assert_eq!(v.slice(0, 0).iter().transform(|&x| x).max(), None);
assert_eq!(v.slice(0, 4).iter().map(|&x| x).max(), Some(3));
assert_eq!(v.iter().map(|&x| x).max(), Some(10));
assert_eq!(v.slice(0, 0).iter().map(|&x| x).max(), None);
}
#[test]
fn test_iterator_min() {
let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert_eq!(v.slice(0, 4).iter().transform(|&x| x).min(), Some(0));
assert_eq!(v.iter().transform(|&x| x).min(), Some(0));
assert_eq!(v.slice(0, 0).iter().transform(|&x| x).min(), None);
assert_eq!(v.slice(0, 4).iter().map(|&x| x).min(), Some(0));
assert_eq!(v.iter().map(|&x| x).min(), Some(0));
assert_eq!(v.slice(0, 0).iter().map(|&x| x).min(), None);
}
#[test]
@ -1775,11 +1774,11 @@ mod tests {
assert_eq!(c.take_while(|_| false).size_hint(), (0, None));
assert_eq!(c.skip_while(|_| false).size_hint(), (0, None));
assert_eq!(c.enumerate().size_hint(), (uint::max_value, None));
assert_eq!(c.chain_(vi.transform(|&i| i)).size_hint(), (uint::max_value, None));
assert_eq!(c.chain_(vi.map(|&i| i)).size_hint(), (uint::max_value, None));
assert_eq!(c.zip(vi).size_hint(), (10, Some(10)));
assert_eq!(c.scan(0, |_,_| Some(0)).size_hint(), (0, None));
assert_eq!(c.filter(|_| false).size_hint(), (0, None));
assert_eq!(c.transform(|_| 0).size_hint(), (uint::max_value, None));
assert_eq!(c.map(|_| 0).size_hint(), (uint::max_value, None));
assert_eq!(c.filter_map(|_| Some(0)).size_hint(), (0, None));
assert_eq!(vi.take_(5).size_hint(), (5, Some(5)));
@ -1793,14 +1792,14 @@ mod tests {
assert_eq!(vi.zip(v2.iter()).size_hint(), (3, Some(3)));
assert_eq!(vi.scan(0, |_,_| Some(0)).size_hint(), (0, Some(10)));
assert_eq!(vi.filter(|_| false).size_hint(), (0, Some(10)));
assert_eq!(vi.transform(|i| i+1).size_hint(), (10, Some(10)));
assert_eq!(vi.map(|i| i+1).size_hint(), (10, Some(10)));
assert_eq!(vi.filter_map(|_| Some(0)).size_hint(), (0, Some(10)));
}
#[test]
fn test_collect() {
let a = ~[1, 2, 3, 4, 5];
let b: ~[int] = a.iter().transform(|&x| x).collect();
let b: ~[int] = a.iter().map(|&x| x).collect();
assert_eq!(a, b);
}
@ -1864,13 +1863,13 @@ mod tests {
let mut it = xs.iter();
it.next();
it.next();
assert_eq!(it.invert().transform(|&x| x).collect::<~[int]>(), ~[16, 14, 12, 10, 8, 6]);
assert_eq!(it.invert().map(|&x| x).collect::<~[int]>(), ~[16, 14, 12, 10, 8, 6]);
}
#[test]
fn test_double_ended_map() {
let xs = [1, 2, 3, 4, 5, 6];
let mut it = xs.iter().transform(|&x| x * -1);
let mut it = xs.iter().map(|&x| x * -1);
assert_eq!(it.next(), Some(-1));
assert_eq!(it.next(), Some(-2));
assert_eq!(it.next_back(), Some(-6));
@ -2020,7 +2019,7 @@ mod tests {
fn test_random_access_peek() {
let xs = [1, 2, 3, 4, 5];
// test .transform and .peek_ that don't implement Clone
// test .map and .peek_ that don't implement Clone
let it = xs.iter().peek_(|_| {});
assert_eq!(xs.len(), it.indexable());
for (i, elt) in xs.iter().enumerate() {
@ -2030,11 +2029,11 @@ mod tests {
}
#[test]
fn test_random_access_transform() {
fn test_random_access_map() {
let xs = [1, 2, 3, 4, 5];
// test .transform and .peek_ that don't implement Clone
let it = xs.iter().transform(|x| *x);
// test .map and .peek_ that don't implement Clone
let it = xs.iter().map(|x| *x);
assert_eq!(xs.len(), it.indexable());
for (i, elt) in xs.iter().enumerate() {
assert_eq!(Some(*elt), it.idx(i));

2
src/libstd/rt/kill.rs
View file

@ -239,7 +239,7 @@ impl BlockedTask {
};
// Even if the task was unkillable before, we use 'Killable' because
// multiple pipes will have handles. It does not really mean killable.
handles.move_iter().transform(|x| Killable(x)).collect()
handles.move_iter().map(|x| Killable(x)).collect()
}
// This assertion has two flavours because the wake involves an atomic op.

16
src/libstd/str.rs
View file

@ -185,7 +185,7 @@ impl<'self, S: Str> StrVector for &'self [S] {
pub fn concat(&self) -> ~str {
if self.is_empty() { return ~""; }
let len = self.iter().transform(|s| s.as_slice().len()).sum();
let len = self.iter().map(|s| s.as_slice().len()).sum();
let mut s = with_capacity(len);
@ -210,7 +210,7 @@ impl<'self, S: Str> StrVector for &'self [S] {
pub fn concat(&self) -> ~str {
if self.is_empty() { return ~""; }
let len = self.iter().transform(|s| s.as_slice().len()).sum();
let len = self.iter().map(|s| s.as_slice().len()).sum();
let mut s = with_capacity(len);
@ -239,7 +239,7 @@ impl<'self, S: Str> StrVector for &'self [S] {
// this is wrong without the guarantee that `self` is non-empty
let len = sep.len() * (self.len() - 1)
+ self.iter().transform(|s| s.as_slice().len()).sum();
+ self.iter().map(|s| s.as_slice().len()).sum();
let mut s = ~"";
let mut first = true;
@ -280,7 +280,7 @@ impl<'self, S: Str> StrVector for &'self [S] {
// this is wrong without the guarantee that `self` is non-empty
let len = sep.len() * (self.len() - 1)
+ self.iter().transform(|s| s.as_slice().len()).sum();
+ self.iter().map(|s| s.as_slice().len()).sum();
let mut s = ~"";
let mut first = true;
@ -1445,7 +1445,7 @@ impl<'self> StrSlice<'self> for &'self str {
/// ~~~
#[inline]
fn iter(&self) -> CharIterator<'self> {
self.char_offset_iter().transform(|(_, c)| c)
self.char_offset_iter().map(|(_, c)| c)
}
/// An iterator over the characters of `self`, in reverse order.
@ -1457,7 +1457,7 @@ impl<'self> StrSlice<'self> for &'self str {
/// An iterator over the bytes of `self`
#[inline]
fn byte_iter(&self) -> ByteIterator<'self> {
self.as_bytes().iter().transform(|&b| b)
self.as_bytes().iter().map(|&b| b)
}
/// An iterator over the bytes of `self`, in reverse order
@ -1565,7 +1565,7 @@ impl<'self> StrSlice<'self> for &'self str {
/// An iterator over the lines of a string, separated by either
/// `\n` or (`\r\n`).
fn any_line_iter(&self) -> AnyLineIterator<'self> {
do self.line_iter().transform |line| {
do self.line_iter().map |line| {
let l = line.len();
if l > 0 && line[l - 1] == '\r' as u8 { line.slice(0, l - 1) }
else { line }
@ -3686,7 +3686,7 @@ mod tests {
#[test]
fn test_str_container() {
fn sum_len<S: Container>(v: &[S]) -> uint {
v.iter().transform(|x| x.len()).sum()
v.iter().map(|x| x.len()).sum()
}
let s = ~"01234";

4
src/libstd/trie.rs
View file

@ -617,7 +617,7 @@ mod test_map {
fn test_from_iter() {
let xs = ~[(1u, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
let map: TrieMap<int> = xs.iter().transform(|&x| x).collect();
let map: TrieMap<int> = xs.iter().map(|&x| x).collect();
for &(k, v) in xs.iter() {
assert_eq!(map.find(&k), Some(&v));
@ -680,7 +680,7 @@ mod test_set {
fn test_from_iter() {
let xs = ~[9u, 8, 7, 6, 5, 4, 3, 2, 1];
let set: TrieSet = xs.iter().transform(|&x| x).collect();
let set: TrieSet = xs.iter().map(|&x| x).collect();
for x in xs.iter() {
assert!(set.contains(x));

4
src/libstd/tuple.rs
View file

@ -102,7 +102,7 @@ impl<'self,
fn map<C>(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C] {
match *self {
(ref a, ref b) => {
a.iter().zip(b.iter()).transform(|(aa, bb)| f(aa, bb)).collect()
a.iter().zip(b.iter()).map(|(aa, bb)| f(aa, bb)).collect()
}
}
}
@ -122,7 +122,7 @@ impl<A:Clone, B:Clone> ExtendedTupleOps<A,B> for (~[A], ~[B]) {
fn map<C>(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C] {
match *self {
(ref a, ref b) => {
a.iter().zip(b.iter()).transform(|(aa, bb)| f(aa, bb)).collect()
a.iter().zip(b.iter()).map(|(aa, bb)| f(aa, bb)).collect()
}
}
}

6
src/libstd/vec.rs
View file

@ -1068,10 +1068,10 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
}
/// Deprecated, use iterators where possible
/// (`self.iter().transform(f)`). Apply a function to each element
/// (`self.iter().map(f)`). Apply a function to each element
/// of a vector and return the results.
fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U] {
self.iter().transform(f).collect()
self.iter().map(f).collect()
}
/**
@ -2148,7 +2148,7 @@ pub mod bytes {
impl<A:Clone> Clone for ~[A] {
#[inline]
fn clone(&self) -> ~[A] {
self.iter().transform(|item| item.clone()).collect()
self.iter().map(|item| item.clone()).collect()
}
}

4
src/libsyntax/attr.rs
View file

@ -201,7 +201,7 @@ pub fn sort_meta_items(items: &[@MetaItem]) -> ~[@MetaItem] {
// This is sort of stupid here, but we need to sort by
// human-readable strings.
let mut v = items.iter()
.transform(|&mi| (mi.name(), mi))
.map(|&mi| (mi.name(), mi))
.collect::<~[(@str, @MetaItem)]>();
do extra::sort::quick_sort(v) |&(a, _), &(b, _)| {
@ -209,7 +209,7 @@ pub fn sort_meta_items(items: &[@MetaItem]) -> ~[@MetaItem] {
}
// There doesn't seem to be a more optimal way to do this
do v.move_iter().transform |(_, m)| {
do v.move_iter().map |(_, m)| {
match m.node {
MetaList(n, ref mis) => {
@spanned {

2
src/libsyntax/ext/build.rs
View file

@ -702,7 +702,7 @@ impl AstBuilder for @ExtCtxt {
}
fn variant(&self, span: span, name: ident, tys: ~[ast::Ty]) -> ast::variant {
let args = tys.move_iter().transform(|ty| {
let args = tys.move_iter().map(|ty| {
ast::variant_arg { ty: ty, id: self.next_id() }
}).collect();

2
src/libsyntax/ext/cfg.rs
View file

@ -39,7 +39,7 @@ pub fn expand_cfg(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> base::MacR
// test_cfg searches for meta items looking like `cfg(foo, ...)`
let in_cfg = &[cx.meta_list(sp, @"cfg", cfgs)];
let matches_cfg = attr::test_cfg(cx.cfg(), in_cfg.iter().transform(|&x| x));
let matches_cfg = attr::test_cfg(cx.cfg(), in_cfg.iter().map(|&x| x));
let e = cx.expr_bool(sp, matches_cfg);
MRExpr(e)
}

4
src/libsyntax/ext/deriving/decodable.rs
View file

@ -90,7 +90,7 @@ fn decodable_substructure(cx: @ExtCtxt, span: span,
}
}
Right(ref fields) => {
let fields = do fields.iter().enumerate().transform |(i, f)| {
let fields = do fields.iter().enumerate().map |(i, f)| {
cx.field_imm(span, *f, getarg(cx.str_of(*f), i))
}.collect();
cx.expr_struct_ident(span, substr.type_ident, fields)
@ -132,7 +132,7 @@ fn decodable_substructure(cx: @ExtCtxt, span: span,
}
}
Right(ref fields) => {
let fields = do fields.iter().enumerate().transform |(i, f)| {
let fields = do fields.iter().enumerate().map |(i, f)| {
cx.field_imm(span, *f, getarg(i))
}.collect();
cx.expr_struct_ident(span, name, fields)

4
src/libsyntax/ext/deriving/generic.rs
View file

@ -590,7 +590,7 @@ impl<'self> MethodDef<'self> {
// transpose raw_fields
let fields = match raw_fields {
[ref self_arg, .. rest] => {
do self_arg.iter().enumerate().transform |(i, &(opt_id, field))| {
do self_arg.iter().enumerate().map |(i, &(opt_id, field))| {
let other_fields = do rest.map |l| {
match &l[i] {
&(_, ex) => ex
@ -750,7 +750,7 @@ impl<'self> MethodDef<'self> {
let field_tuples =
do self_vec.iter()
.zip(enum_matching_fields.iter())
.transform |(&(id, self_f), other)| {
.map |(&(id, self_f), other)| {
(id, self_f, (*other).clone())
}.collect();
substructure = EnumMatching(variant_index, variant, field_tuples);

2
src/libsyntax/ext/deriving/rand.rs
View file

@ -95,7 +95,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.iter().enumerate().transform |(i, id_sum)| {
let mut arms = do variants.iter().enumerate().map |(i, id_sum)| {
let i_expr = cx.expr_uint(span, i);
let pat = cx.pat_lit(span, i_expr);

14
src/libsyntax/ext/ifmt.rs
View file

@ -353,9 +353,9 @@ impl Context {
let trans_method = |method: &parse::Method| {
let method = match *method {
parse::Select(ref arms, ref default) => {
let arms = arms.iter().transform(|arm| {
let arms = arms.iter().map(|arm| {
let p = self.ecx.path_global(sp, rtpath("SelectArm"));
let result = arm.result.iter().transform(|p| {
let result = arm.result.iter().map(|p| {
self.trans_piece(p)
}).collect();
let s = arm.selector.to_managed();
@ -368,7 +368,7 @@ impl Context {
self.ecx.expr_vec_slice(sp, result)),
])
}).collect();
let default = default.iter().transform(|p| {
let default = default.iter().map(|p| {
self.trans_piece(p)
}).collect();
self.ecx.expr_call_global(sp, rtpath("Select"), ~[
@ -381,9 +381,9 @@ impl Context {
Some(i) => { some(self.ecx.expr_uint(sp, i)) }
None => { none() }
};
let arms = arms.iter().transform(|arm| {
let arms = arms.iter().map(|arm| {
let p = self.ecx.path_global(sp, rtpath("PluralArm"));
let result = arm.result.iter().transform(|p| {
let result = arm.result.iter().map(|p| {
self.trans_piece(p)
}).collect();
let (lr, selarg) = match arm.selector {
@ -408,7 +408,7 @@ impl Context {
self.ecx.expr_vec_slice(sp, result)),
])
}).collect();
let default = default.iter().transform(|p| {
let default = default.iter().map(|p| {
self.trans_piece(p)
}).collect();
self.ecx.expr_call_global(sp, rtpath("Plural"), ~[
@ -575,7 +575,7 @@ impl Context {
Some(self.format_arg(e.span, Right(name), lname));
}
let args = names.move_iter().transform(|a| a.unwrap());
let args = names.move_iter().map(|a| a.unwrap());
let mut args = locals.move_iter().chain_(args);
// Next, build up the actual call to the sprintf function.

2
src/libsyntax/ext/source_util.rs
View file

@ -105,7 +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: ~[@ast::expr] = src.iter().transform(|char| cx.expr_u8(sp, *char)).collect();
let u8_exprs: ~[@ast::expr] = src.iter().map(|char| cx.expr_u8(sp, *char)).collect();
base::MRExpr(cx.expr_vec(sp, u8_exprs))
}
result::Err(ref e) => {

10
src/libsyntax/fold.rs
View file

@ -704,7 +704,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: m.view_items.iter().transform(|x| fld.fold_view_item(x)).collect(),
view_items: m.view_items.iter().map(|x| fld.fold_view_item(x)).collect(),
items: m.items.iter().filter_map(|x| fld.fold_item(*x)).collect(),
}
}
@ -713,8 +713,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: nm.view_items.iter().transform(|x| fld.fold_view_item(x)).collect(),
items: nm.items.iter().transform(|x| fld.fold_foreign_item(*x)).collect(),
view_items: nm.view_items.iter().map(|x| fld.fold_view_item(x)).collect(),
items: nm.items.iter().map(|x| fld.fold_foreign_item(*x)).collect(),
}
}
@ -734,7 +734,7 @@ fn noop_fold_variant(v: &variant_, fld: @ast_fold) -> variant_ {
struct_variant_kind(ref struct_def) => {
kind = struct_variant_kind(@ast::struct_def {
fields: struct_def.fields.iter()
.transform(|f| fld.fold_struct_field(*f)).collect(),
.map(|f| fld.fold_struct_field(*f)).collect(),
ctor_id: struct_def.ctor_id.map(|c| fld.new_id(*c))
})
}
@ -828,7 +828,7 @@ impl ast_fold for AstFoldFns {
fn fold_view_item(@self, x: &view_item) -> view_item {
ast::view_item {
node: (self.fold_view_item)(&x.node, self as @ast_fold),
attrs: x.attrs.iter().transform(|a| fold_attribute_(*a, self as @ast_fold)).collect(),
attrs: x.attrs.iter().map(|a| fold_attribute_(*a, self as @ast_fold)).collect(),
vis: x.vis,
span: (self.new_span)(x.span),
}

4
src/libsyntax/opt_vec.rs
View file

@ -60,7 +60,7 @@ impl<T> OptVec<T> {
fn map_move<U>(self, op: &fn(T) -> U) -> OptVec<U> {
match self {
Empty => Empty,
Vec(v) => Vec(v.move_iter().transform(op).collect())
Vec(v) => Vec(v.move_iter().map(op).collect())
}
}
@ -92,7 +92,7 @@ impl<T> OptVec<T> {
#[inline]
fn map_to_vec<B>(&self, op: &fn(&T) -> B) -> ~[B] {
self.iter().transform(op).collect()
self.iter().map(op).collect()
}
fn mapi_to_vec<B>(&self, op: &fn(uint, &T) -> B) -> ~[B] {

2
src/libsyntax/parse/comments.rs
View file

@ -115,7 +115,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
if comment.starts_with("/*") {
let lines = comment.slice(3u, comment.len() - 2u)
.any_line_iter()
.transform(|s| s.to_owned())
.map(|s| s.to_owned())
.collect::<~[~str]>();
let lines = vertical_trim(lines);

6
src/test/bench/graph500-bfs.rs
View file

@ -96,7 +96,7 @@ fn make_graph(N: uint, edges: ~[(node_id, node_id)]) -> graph {
}
}
do graph.move_iter().transform |v| {
do graph.move_iter().map |v| {
let mut vec = ~[];
for i in v.move_iter() {
vec.push(i);
@ -193,7 +193,7 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result {
// Do the BFS.
info!("PBFS iteration %?", i);
i += 1;
colors = do colors.iter().enumerate().transform |(i, c)| {
colors = do colors.iter().enumerate().map |(i, c)| {
let c : color = *c;
match c {
white => {
@ -220,7 +220,7 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result {
}
// Convert the results.
do colors.iter().transform |c| {
do colors.iter().map |c| {
match *c {
white => { -1i64 }
black(parent) => { parent }

2
src/test/bench/shootout-chameneos-redux.rs
View file

@ -150,7 +150,7 @@ fn rendezvous(nn: uint, set: ~[color]) {
// these channels will allow us to talk to each creature by 'name'/index
let to_creature: ~[Chan<Option<CreatureInfo>>] =
set.iter().enumerate().transform(|(ii, col)| {
set.iter().enumerate().map(|(ii, col)| {
// create each creature as a listener with a port, and
// give us a channel to talk to each
let ii = ii;

2
src/test/bench/shootout-k-nucleotide-pipes.rs
View file

@ -172,7 +172,7 @@ fn main() {
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 = do sizes.iter().zip(streams.mut_iter()).transform |(sz, stream_ref)| {
let to_child = do sizes.iter().zip(streams.mut_iter()).map |(sz, stream_ref)| {
let sz = *sz;
let stream = util::replace(stream_ref, None);
let (from_child_, to_parent_) = stream.unwrap();

4
src/test/bench/task-perf-one-million.rs
View file

@ -28,14 +28,14 @@ fn calc(children: uint, parent_wait_chan: &Chan<Chan<Chan<int>>>) {
};
let child_start_chans: ~[Chan<Chan<int>>] =
wait_ports.move_iter().transform(|port| port.recv()).collect();
wait_ports.move_iter().map(|port| port.recv()).collect();
let (start_port, start_chan) = stream::<Chan<int>>();
parent_wait_chan.send(start_chan);
let parent_result_chan: Chan<int> = start_port.recv();
let child_sum_ports: ~[Port<int>] =
do child_start_chans.move_iter().transform |child_start_chan| {
do child_start_chans.move_iter().map |child_start_chan| {
let (child_sum_port, child_sum_chan) = stream::<int>();
child_start_chan.send(child_sum_chan);
child_sum_port

2
src/test/run-pass/block-arg.rs
View file

@ -28,7 +28,7 @@ pub fn main() {
assert!(any_negative);
// Higher precedence than unary operations:
let abs_v = do v.iter().transform |e| { e.abs() }.collect::<~[float]>();
let abs_v = do v.iter().map |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() });

2
src/test/run-pass/trait-to-str.rs
View file

@ -29,7 +29,7 @@ impl to_str for int {
impl<T:to_str> to_str for ~[T] {
fn to_str(&self) -> ~str {
fmt!("[%s]", self.iter().transform(|e| e.to_str()).collect::<~[~str]>().connect(", "))
fmt!("[%s]", self.iter().map(|e| e.to_str()).collect::<~[~str]>().connect(", "))
}
}