diff --git a/src/libextra/getopts.rs b/src/libextra/getopts.rs
index 1a494f36c6469..c481fb8f5440d 100644
--- a/src/libextra/getopts.rs
+++ b/src/libextra/getopts.rs
@@ -176,7 +176,7 @@ fn name_str(nm: &Name) -> ~str {
 }
 
 fn find_opt(opts: &[Opt], nm: Name) -> Option<uint> {
-    opts.iter().position_(|opt| opt.name == nm)
+    opts.iter().position(|opt| opt.name == nm)
 }
 
 /**
diff --git a/src/libextra/json.rs b/src/libextra/json.rs
index 71d99479693fa..b9b2099d7c228 100644
--- a/src/libextra/json.rs
+++ b/src/libextra/json.rs
@@ -950,7 +950,7 @@ impl serialize::Decoder for Decoder {
             }
             ref json => fail!("invalid variant: %?", *json),
         };
-        let idx = match names.iter().position_(|n| str::eq_slice(*n, name)) {
+        let idx = match names.iter().position(|n| str::eq_slice(*n, name)) {
             Some(idx) => idx,
             None => fail!("Unknown variant name: %?", name),
         };
diff --git a/src/libextra/net/ip.rs b/src/libextra/net/ip.rs
index bf58f81ef0e3e..6876b3510b6ca 100644
--- a/src/libextra/net/ip.rs
+++ b/src/libextra/net/ip.rs
@@ -203,7 +203,7 @@ pub mod v4 {
         }).collect();
         if parts.len() != 4 {
             Err(fmt!("'%s' doesn't have 4 parts", ip))
-        } else if parts.iter().any_(|x| *x == 256u) {
+        } else if parts.iter().any(|x| *x == 256u) {
             Err(fmt!("invalid octal in addr '%s'", ip))
         } else {
             Ok(Ipv4Rep {
diff --git a/src/libextra/net/url.rs b/src/libextra/net/url.rs
index 4ed8761cc11b8..307f75dc98bea 100644
--- a/src/libextra/net/url.rs
+++ b/src/libextra/net/url.rs
@@ -522,7 +522,7 @@ fn get_authority(rawurl: &str) ->
     let host_is_end_plus_one: &fn() -> bool = || {
         let xs = ['?', '#', '/'];
         end+1 == len
-            && !xs.iter().any_(|x| *x == (rawurl[end] as char))
+            && !xs.iter().any(|x| *x == (rawurl[end] as char))
     };
 
     // finish up
diff --git a/src/libextra/par.rs b/src/libextra/par.rs
index d56f7b32ae7d8..d737698cfe2ca 100644
--- a/src/libextra/par.rs
+++ b/src/libextra/par.rs
@@ -136,8 +136,8 @@ pub fn any<A:Copy + Send>(
     fn_factory: &fn() -> ~fn(&A) -> bool) -> bool {
     let mapped = map_slices(xs, || {
         let f = fn_factory();
-        let result: ~fn(uint, &[A]) -> bool = |_, slice| slice.iter().any_(f);
+        let result: ~fn(uint, &[A]) -> bool = |_, slice| slice.iter().any(f);
         result
     });
-    mapped.iter().any_(|&x| x)
+    mapped.iter().any(|&x| x)
 }
diff --git a/src/libextra/terminfo/parser/compiled.rs b/src/libextra/terminfo/parser/compiled.rs
index e16297e387178..e56b3b6bcf4c8 100644
--- a/src/libextra/terminfo/parser/compiled.rs
+++ b/src/libextra/terminfo/parser/compiled.rs
@@ -294,7 +294,7 @@ pub fn parse(file: @Reader, longnames: bool) -> Result<~TermInfo, ~str> {
 
             // Find the offset of the NUL we want to go to
             let nulpos = string_table.slice(offset as uint, string_table_bytes as uint)
-                .iter().position_(|&b| b == 0);
+                .iter().position(|&b| b == 0);
             match nulpos {
                 Some(len) => {
                     string_map.insert(name.to_owned(),
diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs
index 17970f158dd23..a5f7479d41a01 100644
--- a/src/libextra/treemap.rs
+++ b/src/libextra/treemap.rs
@@ -844,7 +844,7 @@ mod test_treemap {
             for 90.times {
                 let k = rng.gen();
                 let v = rng.gen();
-                if !ctrl.iter().any_(|x| x == &(k, v)) {
+                if !ctrl.iter().any(|x| x == &(k, v)) {
                     assert!(map.insert(k, v));
                     ctrl.push((k, v));
                     check_structure(&map);
diff --git a/src/librustc/front/config.rs b/src/librustc/front/config.rs
index df829d5e20961..0d4d96b3b2b3e 100644
--- a/src/librustc/front/config.rs
+++ b/src/librustc/front/config.rs
@@ -194,7 +194,7 @@ pub fn metas_in_cfg(cfg: &[@ast::meta_item],
 
     if cfg_metas.iter().all(|c| c.is_empty()) { return true; }
 
-    cfg_metas.iter().any_(|cfg_meta| {
+    cfg_metas.iter().any(|cfg_meta| {
         cfg_meta.iter().all(|cfg_mi| {
             match cfg_mi.node {
                 ast::meta_list(s, ref it) if "not" == s
diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs
index 3413cd341ba42..bb1834dc5c8fc 100644
--- a/src/librustc/metadata/cstore.rs
+++ b/src/librustc/metadata/cstore.rs
@@ -102,7 +102,7 @@ pub fn get_used_crate_files(cstore: &CStore) -> ~[Path] {
 pub fn add_used_library(cstore: &mut CStore, lib: @str) -> bool {
     assert!(!lib.is_empty());
 
-    if cstore.used_libraries.iter().any_(|x| x == &lib) { return false; }
+    if cstore.used_libraries.iter().any(|x| x == &lib) { return false; }
     cstore.used_libraries.push(lib);
     true
 }
diff --git a/src/librustc/middle/borrowck/move_data.rs b/src/librustc/middle/borrowck/move_data.rs
index 97fd6ca5cc439..73adade7a5d71 100644
--- a/src/librustc/middle/borrowck/move_data.rs
+++ b/src/librustc/middle/borrowck/move_data.rs
@@ -506,7 +506,7 @@ impl FlowedMoveData {
         for self.dfcx_moves.each_bit_on_entry_frozen(id) |index| {
             let move = &self.move_data.moves[index];
             let moved_path = move.path;
-            if base_indices.iter().any_(|x| x == &moved_path) {
+            if base_indices.iter().any(|x| x == &moved_path) {
                 // Scenario 1 or 2: `loan_path` or some base path of
                 // `loan_path` was moved.
                 if !f(move, self.move_data.path(moved_path).loan_path) {
@@ -535,7 +535,7 @@ impl FlowedMoveData {
                        -> bool {
         //! True if `id` is the id of the LHS of an assignment
 
-        self.move_data.assignee_ids.iter().any_(|x| x == &id)
+        self.move_data.assignee_ids.iter().any(|x| x == &id)
     }
 
     pub fn each_assignment_of(&self,
diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs
index 7113244c7f6cf..26a03b362e356 100644
--- a/src/librustc/middle/check_const.rs
+++ b/src/librustc/middle/check_const.rs
@@ -224,7 +224,7 @@ pub fn check_item_recursion(sess: Session,
     (visitor.visit_item)(it, (env, visitor));
 
     fn visit_item(it: @item, (env, v): (env, visit::vt<env>)) {
-        if env.idstack.iter().any_(|x| x == &(it.id)) {
+        if env.idstack.iter().any(|x| x == &(it.id)) {
             env.sess.span_fatal(env.root_it.span, "recursive constant");
         }
         env.idstack.push(it.id);
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index 740499bbf25e6..0baeb8ce57c6c 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -371,7 +371,7 @@ pub fn missing_ctor(cx: &MatchCheckCtxt,
         let variants = ty::enum_variants(cx.tcx, eid);
         if found.len() != (*variants).len() {
             for (*variants).iter().advance |v| {
-                if !found.iter().any_(|x| x == &(variant(v.id))) {
+                if !found.iter().any(|x| x == &(variant(v.id))) {
                     return Some(variant(v.id));
                 }
             }
@@ -805,13 +805,13 @@ pub fn is_refutable(cx: &MatchCheckCtxt, pat: &pat) -> bool {
       }
       pat_lit(_) | pat_range(_, _) => { true }
       pat_struct(_, ref fields, _) => {
-        fields.iter().any_(|f| is_refutable(cx, f.pat))
+        fields.iter().any(|f| is_refutable(cx, f.pat))
       }
       pat_tup(ref elts) => {
-        elts.iter().any_(|elt| is_refutable(cx, *elt))
+        elts.iter().any(|elt| is_refutable(cx, *elt))
       }
       pat_enum(_, Some(ref args)) => {
-        args.iter().any_(|a| is_refutable(cx, *a))
+        args.iter().any(|a| is_refutable(cx, *a))
       }
       pat_enum(_,_) => { false }
       pat_vec(*) => { true }
diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs
index ac18a9b76cf9a..e054b84984d15 100644
--- a/src/librustc/middle/dataflow.rs
+++ b/src/librustc/middle/dataflow.rs
@@ -341,14 +341,14 @@ impl<O:DataFlowOperator+Copy+'static> DataFlowContext<O> {
                 let entry_str = bits_to_str(on_entry);
 
                 let gens = self.gens.slice(start, end);
-                let gens_str = if gens.iter().any_(|&u| u != 0) {
+                let gens_str = if gens.iter().any(|&u| u != 0) {
                     fmt!(" gen: %s", bits_to_str(gens))
                 } else {
                     ~""
                 };
 
                 let kills = self.kills.slice(start, end);
-                let kills_str = if kills.iter().any_(|&u| u != 0) {
+                let kills_str = if kills.iter().any(|&u| u != 0) {
                     fmt!(" kill: %s", bits_to_str(kills))
                 } else {
                     ~""
@@ -643,7 +643,7 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
                 self.walk_opt_expr(o_e, in_out, loop_scopes);
 
                 // is this a return from a `for`-loop closure?
-                match loop_scopes.iter().position_(|s| s.loop_kind == ForLoop) {
+                match loop_scopes.iter().position(|s| s.loop_kind == ForLoop) {
                     Some(i) => {
                         // if so, add the in_out bits to the state
                         // upon exit. Remember that we cannot count
@@ -916,7 +916,7 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
             Some(_) => {
                 match self.tcx().def_map.find(&expr.id) {
                     Some(&ast::def_label(loop_id)) => {
-                        match loop_scopes.iter().position_(|l| l.loop_id == loop_id) {
+                        match loop_scopes.iter().position(|l| l.loop_id == loop_id) {
                             Some(i) => i,
                             None => {
                                 self.tcx().sess.span_bug(
diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs
index 335a54a975353..a9454d1b23096 100644
--- a/src/librustc/middle/kind.rs
+++ b/src/librustc/middle/kind.rs
@@ -536,7 +536,7 @@ pub fn check_cast_for_escaping_regions(
     // Check, based on the region associated with the trait, whether it can
     // possibly escape the enclosing fn item (note that all type parameters
     // must have been declared on the enclosing fn item).
-    if target_regions.iter().any_(|r| is_re_scope(*r)) {
+    if target_regions.iter().any(|r| is_re_scope(*r)) {
         return; /* case (1) */
     }
 
@@ -551,7 +551,7 @@ pub fn check_cast_for_escaping_regions(
         |_r| {
             // FIXME(#5723) --- turn this check on once &Objects are usable
             //
-            // if !target_regions.iter().any_(|t_r| is_subregion_of(cx, *t_r, r)) {
+            // if !target_regions.iter().any(|t_r| is_subregion_of(cx, *t_r, r)) {
             //     cx.tcx.sess.span_err(
             //         source.span,
             //         fmt!("source contains borrowed pointer with lifetime \
@@ -565,7 +565,7 @@ pub fn check_cast_for_escaping_regions(
         |ty| {
             match ty::get(ty).sty {
                 ty::ty_param(source_param) => {
-                    if target_params.iter().any_(|x| x == &source_param) {
+                    if target_params.iter().any(|x| x == &source_param) {
                         /* case (2) */
                     } else {
                         check_durable(cx.tcx, ty, source.span); /* case (3) */
diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs
index 0dce9c69bfdbe..0fc19ffd78e52 100644
--- a/src/librustc/middle/lint.rs
+++ b/src/librustc/middle/lint.rs
@@ -898,7 +898,7 @@ fn check_item_non_uppercase_statics(cx: &Context, it: &ast::item) {
             // check for lowercase letters rather than non-uppercase
             // ones (some scripts don't have a concept of
             // upper/lowercase)
-            if s.iter().any_(|c| c.is_lowercase()) {
+            if s.iter().any(|c| c.is_lowercase()) {
                 cx.span_lint(non_uppercase_statics, it.span,
                              "static constant should have an uppercase identifier");
             }
@@ -1038,7 +1038,7 @@ fn lint_missing_doc() -> visit::vt<@mut Context> {
         // If we have doc(hidden), nothing to do
         if cx.doc_hidden { return }
         // If we're documented, nothing to do
-        if attrs.iter().any_(|a| a.node.is_sugared_doc) { return }
+        if attrs.iter().any(|a| a.node.is_sugared_doc) { return }
 
         // otherwise, warn!
         cx.span_lint(missing_doc, sp, msg);
diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs
index c7d338b1976ad..f3d4abcdf310f 100644
--- a/src/librustc/middle/moves.rs
+++ b/src/librustc/middle/moves.rs
@@ -390,8 +390,8 @@ impl VisitContext {
                     // any fields which (1) were not explicitly
                     // specified and (2) have a type that
                     // moves-by-default:
-                    let consume_with = with_fields.iter().any_(|tf| {
-                        !fields.iter().any_(|f| f.node.ident == tf.ident) &&
+                    let consume_with = with_fields.iter().any(|tf| {
+                        !fields.iter().any(|f| f.node.ident == tf.ident) &&
                             ty::type_moves_by_default(self.tcx, tf.mt.ty)
                     });
 
diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs
index dd6b5615c3f3f..8a2b134191534 100644
--- a/src/librustc/middle/privacy.rs
+++ b/src/librustc/middle/privacy.rs
@@ -259,7 +259,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                                                          method_id.node);
             if is_private &&
                     (container_id.crate != local_crate ||
-                     !privileged_items.iter().any_(|x| x == &(container_id.node))) {
+                     !privileged_items.iter().any(|x| x == &(container_id.node))) {
                 tcx.sess.span_err(span,
                                   fmt!("method `%s` is private",
                                        token::ident_to_str(name)));
@@ -287,7 +287,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
             def_fn(def_id, _) => {
                 if def_id.crate == local_crate {
                     if local_item_is_private(span, def_id.node) &&
-                            !privileged_items.iter().any_(|x| x == &def_id.node) {
+                            !privileged_items.iter().any(|x| x == &def_id.node) {
                         tcx.sess.span_err(span,
                                           fmt!("function `%s` is private",
                                                token::ident_to_str(path.idents.last())));
@@ -332,7 +332,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                                         provided(method)
                                              if method.vis == private &&
                                              !privileged_items.iter()
-                                             .any_(|x| x == &(trait_id.node)) => {
+                                             .any(|x| x == &(trait_id.node)) => {
                                             tcx.sess.span_err(span,
                                                               fmt!("method `%s` is private",
                                                                    token::ident_to_str(&method
@@ -417,7 +417,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                                                           base))).sty {
                         ty_struct(id, _)
                         if id.crate != local_crate || !privileged_items.iter()
-                                .any_(|x| x == &(id.node)) => {
+                                .any(|x| x == &(id.node)) => {
                             debug!("(privacy checking) checking field access");
                             check_field(expr.span, id, ident);
                         }
@@ -430,7 +430,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                                                           base))).sty {
                         ty_struct(id, _)
                         if id.crate != local_crate ||
-                           !privileged_items.iter().any_(|x| x == &(id.node)) => {
+                           !privileged_items.iter().any(|x| x == &(id.node)) => {
                             match method_map.find(&expr.id) {
                                 None => {
                                     tcx.sess.span_bug(expr.span,
@@ -456,7 +456,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                     match ty::get(ty::expr_ty(tcx, expr)).sty {
                         ty_struct(id, _) => {
                             if id.crate != local_crate ||
-                                    !privileged_items.iter().any_(|x| x == &(id.node)) {
+                                    !privileged_items.iter().any(|x| x == &(id.node)) {
                                 for (*fields).iter().advance |field| {
                                         debug!("(privacy checking) checking \
                                                 field in struct literal");
@@ -467,7 +467,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                         }
                         ty_enum(id, _) => {
                             if id.crate != local_crate ||
-                                    !privileged_items.iter().any_(|x| x == &(id.node)) {
+                                    !privileged_items.iter().any(|x| x == &(id.node)) {
                                 match tcx.def_map.get_copy(&expr.id) {
                                     def_variant(_, variant_id) => {
                                         for (*fields).iter().advance |field| {
@@ -504,7 +504,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                     match ty::get(ty::expr_ty(tcx, operand)).sty {
                         ty_enum(id, _) => {
                             if id.crate != local_crate ||
-                                !privileged_items.iter().any_(|x| x == &(id.node)) {
+                                !privileged_items.iter().any(|x| x == &(id.node)) {
                                 check_variant(expr.span, id);
                             }
                         }
@@ -522,7 +522,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                     match ty::get(ty::pat_ty(tcx, pattern)).sty {
                         ty_struct(id, _) => {
                             if id.crate != local_crate ||
-                                    !privileged_items.iter().any_(|x| x == &(id.node)) {
+                                    !privileged_items.iter().any(|x| x == &(id.node)) {
                                 for fields.iter().advance |field| {
                                         debug!("(privacy checking) checking \
                                                 struct pattern");
@@ -533,7 +533,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                         }
                         ty_enum(enum_id, _) => {
                             if enum_id.crate != local_crate ||
-                                    !privileged_items.iter().any_(|x| x == &enum_id.node) {
+                                    !privileged_items.iter().any(|x| x == &enum_id.node) {
                                 match tcx.def_map.find(&pattern.id) {
                                     Some(&def_variant(_, variant_id)) => {
                                         for fields.iter().advance |field| {
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
index b1b2a0083acc3..e1c43121ec82b 100644
--- a/src/librustc/middle/region.rs
+++ b/src/librustc/middle/region.rs
@@ -78,7 +78,7 @@ impl RegionMaps {
     pub fn relate_free_regions(&mut self, sub: FreeRegion, sup: FreeRegion) {
         match self.free_region_map.find_mut(&sub) {
             Some(sups) => {
-                if !sups.iter().any_(|x| x == &sup) {
+                if !sups.iter().any(|x| x == &sup) {
                     sups.push(sup);
                 }
                 return;
@@ -202,7 +202,7 @@ impl RegionMaps {
                             return true;
                         }
 
-                        if !queue.iter().any_(|x| x == parent) {
+                        if !queue.iter().any(|x| x == parent) {
                             queue.push(*parent);
                         }
                     }
@@ -612,7 +612,7 @@ impl DetermineRpCtxt {
             ambient_variance: self.ambient_variance,
             id: self.item_id
         };
-        if !vec.iter().any_(|x| x == &dep) { vec.push(dep); }
+        if !vec.iter().any(|x| x == &dep) { vec.push(dep); }
     }
 
     // Determines whether a reference to a region that appears in the
diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
index 3e828a891d49e..511e4fdd864cf 100644
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@@ -796,7 +796,7 @@ pub fn enter_region<'r>(bcx: block,
 pub fn get_options(bcx: block, m: &[@Match], col: uint) -> ~[Opt] {
     let ccx = bcx.ccx();
     fn add_to_set(tcx: ty::ctxt, set: &mut ~[Opt], val: Opt) {
-        if set.iter().any_(|l| opt_eq(tcx, l, &val)) {return;}
+        if set.iter().any(|l| opt_eq(tcx, l, &val)) {return;}
         set.push(val);
     }
 
@@ -963,7 +963,7 @@ pub fn collect_record_or_struct_fields(bcx: block,
     fn extend(idents: &mut ~[ast::ident], field_pats: &[ast::field_pat]) {
         for field_pats.iter().advance |field_pat| {
             let field_ident = field_pat.ident;
-            if !idents.iter().any_(|x| *x == field_ident) {
+            if !idents.iter().any(|x| *x == field_ident) {
                 idents.push(field_ident);
             }
         }
@@ -974,7 +974,7 @@ pub fn pats_require_rooting(bcx: block,
                             m: &[@Match],
                             col: uint)
                          -> bool {
-    do m.iter().any_ |br| {
+    do m.iter().any |br| {
         let pat_id = br.pats[col].id;
         let key = root_map_key {id: pat_id, derefs: 0u };
         bcx.ccx().maps.root_map.contains_key(&key)
@@ -1003,7 +1003,7 @@ pub fn root_pats_as_necessary(mut bcx: block,
 // matches may be wildcards like _ or identifiers).
 macro_rules! any_pat (
     ($m:expr, $pattern:pat) => (
-        do ($m).iter().any_ |br| {
+        do ($m).iter().any |br| {
             match br.pats[col].node {
                 $pattern => true,
                 _ => false
@@ -1029,7 +1029,7 @@ pub fn any_tup_pat(m: &[@Match], col: uint) -> bool {
 }
 
 pub fn any_tuple_struct_pat(bcx: block, m: &[@Match], col: uint) -> bool {
-    do m.iter().any_ |br| {
+    do m.iter().any |br| {
         let pat = br.pats[col];
         match pat.node {
             ast::pat_enum(_, Some(_)) => {
diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs
index 4755f7629511e..dc8f6b1d05b51 100644
--- a/src/librustc/middle/trans/adt.rs
+++ b/src/librustc/middle/trans/adt.rs
@@ -147,7 +147,7 @@ fn represent_type_uncached(cx: &mut CrateContext, t: ty::t) -> Repr {
                     mk_struct(cx, self.tys, false).size == 0
                 }
                 fn find_ptr(&self) -> Option<uint> {
-                    self.tys.iter().position_(|&ty| mono_data_classify(ty) == MonoNonNull)
+                    self.tys.iter().position(|&ty| mono_data_classify(ty) == MonoNonNull)
                 }
             }
 
diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs
index 19c94d95c4f99..fa994ccaa6514 100644
--- a/src/librustc/middle/trans/common.rs
+++ b/src/librustc/middle/trans/common.rs
@@ -413,7 +413,7 @@ pub fn add_clean_free(cx: block, ptr: ValueRef, heap: heap) {
 // drop glue checks whether it is zero.
 pub fn revoke_clean(cx: block, val: ValueRef) {
     do in_scope_cx(cx, None) |scope_info| {
-        let cleanup_pos = scope_info.cleanups.iter().position_(
+        let cleanup_pos = scope_info.cleanups.iter().position(
             |cu| match *cu {
                 clean_temp(v, _, _) if v == val => true,
                 _ => false
diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs
index bbec78880fe23..9044ef5700321 100644
--- a/src/librustc/middle/trans/consts.rs
+++ b/src/librustc/middle/trans/consts.rs
@@ -91,7 +91,7 @@ pub fn const_vec(cx: @mut CrateContext, e: &ast::expr, es: &[@ast::expr])
         let sz = llvm::LLVMConstMul(C_uint(cx, es.len()), unit_sz);
         let vs = es.map(|e| const_expr(cx, *e));
         // If the vector contains enums, an LLVM array won't work.
-        let v = if vs.iter().any_(|vi| val_ty(*vi) != llunitty) {
+        let v = if vs.iter().any(|vi| val_ty(*vi) != llunitty) {
             C_struct(vs)
         } else {
             C_array(llunitty, vs)
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
index 9c831db514a52..d1dde628dd00e 100644
--- a/src/librustc/middle/trans/expr.rs
+++ b/src/librustc/middle/trans/expr.rs
@@ -1147,7 +1147,7 @@ fn trans_rec_or_struct(bcx: block,
         let mut need_base = vec::from_elem(field_tys.len(), true);
 
         let numbered_fields = do fields.map |field| {
-            let opt_pos = field_tys.iter().position_(|field_ty| field_ty.ident == field.node.ident);
+            let opt_pos = field_tys.iter().position(|field_ty| field_ty.ident == field.node.ident);
             match opt_pos {
                 Some(i) => {
                     need_base[i] = false;
@@ -1171,7 +1171,7 @@ fn trans_rec_or_struct(bcx: block,
                                      fields: leftovers })
             }
             None => {
-                if need_base.iter().any_(|b| *b) {
+                if need_base.iter().any(|b| *b) {
                     tcx.sess.span_bug(expr_span, "missing fields and no base expr")
                 }
                 None
diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs
index bfe8c012777be..bbcf68c386de7 100644
--- a/src/librustc/middle/trans/monomorphize.rs
+++ b/src/librustc/middle/trans/monomorphize.rs
@@ -84,7 +84,7 @@ pub fn monomorphic_fn(ccx: @mut CrateContext,
     let hash_id = make_mono_id(ccx, fn_id, impl_did_opt,
                                &*psubsts,
                                Some(param_uses));
-    if hash_id.params.iter().any_(
+    if hash_id.params.iter().any(
                 |p| match *p { mono_precise(_, _) => false, _ => true }) {
         must_cast = true;
     }
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 129208a9aa37e..dce899010c76d 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -1485,8 +1485,8 @@ pub fn type_needs_subst(ty: t) -> bool {
 }
 
 pub fn trait_ref_contains_error(tref: &ty::TraitRef) -> bool {
-    tref.substs.self_ty.iter().any_(|&t| type_is_error(t)) ||
-        tref.substs.tps.iter().any_(|&t| type_is_error(t))
+    tref.substs.self_ty.iter().any(|&t| type_is_error(t)) ||
+        tref.substs.tps.iter().any(|&t| type_is_error(t))
 }
 
 pub fn type_is_ty_var(ty: t) -> bool {
@@ -2342,13 +2342,13 @@ pub fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
             ty_struct(did, ref substs) => {
                 seen.push(did);
                 let fields = struct_fields(cx, did, substs);
-                let r = fields.iter().any_(|f| type_requires(cx, seen, r_ty, f.mt.ty));
+                let r = fields.iter().any(|f| type_requires(cx, seen, r_ty, f.mt.ty));
                 seen.pop();
                 r
             }
 
             ty_tup(ref ts) => {
-                ts.iter().any_(|t| type_requires(cx, seen, r_ty, *t))
+                ts.iter().any(|t| type_requires(cx, seen, r_ty, *t))
             }
 
             ty_enum(ref did, _) if seen.contains(did) => {
@@ -2359,7 +2359,7 @@ pub fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
                 seen.push(did);
                 let vs = enum_variants(cx, did);
                 let r = !vs.is_empty() && do vs.iter().all |variant| {
-                    do variant.args.iter().any_ |aty| {
+                    do variant.args.iter().any |aty| {
                         let sty = subst(cx, substs, *aty);
                         type_requires(cx, seen, r_ty, sty)
                     }
@@ -3241,7 +3241,7 @@ pub fn field_idx_strict(tcx: ty::ctxt, id: ast::ident, fields: &[field])
 }
 
 pub fn method_idx(id: ast::ident, meths: &[@Method]) -> Option<uint> {
-    meths.iter().position_(|m| m.ident == id)
+    meths.iter().position(|m| m.ident == id)
 }
 
 /// Returns a vector containing the indices of all type parameters that appear
diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs
index 9442eb0b83869..d8185022e416d 100644
--- a/src/librustc/middle/typeck/astconv.rs
+++ b/src/librustc/middle/typeck/astconv.rs
@@ -553,7 +553,7 @@ pub fn bound_lifetimes<AC:AstConv>(
     let special_idents = [special_idents::statik, special_idents::self_];
     let mut bound_lifetime_names = opt_vec::Empty;
     ast_lifetimes.map_to_vec(|ast_lifetime| {
-        if special_idents.iter().any_(|&i| i == ast_lifetime.ident) {
+        if special_idents.iter().any(|&i| i == ast_lifetime.ident) {
             this.tcx().sess.span_err(
                 ast_lifetime.span,
                 fmt!("illegal lifetime parameter name: `%s`",
diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs
index ee61399113a43..04c83f40f6cf8 100644
--- a/src/librustc/middle/typeck/check/method.rs
+++ b/src/librustc/middle/typeck/check/method.rs
@@ -253,7 +253,7 @@ impl<'self> LookupContext<'self> {
             ty_enum(did, _) => {
                 // Watch out for newtype'd enums like "enum t = @T".
                 // See discussion in typeck::check::do_autoderef().
-                if enum_dids.iter().any_(|x| x == &did) {
+                if enum_dids.iter().any(|x| x == &did) {
                     return None;
                 }
                 enum_dids.push(did);
@@ -368,7 +368,7 @@ impl<'self> LookupContext<'self> {
 
             let trait_methods = ty::trait_methods(tcx, bound_trait_ref.def_id);
             let pos = {
-                match trait_methods.iter().position_(|m| {
+                match trait_methods.iter().position(|m| {
                     m.explicit_self != ast::sty_static &&
                         m.ident == self.m_name })
                 {
@@ -412,7 +412,7 @@ impl<'self> LookupContext<'self> {
 
         let tcx = self.tcx();
         let ms = ty::trait_methods(tcx, did);
-        let index = match ms.iter().position_(|m| m.ident == self.m_name) {
+        let index = match ms.iter().position(|m| m.ident == self.m_name) {
             Some(i) => i,
             None => { return; } // no method with the right name
         };
@@ -466,7 +466,7 @@ impl<'self> LookupContext<'self> {
         // First, try self methods
         let mut method_info: Option<MethodInfo> = None;
         let methods = ty::trait_methods(tcx, did);
-        match methods.iter().position_(|m| m.ident == self.m_name) {
+        match methods.iter().position(|m| m.ident == self.m_name) {
             Some(i) => {
                 method_info = Some(MethodInfo {
                     method_ty: methods[i],
@@ -482,7 +482,7 @@ impl<'self> LookupContext<'self> {
             for ty::trait_supertraits(tcx, did).iter().advance |trait_ref| {
                 let supertrait_methods =
                     ty::trait_methods(tcx, trait_ref.def_id);
-                match supertrait_methods.iter().position_(|m| m.ident == self.m_name) {
+                match supertrait_methods.iter().position(|m| m.ident == self.m_name) {
                     Some(i) => {
                         method_info = Some(MethodInfo {
                             method_ty: supertrait_methods[i],
@@ -538,7 +538,7 @@ impl<'self> LookupContext<'self> {
                impl_info.methods.map(|m| m.ident).repr(self.tcx()));
 
         let idx = {
-            match impl_info.methods.iter().position_(|m| m.ident == self.m_name) {
+            match impl_info.methods.iter().position(|m| m.ident == self.m_name) {
                 Some(idx) => idx,
                 None => { return; } // No method with the right name.
             }
diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs
index d908633443961..7cc3286741430 100644
--- a/src/librustc/middle/typeck/check/vtable.rs
+++ b/src/librustc/middle/typeck/check/vtable.rs
@@ -67,7 +67,7 @@ impl VtableContext {
 }
 
 fn has_trait_bounds(type_param_defs: &[ty::TypeParameterDef]) -> bool {
-    type_param_defs.iter().any_(
+    type_param_defs.iter().any(
         |type_param_def| !type_param_def.bounds.trait_bounds.is_empty())
 }
 
diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs
index fb88f198231f8..fb544335a723b 100644
--- a/src/librustc/middle/typeck/collect.rs
+++ b/src/librustc/middle/typeck/collect.rs
@@ -391,7 +391,7 @@ pub fn ensure_supertraits(ccx: &CrateCtxt,
                                               generics, self_ty);
 
         // FIXME(#5527) Could have same trait multiple times
-        if ty_trait_refs.iter().any_(|other_trait| other_trait.def_id == trait_ref.def_id) {
+        if ty_trait_refs.iter().any(|other_trait| other_trait.def_id == trait_ref.def_id) {
             // This means a trait inherited from the same supertrait more
             // than once.
             tcx.sess.span_err(sp, "Duplicate supertrait in trait declaration");
diff --git a/src/librustc/middle/typeck/infer/lattice.rs b/src/librustc/middle/typeck/infer/lattice.rs
index b1a6aefd17949..90a316c78f965 100644
--- a/src/librustc/middle/typeck/infer/lattice.rs
+++ b/src/librustc/middle/typeck/infer/lattice.rs
@@ -540,7 +540,7 @@ pub fn var_ids<T:Combine>(this: &T, isr: isr_alist) -> ~[RegionVid] {
 
 pub fn is_var_in_set(new_vars: &[RegionVid], r: ty::Region) -> bool {
     match r {
-        ty::re_infer(ty::ReVar(ref v)) => new_vars.iter().any_(|x| x == v),
+        ty::re_infer(ty::ReVar(ref v)) => new_vars.iter().any(|x| x == v),
         _ => false
     }
 }
diff --git a/src/librustc/middle/typeck/infer/lub.rs b/src/librustc/middle/typeck/infer/lub.rs
index 3f23fd6e7096f..96d18976358e0 100644
--- a/src/librustc/middle/typeck/infer/lub.rs
+++ b/src/librustc/middle/typeck/infer/lub.rs
@@ -184,7 +184,7 @@ impl Combine for Lub {
             // with.
             for list::each(a_isr) |pair| {
                 let (a_br, a_r) = *pair;
-                if tainted.iter().any_(|x| x == &a_r) {
+                if tainted.iter().any(|x| x == &a_r) {
                     debug!("generalize_region(r0=%?): \
                             replacing with %?, tainted=%?",
                            r0, a_br, tainted);
diff --git a/src/librustc/middle/typeck/infer/region_inference/mod.rs b/src/librustc/middle/typeck/infer/region_inference/mod.rs
index 7bf4d07b72306..50290ba752e74 100644
--- a/src/librustc/middle/typeck/infer/region_inference/mod.rs
+++ b/src/librustc/middle/typeck/infer/region_inference/mod.rs
@@ -454,7 +454,7 @@ impl RegionVarBindings {
         {
             let mut result_set = result_set;
             if r == r1 { // Clearly, this is potentially inefficient.
-                if !result_set.iter().any_(|x| *x == r2) {
+                if !result_set.iter().any(|x| *x == r2) {
                     result_set.push(r2);
                 }
             }
diff --git a/src/librustc/middle/typeck/infer/sub.rs b/src/librustc/middle/typeck/infer/sub.rs
index cfb33732459ff..7e418c0061d33 100644
--- a/src/librustc/middle/typeck/infer/sub.rs
+++ b/src/librustc/middle/typeck/infer/sub.rs
@@ -199,7 +199,7 @@ impl Combine for Sub {
                 // or new variables:
                 match *tainted_region {
                     ty::re_infer(ty::ReVar(ref vid)) => {
-                        if new_vars.iter().any_(|x| x == vid) { loop; }
+                        if new_vars.iter().any(|x| x == vid) { loop; }
                     }
                     _ => {
                         if *tainted_region == skol { loop; }
diff --git a/src/librustc/rustc.rs b/src/librustc/rustc.rs
index 243ddb2a14b06..35375d025ebc6 100644
--- a/src/librustc/rustc.rs
+++ b/src/librustc/rustc.rs
@@ -212,7 +212,7 @@ pub fn run_compiler(args: &~[~str], demitter: diagnostic::Emitter) {
     let lint_flags = vec::append(getopts::opt_strs(matches, "W"),
                                  getopts::opt_strs(matches, "warn"));
 
-    let show_lint_options = lint_flags.iter().any_(|x| x == &~"help") ||
+    let show_lint_options = lint_flags.iter().any(|x| x == &~"help") ||
         (opt_present(matches, "W") && lint_flags.is_empty());
 
     if show_lint_options {
@@ -221,7 +221,7 @@ pub fn run_compiler(args: &~[~str], demitter: diagnostic::Emitter) {
     }
 
     let r = getopts::opt_strs(matches, "Z");
-    if r.iter().any_(|x| x == &~"help") {
+    if r.iter().any(|x| x == &~"help") {
         describe_debug_flags();
         return;
     }
diff --git a/src/librustdoc/attr_parser.rs b/src/librustdoc/attr_parser.rs
index 0681cf867f13a..e61f8d6d74334 100644
--- a/src/librustdoc/attr_parser.rs
+++ b/src/librustdoc/attr_parser.rs
@@ -57,7 +57,7 @@ pub fn parse_desc(attrs: ~[ast::attribute]) -> Option<~str> {
 
 pub fn parse_hidden(attrs: ~[ast::attribute]) -> bool {
     let r = doc_metas(attrs);
-    do r.iter().any_ |meta| {
+    do r.iter().any |meta| {
         match attr::get_meta_item_list(*meta) {
             Some(metas) => {
                 let hiddens = attr::find_meta_items_by_name(metas, "hidden");
diff --git a/src/librustdoc/rustdoc.rs b/src/librustdoc/rustdoc.rs
index 3659d24a254f8..ccf014fb2383b 100644
--- a/src/librustdoc/rustdoc.rs
+++ b/src/librustdoc/rustdoc.rs
@@ -64,7 +64,7 @@ pub mod util;
 pub fn main() {
     let args = os::args();
 
-    if args.iter().any_(|x| "-h" == *x) || args.iter().any_(|x| "--help" == *x) {
+    if args.iter().any(|x| "-h" == *x) || args.iter().any(|x| "--help" == *x) {
         config::usage();
         return;
     }
diff --git a/src/librusti/rusti.rs b/src/librusti/rusti.rs
index d9cd52201c0c5..d7c03ce2ba767 100644
--- a/src/librusti/rusti.rs
+++ b/src/librusti/rusti.rs
@@ -381,7 +381,7 @@ fn run_cmd(repl: &mut Repl, _in: @io::Reader, _out: @io::Writer,
                 let crate_path = Path(*crate);
                 let crate_dir = crate_path.dirname();
                 repl.program.record_extern(fmt!("extern mod %s;", *crate));
-                if !repl.lib_search_paths.iter().any_(|x| x == &crate_dir) {
+                if !repl.lib_search_paths.iter().any(|x| x == &crate_dir) {
                     repl.lib_search_paths.push(crate_dir);
                 }
             }
diff --git a/src/librustpkg/tests.rs b/src/librustpkg/tests.rs
index 042879807ea9c..251783577df8e 100644
--- a/src/librustpkg/tests.rs
+++ b/src/librustpkg/tests.rs
@@ -626,14 +626,14 @@ fn install_remove() {
     command_line_test([~"install", ~"bar"], &dir);
     command_line_test([~"install", ~"quux"], &dir);
     let list_output = command_line_test_output([~"list"]);
-    assert!(list_output.iter().any_(|x| x == &~"foo"));
-    assert!(list_output.iter().any_(|x| x == &~"bar"));
-    assert!(list_output.iter().any_(|x| x == &~"quux"));
+    assert!(list_output.iter().any(|x| x == &~"foo"));
+    assert!(list_output.iter().any(|x| x == &~"bar"));
+    assert!(list_output.iter().any(|x| x == &~"quux"));
     command_line_test([~"remove", ~"foo"], &dir);
     let list_output = command_line_test_output([~"list"]);
-    assert!(!list_output.iter().any_(|x| x == &~"foo"));
-    assert!(list_output.iter().any_(|x| x == &~"bar"));
-    assert!(list_output.iter().any_(|x| x == &~"quux"));
+    assert!(!list_output.iter().any(|x| x == &~"foo"));
+    assert!(list_output.iter().any(|x| x == &~"bar"));
+    assert!(list_output.iter().any(|x| x == &~"quux"));
 }
 
 #[test]
@@ -699,7 +699,7 @@ fn test_versions() {
     command_line_test([~"install", ~"foo#0.1"], &workspace);
     let output = command_line_test_output([~"list"]);
     // make sure output includes versions
-    assert!(!output.iter().any_(|x| x == &~"foo#0.2"));
+    assert!(!output.iter().any(|x| x == &~"foo#0.2"));
 }
 
 #[test]
diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs
index 8a57cd4b25c0e..900ef4896ca11 100644
--- a/src/librustpkg/util.rs
+++ b/src/librustpkg/util.rs
@@ -55,7 +55,7 @@ pub fn root() -> Path {
 }
 
 pub fn is_cmd(cmd: &str) -> bool {
-    COMMANDS.iter().any_(|&c| c == cmd)
+    COMMANDS.iter().any(|&c| c == cmd)
 }
 
 struct ListenerFn {
diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs
index b164bcbd28b3c..8094b2387495c 100644
--- a/src/libstd/iterator.rs
+++ b/src/libstd/iterator.rs
@@ -338,16 +338,16 @@ pub trait IteratorUtil<A> {
     /// ~~~ {.rust}
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter();
-    /// assert!(it.any_(|&x| *x == 3));
-    /// assert!(!it.any_(|&x| *x == 3));
+    /// assert!(it.any(|&x| *x == 3));
+    /// assert!(!it.any(|&x| *x == 3));
     /// ~~~
-    fn any_(&mut self, f: &fn(A) -> bool) -> bool;
+    fn any(&mut self, f: &fn(A) -> bool) -> bool;
 
     /// Return the first element satisfying the specified predicate
     fn find_(&mut self, predicate: &fn(&A) -> bool) -> Option<A>;
 
     /// Return the index of the first element satisfying the specified predicate
-    fn position_(&mut self, predicate: &fn(A) -> bool) -> Option<uint>;
+    fn position(&mut self, predicate: &fn(A) -> bool) -> Option<uint>;
 
     /// Count the number of elements satisfying the specified predicate
     fn count(&mut self, predicate: &fn(A) -> bool) -> uint;
@@ -504,7 +504,7 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
     }
 
     #[inline]
-    fn any_(&mut self, f: &fn(A) -> bool) -> bool {
+    fn any(&mut self, f: &fn(A) -> bool) -> bool {
         for self.advance |x| { if f(x) { return true; } }
         false
     }
@@ -520,7 +520,7 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
 
     /// Return the index of the first element satisfying the specified predicate
     #[inline]
-    fn position_(&mut self, predicate: &fn(A) -> bool) -> Option<uint> {
+    fn position(&mut self, predicate: &fn(A) -> bool) -> Option<uint> {
         let mut i = 0;
         for self.advance |x| {
             if predicate(x) {
@@ -1368,10 +1368,10 @@ mod tests {
     #[test]
     fn test_any() {
         let v = ~&[1, 2, 3, 4, 5];
-        assert!(v.iter().any_(|&x| x < 10));
-        assert!(v.iter().any_(|&x| x.is_even()));
-        assert!(!v.iter().any_(|&x| x > 100));
-        assert!(!v.slice(0, 0).iter().any_(|_| fail!()));
+        assert!(v.iter().any(|&x| x < 10));
+        assert!(v.iter().any(|&x| x.is_even()));
+        assert!(!v.iter().any(|&x| x > 100));
+        assert!(!v.slice(0, 0).iter().any(|_| fail!()));
     }
 
     #[test]
@@ -1385,9 +1385,9 @@ mod tests {
     #[test]
     fn test_position() {
         let v = &[1, 3, 9, 27, 103, 14, 11];
-        assert_eq!(v.iter().position_(|x| *x & 1 == 0).unwrap(), 5);
-        assert_eq!(v.iter().position_(|x| *x % 3 == 0).unwrap(), 1);
-        assert!(v.iter().position_(|x| *x % 12 == 0).is_none());
+        assert_eq!(v.iter().position(|x| *x & 1 == 0).unwrap(), 5);
+        assert_eq!(v.iter().position(|x| *x % 3 == 0).unwrap(), 1);
+        assert!(v.iter().position(|x| *x % 12 == 0).is_none());
     }
 
     #[test]
diff --git a/src/libstd/run.rs b/src/libstd/run.rs
index df15111a91f42..7e051b62171c8 100644
--- a/src/libstd/run.rs
+++ b/src/libstd/run.rs
@@ -587,7 +587,7 @@ pub fn make_command_line(prog: &str, args: &[~str]) -> ~str {
     return cmd;
 
     fn append_arg(cmd: &mut ~str, arg: &str) {
-        let quote = arg.iter().any_(|c| c == ' ' || c == '\t');
+        let quote = arg.iter().any(|c| c == ' ' || c == '\t');
         if quote {
             cmd.push_char('"');
         }
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 564c58f7097ee..bdd9bebf158d2 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -279,7 +279,7 @@ impl CharEq for extern "Rust" fn(char) -> bool {
 impl<'self, C: CharEq> CharEq for &'self [C] {
     #[inline]
     fn matches(&self, c: char) -> bool {
-        self.iter().any_(|m| m.matches(c))
+        self.iter().any(|m| m.matches(c))
     }
 
     fn only_ascii(&self) -> bool {
diff --git a/src/libstd/task/local_data_priv.rs b/src/libstd/task/local_data_priv.rs
index 0956b76c970a5..8dd96df454539 100644
--- a/src/libstd/task/local_data_priv.rs
+++ b/src/libstd/task/local_data_priv.rs
@@ -142,7 +142,7 @@ unsafe fn local_data_lookup<T: 'static>(
     -> Option<(uint, *libc::c_void)> {
 
     let key_value = key_to_key_value(key);
-    let map_pos = (*map).iter().position_(|entry|
+    let map_pos = (*map).iter().position(|entry|
         match *entry {
             Some((k,_,_)) => k == key_value,
             None => false
@@ -215,7 +215,7 @@ pub unsafe fn local_set<T: 'static>(
         }
         None => {
             // Find an empty slot. If not, grow the vector.
-            match (*map).iter().position_(|x| x.is_none()) {
+            match (*map).iter().position(|x| x.is_none()) {
                 Some(empty_index) => { map[empty_index] = new_entry; }
                 None => { map.push(new_entry); }
             }
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index effbc008b6ac8..84e4358a49601 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -191,7 +191,7 @@ impl<'self, T> Iterator<&'self [T]> for VecSplitIterator<'self, T> {
             return Some(self.v);
         }
 
-        match self.v.iter().position_(|x| (self.pred)(x)) {
+        match self.v.iter().position(|x| (self.pred)(x)) {
             None => {
                 self.finished = true;
                 Some(self.v)
@@ -1010,7 +1010,7 @@ impl<'self,T:Eq> ImmutableEqVector<T> for &'self [T] {
     /// Find the first index containing a matching value
     #[inline]
     fn position_elem(&self, x: &T) -> Option<uint> {
-        self.iter().position_(|y| *x == *y)
+        self.iter().position(|y| *x == *y)
     }
 
     /// Find the last index containing a matching value
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index d04d96b2481d6..e4532c476d75f 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -192,7 +192,7 @@ fn eq(a: @ast::meta_item, b: @ast::meta_item) -> bool {
             ast::meta_list(ref nb, ref misb) => {
                 if na != nb { return false; }
                 for misa.iter().advance |mi| {
-                    if !misb.iter().any_(|x| x == mi) { return false; }
+                    if !misb.iter().any(|x| x == mi) { return false; }
                 }
                 true
             }
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 940bd5ef61c11..71e0d49493b81 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -198,7 +198,7 @@ pub fn expand_item(extsbox: @mut SyntaxEnv,
 
 // does this attribute list contain "macro_escape" ?
 pub fn contains_macro_escape (attrs: &[ast::attribute]) -> bool {
-    attrs.iter().any_(|attr| "macro_escape" == attr::get_attr_name(attr))
+    attrs.iter().any(|attr| "macro_escape" == attr::get_attr_name(attr))
 }
 
 // Support for item-position macro invocations, exactly the same
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 2f79f60fb608b..c43b350abdbf7 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -3914,7 +3914,7 @@ impl Parser {
         };
         let full_path = full_path.normalize();
 
-        let maybe_i = do self.sess.included_mod_stack.iter().position_ |&p| { p == full_path };
+        let maybe_i = do self.sess.included_mod_stack.iter().position |&p| { p == full_path };
         match maybe_i {
             Some(i) => {
                 let stack = &self.sess.included_mod_stack;
diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs
index c4d89a698c1ab..867be38545cdf 100644
--- a/src/test/bench/core-std.rs
+++ b/src/test/bench/core-std.rs
@@ -44,7 +44,7 @@ fn maybe_run_test(argv: &[~str], name: ~str, test: &fn()) {
     if os::getenv(~"RUST_BENCH").is_some() {
         run_test = true
     } else if argv.len() > 0 {
-        run_test = argv.iter().any_(|x| x == &~"all") || argv.iter().any_(|x| x == &name)
+        run_test = argv.iter().any(|x| x == &~"all") || argv.iter().any(|x| x == &name)
     }
 
     if !run_test {
diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs
index d327b73c625ec..47de9334be15c 100644
--- a/src/test/bench/graph500-bfs.rs
+++ b/src/test/bench/graph500-bfs.rs
@@ -111,7 +111,7 @@ fn gen_search_keys(graph: &[~[node_id]], n: uint) -> ~[node_id] {
     while keys.len() < n {
         let k = r.gen_uint_range(0u, graph.len());
 
-        if graph[k].len() > 0u && graph[k].iter().any_(|i| {
+        if graph[k].len() > 0u && graph[k].iter().any(|i| {
             *i != k as node_id
         }) {
             keys.insert(k as node_id);
@@ -187,7 +187,7 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result {
     }
 
     let mut i = 0;
-    while colors.iter().any_(is_gray) {
+    while colors.iter().any(is_gray) {
         // Do the BFS.
         info!("PBFS iteration %?", i);
         i += 1;
@@ -402,7 +402,7 @@ fn validate(edges: ~[(node_id, node_id)],
             if *v == -1i64 || u == root {
                 true
             } else {
-                edges.iter().any_(|x| x == &(u, *v)) || edges.iter().any_(|x| x == &(*v, u))
+                edges.iter().any(|x| x == &(u, *v)) || edges.iter().any(|x| x == &(*v, u))
             }
         };
         result
diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs
index 8ea2a88fa09a7..466f2def290bf 100644
--- a/src/test/run-pass/block-arg.rs
+++ b/src/test/run-pass/block-arg.rs
@@ -20,20 +20,20 @@ pub fn main() {
     }
 
     // Usable at all:
-    let mut any_negative = do v.iter().any_ |e| { e.is_negative() };
+    let mut any_negative = do v.iter().any |e| { e.is_negative() };
     assert!(any_negative);
 
     // Higher precedence than assignments:
-    any_negative = do v.iter().any_ |e| { e.is_negative() };
+    any_negative = do v.iter().any |e| { e.is_negative() };
     assert!(any_negative);
 
     // Higher precedence than unary operations:
     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() });
+    assert!(!do abs_v.iter().any |e| { e.is_negative() });
 
     // Usable in funny statement-like forms:
-    if !do v.iter().any_ |e| { e.is_positive() } {
+    if !do v.iter().any |e| { e.is_positive() } {
         assert!(false);
     }
     match do v.iter().all |e| { e.is_negative() } {
@@ -41,7 +41,7 @@ pub fn main() {
         false => { }
     }
     match 3 {
-      _ if do v.iter().any_ |e| { e.is_negative() } => {
+      _ if do v.iter().any |e| { e.is_negative() } => {
       }
       _ => {
         fail!("wrong answer.");
@@ -58,7 +58,7 @@ pub fn main() {
 
     // In the tail of a block
     let w =
-        if true { do abs_v.iter().any_ |e| { e.is_positive() } }
+        if true { do abs_v.iter().any |e| { e.is_positive() } }
       else { false };
     assert!(w);
 }
diff --git a/src/test/run-pass/test-ignore-cfg.rs b/src/test/run-pass/test-ignore-cfg.rs
index e7a23244c06bc..068f18ac0f83a 100644
--- a/src/test/run-pass/test-ignore-cfg.rs
+++ b/src/test/run-pass/test-ignore-cfg.rs
@@ -29,8 +29,8 @@ fn checktests() {
     let tests = __test::tests;
 
     assert!(
-        tests.iter().any_(|t| t.desc.name.to_str() == ~"shouldignore" && t.desc.ignore));
+        tests.iter().any(|t| t.desc.name.to_str() == ~"shouldignore" && t.desc.ignore));
 
     assert!(
-        tests.iter().any_(|t| t.desc.name.to_str() == ~"shouldnotignore" && !t.desc.ignore));
+        tests.iter().any(|t| t.desc.name.to_str() == ~"shouldnotignore" && !t.desc.ignore));
 }