option: rewrite the API to use composition

12 files changed, 34 insertions, 34 deletions

diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index d9e24e045ff..7295081afba 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -588,7 +588,7 @@ impl<'self, O: IdVisitingOperation> Visitor<()> for IdVisitor<'self, O> {
                         id: NodeId,
                         _: ()) {
         self.operation.visit_id(id);
-        struct_def.ctor_id.map(|&ctor_id| self.operation.visit_id(ctor_id));
+        struct_def.ctor_id.map(|ctor_id| self.operation.visit_id(ctor_id));
         visit::walk_struct_def(self, struct_def, ident, generics, id, ());
     }
 
@@ -783,7 +783,7 @@ pub fn new_sctable_internal() -> SCTable {
 // fetch the SCTable from TLS, create one if it doesn't yet exist.
 pub fn get_sctable() -> @mut SCTable {
     local_data_key!(sctable_key: @@mut SCTable)
-    match local_data::get(sctable_key, |k| k.map_move(|k| *k)) {
+    match local_data::get(sctable_key, |k| k.map(|k| *k)) {
         None => {
             let new_table = @@mut new_sctable_internal();
             local_data::set(sctable_key,new_table);
@@ -820,7 +820,7 @@ pub type ResolveTable = HashMap<(Name,SyntaxContext),Name>;
 // fetch the SCTable from TLS, create one if it doesn't yet exist.
 pub fn get_resolve_table() -> @mut ResolveTable {
     local_data_key!(resolve_table_key: @@mut ResolveTable)
-    match local_data::get(resolve_table_key, |k| k.map(|&k| *k)) {
+    match local_data::get(resolve_table_key, |k| k.map(|k| *k)) {
         None => {
             let new_table = @@mut HashMap::new();
             local_data::set(resolve_table_key,new_table);
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index d9a23f6eb35..47b31a4f76d 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -83,7 +83,7 @@ impl AttrMetaMethods for MetaItem {
     }
 
     fn name_str_pair(&self) -> Option<(@str, @str)> {
-        self.value_str().map_move(|s| (self.name(), s))
+        self.value_str().map(|s| (self.name(), s))
     }
 }
 
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index 03b47f89ab6..4b5ab2fbb56 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -198,7 +198,7 @@ fn print_maybe_styled(msg: &str, color: term::attr::Attr) {
     let stderr = io::stderr();
 
     if stderr.get_type() == io::Screen {
-        let t = match local_data::get(tls_terminal, |v| v.map_move(|k| *k)) {
+        let t = match local_data::get(tls_terminal, |v| v.map(|k| *k)) {
             None => {
                 let t = term::Terminal::new(stderr);
                 let tls = @match t {
@@ -337,7 +337,7 @@ fn highlight_lines(cm: @codemap::CodeMap,
 
 fn print_macro_backtrace(cm: @codemap::CodeMap, sp: Span) {
     for ei in sp.expn_info.iter() {
-        let ss = ei.callee.span.map_default(~"", |span| cm.span_to_str(*span));
+        let ss = ei.callee.span.as_ref().map_default(~"", |span| cm.span_to_str(*span));
         print_diagnostic(ss, note,
                          format!("in expansion of {}!", ei.callee.name));
         let ss = cm.span_to_str(ei.call_site);
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 7f89271927c..a64e8ff825c 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -565,7 +565,7 @@ impl <K: Eq + Hash + IterBytes + 'static, V: 'static> MapChain<K,V>{
             ConsMapChain(ref map,_) => map
         };
         // strip one layer of indirection off the pointer.
-        map.find(key).map_move(|r| {*r})
+        map.find(key).map(|r| {*r})
     }
 
     // insert the binding into the top-level map
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index a5336187200..78cdc3f585b 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -663,7 +663,7 @@ impl AstBuilder for @ExtCtxt {
 
     fn expr_if(&self, span: Span,
                cond: @ast::Expr, then: @ast::Expr, els: Option<@ast::Expr>) -> @ast::Expr {
-        let els = els.map_move(|x| self.expr_block(self.block_expr(x)));
+        let els = els.map(|x| self.expr_block(self.block_expr(x)));
         self.expr(span, ast::ExprIf(cond, self.block_expr(then), els))
     }
 
diff --git a/src/libsyntax/ext/deriving/ty.rs b/src/libsyntax/ext/deriving/ty.rs
index d6f5e2df5a4..83c73e3d85f 100644
--- a/src/libsyntax/ext/deriving/ty.rs
+++ b/src/libsyntax/ext/deriving/ty.rs
@@ -249,7 +249,7 @@ pub fn get_explicit_self(cx: @ExtCtxt, span: Span, self_ptr: &Option<PtrTy>)
                     Send => ast::sty_uniq,
                     Managed(mutbl) => ast::sty_box(mutbl),
                     Borrowed(ref lt, mutbl) => {
-                        let lt = lt.map(|s| cx.lifetime(span, cx.ident_of(*s)));
+                        let lt = lt.map(|s| cx.lifetime(span, cx.ident_of(s)));
                         ast::sty_region(lt, mutbl)
                     }
                 });
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 1039ec07804..01d0fd80672 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -582,7 +582,7 @@ fn expand_non_macro_stmt(exts: SyntaxEnv, s: &Stmt, fld: &MacroExpander)
             // add them to the existing pending renames:
             for pr in new_pending_renames.iter() {pending_renames.push(*pr)}
             // also, don't forget to expand the init:
-            let new_init_opt = init.map(|e| fld.fold_expr(*e));
+            let new_init_opt = init.map(|e| fld.fold_expr(e));
             let rewritten_local =
                 @Local {
                     is_mutbl: is_mutbl,
@@ -725,7 +725,7 @@ pub fn expand_block_elts(exts: SyntaxEnv, b: &Block, fld: &MacroExpander)
             None => ()
         }
     }
-    let new_expr = b.expr.map(|x| fld.fold_expr(rename_fld.fold_expr(*x)));
+    let new_expr = b.expr.map(|x| fld.fold_expr(rename_fld.fold_expr(x)));
     Block{
         view_items: new_view_items,
         stmts: new_stmts,
diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs
index 171748e9b2e..7518816be1e 100644
--- a/src/libsyntax/ext/format.rs
+++ b/src/libsyntax/ext/format.rs
@@ -266,7 +266,7 @@ impl Context {
                     }
                 };
                 self.verify_same(span, ty,
-                                 self.name_types.find(&name).map(|&x| *x));
+                                 self.name_types.find(&name).map(|&x| x));
                 if !self.name_types.contains_key(&name) {
                     self.name_types.insert(name, ty);
                 }
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 909f5e5c443..3c601196db9 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -165,7 +165,7 @@ pub trait ast_fold {
     fn fold_arm(&self, a: &Arm) -> Arm {
         Arm {
             pats: a.pats.map(|x| self.fold_pat(*x)),
-            guard: a.guard.map_move(|x| self.fold_expr(x)),
+            guard: a.guard.map(|x| self.fold_expr(x)),
             body: self.fold_block(&a.body),
         }
     }
@@ -176,12 +176,12 @@ pub trait ast_fold {
             PatIdent(binding_mode, ref pth, ref sub) => {
                 PatIdent(binding_mode,
                          self.fold_path(pth),
-                         sub.map_move(|x| self.fold_pat(x)))
+                         sub.map(|x| self.fold_pat(x)))
             }
             PatLit(e) => PatLit(self.fold_expr(e)),
             PatEnum(ref pth, ref pats) => {
                 PatEnum(self.fold_path(pth),
-                        pats.map(|pats| pats.map(|x| self.fold_pat(*x))))
+                        pats.as_ref().map(|pats| pats.map(|x| self.fold_pat(*x))))
             }
             PatStruct(ref pth, ref fields, etc) => {
                 let pth_ = self.fold_path(pth);
@@ -202,7 +202,7 @@ pub trait ast_fold {
             },
             PatVec(ref before, ref slice, ref after) => {
                 PatVec(before.map(|x| self.fold_pat(*x)),
-                       slice.map_move(|x| self.fold_pat(x)),
+                       slice.map(|x| self.fold_pat(x)),
                        after.map(|x| self.fold_pat(*x)))
             }
         };
@@ -225,7 +225,7 @@ pub trait ast_fold {
             }
         };
 
-        node.map_move(|node| {
+        node.map(|node| {
             @Spanned {
                 node: node,
                 span: d.span,
@@ -313,7 +313,7 @@ pub trait ast_fold {
                 kind = struct_variant_kind(@ast::struct_def {
                     fields: struct_def.fields.iter()
                         .map(|f| self.fold_struct_field(*f)).collect(),
-                    ctor_id: struct_def.ctor_id.map(|c| self.new_id(*c))
+                    ctor_id: struct_def.ctor_id.map(|c| self.new_id(c))
                 })
             }
         }
@@ -360,7 +360,7 @@ pub trait ast_fold {
             is_mutbl: l.is_mutbl,
             ty: self.fold_ty(&l.ty),
             pat: self.fold_pat(l.pat),
-            init: l.init.map_move(|e| self.fold_expr(e)),
+            init: l.init.map(|e| self.fold_expr(e)),
             id: self.new_id(l.id),
             span: self.new_span(l.span),
         }
@@ -445,7 +445,7 @@ pub fn fold_tts<T:ast_fold>(tts: &[token_tree], fld: &T) -> ~[token_tree] {
             tt_seq(span, ref pattern, ref sep, is_optional) =>
             tt_seq(span,
                    @mut fold_tts(**pattern, fld),
-                   sep.map(|tok|maybe_fold_ident(tok,fld)),
+                   sep.as_ref().map(|tok|maybe_fold_ident(tok,fld)),
                    is_optional),
             tt_nonterminal(sp,ref ident) =>
             tt_nonterminal(sp,fld.fold_ident(*ident))
@@ -515,7 +515,7 @@ fn fold_struct_def<T:ast_fold>(struct_def: @ast::struct_def, fld: &T)
                                -> @ast::struct_def {
     @ast::struct_def {
         fields: struct_def.fields.map(|f| fold_struct_field(*f, fld)),
-        ctor_id: struct_def.ctor_id.map(|cid| fld.new_id(*cid)),
+        ctor_id: struct_def.ctor_id.map(|cid| fld.new_id(cid)),
     }
 }
 
@@ -577,7 +577,7 @@ fn fold_field<T:ast_fold>(f: TypeField, folder: &T) -> TypeField {
 
 fn fold_opt_bounds<T:ast_fold>(b: &Option<OptVec<TyParamBound>>, folder: &T)
                                -> Option<OptVec<TyParamBound>> {
-    do b.map |bounds| {
+    do b.as_ref().map |bounds| {
         do bounds.map |bound| {
             fold_ty_param_bound(bound, folder)
         }
@@ -604,7 +604,7 @@ pub fn noop_fold_block<T:ast_fold>(b: &Block, folder: &T) -> Block {
     ast::Block {
         view_items: view_items,
         stmts: stmts,
-        expr: b.expr.map(|x| folder.fold_expr(*x)),
+        expr: b.expr.map(|x| folder.fold_expr(x)),
         id: folder.new_id(b.id),
         rules: b.rules,
         span: folder.new_span(b.span),
@@ -648,7 +648,7 @@ pub fn noop_fold_item_underscore<T:ast_fold>(i: &item_, folder: &T) -> item_ {
         }
         item_impl(ref generics, ref ifce, ref ty, ref methods) => {
             item_impl(fold_generics(generics, folder),
-                      ifce.map(|p| fold_trait_ref(p, folder)),
+                      ifce.as_ref().map(|p| fold_trait_ref(p, folder)),
                       folder.fold_ty(ty),
                       methods.map(|x| folder.fold_method(*x))
             )
@@ -764,7 +764,7 @@ pub fn noop_fold_expr<T:ast_fold>(e: @ast::Expr, folder: &T) -> @ast::Expr {
         ExprIf(cond, ref tr, fl) => {
             ExprIf(folder.fold_expr(cond),
                    folder.fold_block(tr),
-                   fl.map_move(|x| folder.fold_expr(x)))
+                   fl.map(|x| folder.fold_expr(x)))
         }
         ExprWhile(cond, ref body) => {
             ExprWhile(folder.fold_expr(cond), folder.fold_block(body))
@@ -773,11 +773,11 @@ pub fn noop_fold_expr<T:ast_fold>(e: @ast::Expr, folder: &T) -> @ast::Expr {
             ExprForLoop(folder.fold_pat(pat),
                         folder.fold_expr(iter),
                         folder.fold_block(body),
-                        maybe_ident.map_move(|i| folder.fold_ident(i)))
+                        maybe_ident.map(|i| folder.fold_ident(i)))
         }
         ExprLoop(ref body, opt_ident) => {
             ExprLoop(folder.fold_block(body),
-                     opt_ident.map_move(|x| folder.fold_ident(x)))
+                     opt_ident.map(|x| folder.fold_ident(x)))
         }
         ExprMatch(expr, ref arms) => {
             ExprMatch(folder.fold_expr(expr),
@@ -814,7 +814,7 @@ pub fn noop_fold_expr<T:ast_fold>(e: @ast::Expr, folder: &T) -> @ast::Expr {
         ExprBreak(opt_ident) => ExprBreak(opt_ident),
         ExprAgain(opt_ident) => ExprAgain(opt_ident),
         ExprRet(ref e) => {
-            ExprRet(e.map_move(|x| folder.fold_expr(x)))
+            ExprRet(e.map(|x| folder.fold_expr(x)))
         }
         ExprInlineAsm(ref a) => {
             ExprInlineAsm(inline_asm {
@@ -827,7 +827,7 @@ pub fn noop_fold_expr<T:ast_fold>(e: @ast::Expr, folder: &T) -> @ast::Expr {
         ExprStruct(ref path, ref fields, maybe_expr) => {
             ExprStruct(folder.fold_path(path),
                        fields.map(|x| fold_field(*x)),
-                       maybe_expr.map_move(|x| folder.fold_expr(x)))
+                       maybe_expr.map(|x| folder.fold_expr(x)))
         },
         ExprParen(ex) => ExprParen(folder.fold_expr(ex))
     };
@@ -856,7 +856,7 @@ pub fn noop_fold_stmt<T:ast_fold>(s: &Stmt, folder: &T) -> Option<@Stmt> {
         StmtMac(ref mac, semi) => Some(StmtMac(folder.fold_mac(mac), semi))
     };
 
-    node.map_move(|node| @Spanned {
+    node.map(|node| @Spanned {
         node: node,
         span: folder.new_span(s.span),
     })
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 484e40a1daa..9f1a436a4d5 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -405,7 +405,7 @@ impl Parser {
         fn tokens_to_str(p:&Parser, tokens: &[token::Token]) -> ~str {
             let mut i = tokens.iter();
             // This might be a sign we need a connect method on Iterator.
-            let b = i.next().map_default(~"", |t| p.token_to_str(*t));
+            let b = i.next().map_default(~"", |t| p.token_to_str(t));
             i.fold(b, |b,a| b + "`, `" + p.token_to_str(a))
         }
         if edible.contains(self.token) {
@@ -470,7 +470,7 @@ impl Parser {
     pub fn commit_stmt(&self, s: @Stmt, edible: &[token::Token], inedible: &[token::Token]) {
         debug2!("commit_stmt {:?}", s);
         let _s = s; // unused, but future checks might want to inspect `s`.
-        if self.last_token.map_default(false, |t|is_ident_or_path(*t)) {
+        if self.last_token.as_ref().map_default(false, |t| is_ident_or_path(*t)) {
             let expected = vec::append(edible.to_owned(), inedible);
             self.check_for_erroneous_unit_struct_expecting(expected);
         }
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 6d3f1d51576..eae3e665b58 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -510,7 +510,7 @@ static RESERVED_KEYWORD_FINAL: uint = 71;
 // fresh one.
 pub fn get_ident_interner() -> @ident_interner {
     local_data_key!(key: @@::parse::token::ident_interner)
-    match local_data::get(key, |k| k.map_move(|k| *k)) {
+    match local_data::get(key, |k| k.map(|k| *k)) {
         Some(interner) => *interner,
         None => {
             let interner = mk_fresh_ident_interner();
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 7091a2d5518..74d5e1a6d27 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1978,7 +1978,7 @@ pub fn print_ty_fn(s: @ps,
     print_onceness(s, onceness);
     word(s.s, "fn");
     match id { Some(id) => { word(s.s, " "); print_ident(s, id); } _ => () }
-    do opt_bounds.map |bounds| { print_bounds(s, bounds, true); };
+    do opt_bounds.as_ref().map |bounds| { print_bounds(s, bounds, true); };
     match generics { Some(g) => print_generics(s, g), _ => () }
     zerobreak(s.s);