libsyntax: Change all uses of &fn to ||.

pcwalton · pcwalton · commit 492677ec1e4e · 2013-11-19T12:40:19.000-08:00
diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs
@@ -84,7 +84,7 @@ static AbiDatas: &'static [AbiData] = &[
     AbiData {abi: RustIntrinsic, name: "rust-intrinsic", abi_arch: RustArch},
 ];
 
-fn each_abi(op: &fn(abi: Abi) -> bool) -> bool {
+fn each_abi(op: |abi: Abi| -> bool) -> bool {
     /*!
      *
      * Iterates through each of the defined ABIs.
@@ -201,7 +201,7 @@ impl AbiSet {
         self.bits |= (1 << abi.index());
     }
 
-    pub fn each(&self, op: &fn(abi: Abi) -> bool) -> bool {
+    pub fn each(&self, op: |abi: Abi| -> bool) -> bool {
         each_abi(|abi| !self.contains(abi) || op(abi))
     }
 
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
@@ -122,7 +122,7 @@ pub enum ast_node {
 }
 
 impl ast_node {
-    pub fn with_attrs<T>(&self, f: &fn(Option<&[Attribute]>) -> T) -> T {
+    pub fn with_attrs<T>(&self, f: |Option<&[Attribute]>| -> T) -> T {
         let attrs = match *self {
             node_item(i, _) => Some(i.attrs.as_slice()),
             node_foreign_item(fi, _, _, _) => Some(fi.attrs.as_slice()),
@@ -480,9 +480,8 @@ pub fn node_id_to_str(map: map, id: NodeId, itr: @ident_interner) -> ~str {
     }
 }
 
-pub fn node_item_query<Result>(items: map, id: NodeId,
-                               query: &fn(@item) -> Result,
-                               error_msg: ~str) -> Result {
+pub fn node_item_query<Result>(items: map, id: NodeId, query: |@item| -> Result, error_msg: ~str)
+                       -> Result {
     match items.find(&id) {
         Some(&node_item(it, _)) => query(it),
         _ => fail!("{}", error_msg)
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
@@ -636,7 +636,7 @@ pub fn is_item_impl(item: @ast::item) -> bool {
     }
 }
 
-pub fn walk_pat(pat: @Pat, it: &fn(@Pat) -> bool) -> bool {
+pub fn walk_pat(pat: @Pat, it: |@Pat| -> bool) -> bool {
     if !it(pat) {
         return false;
     }
@@ -665,7 +665,7 @@ pub fn walk_pat(pat: @Pat, it: &fn(@Pat) -> bool) -> bool {
 }
 
 pub trait EachViewItem {
-    fn each_view_item(&self, f: &fn(&ast::view_item) -> bool) -> bool;
+    fn each_view_item(&self, f: |&ast::view_item| -> bool) -> bool;
 }
 
 struct EachViewItemData<'self> {
@@ -679,7 +679,7 @@ impl<'self> Visitor<()> for EachViewItemData<'self> {
 }
 
 impl EachViewItem for ast::Crate {
-    fn each_view_item(&self, f: &fn(&ast::view_item) -> bool) -> bool {
+    fn each_view_item(&self, f: |&ast::view_item| -> bool) -> bool {
         let mut visit = EachViewItemData {
             callback: f,
         };
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
@@ -347,9 +347,11 @@ fn print_macro_backtrace(cm: @codemap::CodeMap, sp: Span) {
     }
 }
 
-pub fn expect<T:Clone>(diag: @mut span_handler,
-                       opt: Option<T>,
-                       msg: &fn() -> ~str) -> T {
+pub fn expect<T:Clone>(
+              diag: @mut span_handler,
+              opt: Option<T>,
+              msg: || -> ~str)
+              -> T {
     match opt {
        Some(ref t) => (*t).clone(),
        None => diag.handler().bug(msg()),
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
@@ -559,11 +559,11 @@ impl <K: Eq + Hash + IterBytes + 'static, V: 'static> MapChain<K,V>{
     // should each_key and each_value operate on shadowed
     // names? I think not.
     // delaying implementing this....
-    pub fn each_key (&self, _f: &fn (&K)->bool) {
+    pub fn each_key (&self, _f: |&K| -> bool) {
         fail!("unimplemented 2013-02-15T10:01");
     }
 
-    pub fn each_value (&self, _f: &fn (&V) -> bool) {
+    pub fn each_value (&self, _f: |&V| -> bool) {
         fail!("unimplemented 2013-02-15T10:02");
     }
 
@@ -601,7 +601,11 @@ impl <K: Eq + Hash + IterBytes + 'static, V: 'static> MapChain<K,V>{
     // ... there are definitely some opportunities for abstraction
     // here that I'm ignoring. (e.g., manufacturing a predicate on
     // the maps in the chain, and using an abstract "find".
-    pub fn insert_into_frame(&mut self, key: K, ext: @V, n: K, pred: &fn(&@V)->bool) {
+    pub fn insert_into_frame(&mut self,
+                             key: K,
+                             ext: @V,
+                             n: K,
+                             pred: |&@V| -> bool) {
         match *self {
             BaseMapChain (~ref mut map) => {
                 if satisfies_pred(map,&n,pred) {
@@ -622,10 +626,12 @@ impl <K: Eq + Hash + IterBytes + 'static, V: 'static> MapChain<K,V>{
 }
 
 // returns true if the binding for 'n' satisfies 'pred' in 'map'
-fn satisfies_pred<K : Eq + Hash + IterBytes,V>(map : &mut HashMap<K,V>,
-                                               n: &K,
-                                               pred: &fn(&V)->bool)
-    -> bool {
+fn satisfies_pred<K:Eq + Hash + IterBytes,
+                  V>(
+                  map: &mut HashMap<K,V>,
+                  n: &K,
+                  pred: |&V| -> bool)
+                  -> bool {
     match map.find(n) {
         Some(ref v) => (pred(*v)),
         None => false
@@ -637,7 +643,8 @@ mod test {
     use super::MapChain;
     use std::hashmap::HashMap;
 
-    #[test] fn testenv () {
+    #[test]
+    fn testenv() {
         let mut a = HashMap::new();
         a.insert (@"abc",@15);
         let m = MapChain::new(~a);
diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs
@@ -124,9 +124,12 @@ fn decodable_substructure(cx: @ExtCtxt, span: Span,
 /// Create a decoder for a single enum variant/struct:
 /// - `outer_pat_ident` is the name of this enum variant/struct
 /// - `getarg` should retrieve the `uint`-th field with name `@str`.
-fn decode_static_fields(cx: @ExtCtxt, outer_span: Span, outer_pat_ident: Ident,
+fn decode_static_fields(cx: @ExtCtxt,
+                        outer_span: Span,
+                        outer_pat_ident: Ident,
                         fields: &StaticFields,
-                        getarg: &fn(Span, @str, uint) -> @Expr) -> @Expr {
+                        getarg: |Span, @str, uint| -> @Expr)
+                        -> @Expr {
     match *fields {
         Unnamed(ref fields) => {
             if fields.is_empty() {
diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs
@@ -1064,14 +1064,13 @@ Fold the fields. `use_foldl` controls whether this is done
 left-to-right (`true`) or right-to-left (`false`).
 */
 pub fn cs_fold(use_foldl: bool,
-               f: &fn(@ExtCtxt, Span,
-                      old: @Expr,
-                      self_f: @Expr,
-                      other_fs: &[@Expr]) -> @Expr,
+               f: |@ExtCtxt, Span, @Expr, @Expr, &[@Expr]| -> @Expr,
                base: @Expr,
                enum_nonmatch_f: EnumNonMatchFunc,
-               cx: @ExtCtxt, trait_span: Span,
-               substructure: &Substructure) -> @Expr {
+               cx: @ExtCtxt,
+               trait_span: Span,
+               substructure: &Substructure)
+               -> @Expr {
     match *substructure.fields {
         EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => {
             if use_foldl {
@@ -1104,10 +1103,12 @@ f(cx, span, ~[self_1.method(__arg_1_1, __arg_2_1),
 ~~~
 */
 #[inline]
-pub fn cs_same_method(f: &fn(@ExtCtxt, Span, ~[@Expr]) -> @Expr,
+pub fn cs_same_method(f: |@ExtCtxt, Span, ~[@Expr]| -> @Expr,
                       enum_nonmatch_f: EnumNonMatchFunc,
-                      cx: @ExtCtxt, trait_span: Span,
-                      substructure: &Substructure) -> @Expr {
+                      cx: @ExtCtxt,
+                      trait_span: Span,
+                      substructure: &Substructure)
+                      -> @Expr {
     match *substructure.fields {
         EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => {
             // call self_n.method(other_1_n, other_2_n, ...)
@@ -1136,11 +1137,13 @@ fields. `use_foldl` controls whether this is done left-to-right
 */
 #[inline]
 pub fn cs_same_method_fold(use_foldl: bool,
-                           f: &fn(@ExtCtxt, Span, @Expr, @Expr) -> @Expr,
+                           f: |@ExtCtxt, Span, @Expr, @Expr| -> @Expr,
                            base: @Expr,
                            enum_nonmatch_f: EnumNonMatchFunc,
-                           cx: @ExtCtxt, trait_span: Span,
-                           substructure: &Substructure) -> @Expr {
+                           cx: @ExtCtxt,
+                           trait_span: Span,
+                           substructure: &Substructure)
+                           -> @Expr {
     cs_same_method(
         |cx, span, vals| {
             if use_foldl {
diff --git a/src/libsyntax/ext/deriving/rand.rs b/src/libsyntax/ext/deriving/rand.rs
@@ -128,10 +128,12 @@ fn rand_substructure(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @Expr {
         _ => cx.bug("Non-static method in `deriving(Rand)`")
     };
 
-    fn rand_thing(cx: @ExtCtxt, span: Span,
+    fn rand_thing(cx: @ExtCtxt,
+                  span: Span,
                   ctor_ident: Ident,
                   summary: &StaticFields,
-                  rand_call: &fn(Span) -> @Expr) -> @Expr {
+                  rand_call: |Span| -> @Expr)
+                  -> @Expr {
         match *summary {
             Unnamed(ref fields) => {
                 if fields.is_empty() {
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
@@ -381,7 +381,7 @@ pub trait ast_fold {
         }
     }
 
-    fn map_exprs(&self, f: &fn(@Expr) -> @Expr, es: &[@Expr]) -> ~[@Expr] {
+    fn map_exprs(&self, f: |@Expr| -> @Expr, es: &[@Expr]) -> ~[@Expr] {
         es.map(|x| f(*x))
     }
 
diff --git a/src/libsyntax/opt_vec.rs b/src/libsyntax/opt_vec.rs
@@ -50,14 +50,14 @@ impl<T> OptVec<T> {
         *self = Vec(~[t]);
     }
 
-    pub fn map<U>(&self, op: &fn(&T) -> U) -> OptVec<U> {
+    pub fn map<U>(&self, op: |&T| -> U) -> OptVec<U> {
         match *self {
             Empty => Empty,
             Vec(ref v) => Vec(v.map(op))
         }
     }
 
-    pub fn map_move<U>(self, op: &fn(T) -> U) -> OptVec<U> {
+    pub fn map_move<U>(self, op: |T| -> U) -> OptVec<U> {
         match self {
             Empty => Empty,
             Vec(v) => Vec(v.move_iter().map(op).collect())
@@ -91,11 +91,11 @@ impl<T> OptVec<T> {
     }
 
     #[inline]
-    pub fn map_to_vec<B>(&self, op: &fn(&T) -> B) -> ~[B] {
+    pub fn map_to_vec<B>(&self, op: |&T| -> B) -> ~[B] {
         self.iter().map(op).collect()
     }
 
-    pub fn mapi_to_vec<B>(&self, op: &fn(uint, &T) -> B) -> ~[B] {
+    pub fn mapi_to_vec<B>(&self, op: |uint, &T| -> B) -> ~[B] {
         let mut index = 0;
         self.map_to_vec(|a| {
             let i = index;
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
@@ -216,16 +216,22 @@ fn byte_offset(rdr: &StringReader, pos: BytePos) -> BytePos {
 /// Calls `f` with a string slice of the source text spanning from `start`
 /// up to but excluding `rdr.last_pos`, meaning the slice does not include
 /// the character `rdr.curr`.
-pub fn with_str_from<T>(rdr: @mut StringReader, start: BytePos, f: &fn(s: &str) -> T) -> T {
+pub fn with_str_from<T>(
+                     rdr: @mut StringReader,
+                     start: BytePos,
+                     f: |s: &str| -> T)
+                     -> T {
     with_str_from_to(rdr, start, rdr.last_pos, f)
 }
 
 /// Calls `f` with astring slice of the source text spanning from `start`
 /// up to but excluding `end`.
-fn with_str_from_to<T>(rdr: @mut StringReader,
-                       start: BytePos,
-                       end: BytePos,
-                       f: &fn(s: &str) -> T) -> T {
+fn with_str_from_to<T>(
+                    rdr: @mut StringReader,
+                    start: BytePos,
+                    end: BytePos,
+                    f: |s: &str| -> T)
+                    -> T {
     f(rdr.src.slice(
             byte_offset(rdr, start).to_uint(),
             byte_offset(rdr, end).to_uint()))
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
@@ -177,19 +177,14 @@ pub fn parse_tts_from_source_str(
 // consumed all of the input before returning the function's
 // result.
 pub fn parse_from_source_str<T>(
-    f: &fn(&Parser) -> T,
-    name: @str, ss: codemap::FileSubstr,
-    source: @str,
-    cfg: ast::CrateConfig,
-    sess: @mut ParseSess
-) -> T {
-    let p = new_parser_from_source_substr(
-        sess,
-        cfg,
-        name,
-        ss,
-        source
-    );
+                             f: |&Parser| -> T,
+                             name: @str,
+                             ss: codemap::FileSubstr,
+                             source: @str,
+                             cfg: ast::CrateConfig,
+                             sess: @mut ParseSess)
+                             -> T {
+    let p = new_parser_from_source_substr(sess, cfg, name, ss, source);
     let r = f(&p);
     if !p.reader.is_eof() {
         p.reader.fatal(~"expected end-of-string");
diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
@@ -82,7 +82,7 @@ impl ParserObsoleteMethods for Parser {
             ),
             ObsoleteBareFnType => (
                 "bare function type",
-                "use `&fn` or `extern fn` instead"
+                "use `|A| -> B` or `extern fn(A) -> B` instead"
             ),
             ObsoleteNamedExternModule => (
                 "named external module",
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
diff --git a/src/libsyntax/util/parser_testing.rs b/src/libsyntax/util/parser_testing.rs

Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ static AbiDatas: &'static [AbiData] = &[`
`84`	`84`	`AbiData {abi: RustIntrinsic, name: "rust-intrinsic", abi_arch: RustArch},`
`85`	`85`	`];`
`86`	`86`
`87`		`-fn each_abi(op: &fn(abi: Abi) -> bool) -> bool {`
	`87`	`+fn each_abi(op: \|abi: Abi\| -> bool) -> bool {`
`88`	`88`	`/*!`
`89`	`89`	`*`
`90`	`90`	`* Iterates through each of the defined ABIs.`
`@@ -201,7 +201,7 @@ impl AbiSet {`
`201`	`201`	`self.bits \|= (1 << abi.index());`
`202`	`202`	`}`
`203`	`203`
`204`		`- pub fn each(&self, op: &fn(abi: Abi) -> bool) -> bool {`
	`204`	`+ pub fn each(&self, op: \|abi: Abi\| -> bool) -> bool {`
`205`	`205`	`each_abi(\|abi\| !self.contains(abi) \|\| op(abi))`
`206`	`206`	`}`
`207`	`207`
Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ pub enum ast_node {`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`impl ast_node {`
`125`		`- pub fn with_attrs<T>(&self, f: &fn(Option<&[Attribute]>) -> T) -> T {`
	`125`	`+ pub fn with_attrs<T>(&self, f: \|Option<&[Attribute]>\| -> T) -> T {`
`126`	`126`	`let attrs = match *self {`
`127`	`127`	`node_item(i, _) => Some(i.attrs.as_slice()),`
`128`	`128`	`node_foreign_item(fi, _, _, _) => Some(fi.attrs.as_slice()),`
`@@ -480,9 +480,8 @@ pub fn node_id_to_str(map: map, id: NodeId, itr: @ident_interner) -> ~str {`
`480`	`480`	`}`
`481`	`481`	`}`
`482`	`482`
`483`		`-pub fn node_item_query<Result>(items: map, id: NodeId,`
`484`		`- query: &fn(@item) -> Result,`
`485`		`- error_msg: ~str) -> Result {`
	`483`	`+pub fn node_item_query<Result>(items: map, id: NodeId, query: \|@item\| -> Result, error_msg: ~str)`
	`484`	`+ -> Result {`
`486`	`485`	`match items.find(&id) {`
`487`	`486`	`Some(&node_item(it, _)) => query(it),`
`488`	`487`	`_ => fail!("{}", error_msg)`
Original file line number	Diff line number	Diff line change
`@@ -636,7 +636,7 @@ pub fn is_item_impl(item: @ast::item) -> bool {`
`636`	`636`	`}`
`637`	`637`	`}`
`638`	`638`
`639`		`-pub fn walk_pat(pat: @Pat, it: &fn(@Pat) -> bool) -> bool {`
	`639`	`+pub fn walk_pat(pat: @Pat, it: \|@Pat\| -> bool) -> bool {`
`640`	`640`	`if !it(pat) {`
`641`	`641`	`return false;`
`642`	`642`	`}`
`@@ -665,7 +665,7 @@ pub fn walk_pat(pat: @Pat, it: &fn(@Pat) -> bool) -> bool {`
`665`	`665`	`}`
`666`	`666`
`667`	`667`	`pub trait EachViewItem {`
`668`		`- fn each_view_item(&self, f: &fn(&ast::view_item) -> bool) -> bool;`
	`668`	`+ fn each_view_item(&self, f: \|&ast::view_item\| -> bool) -> bool;`
`669`	`669`	`}`
`670`	`670`
`671`	`671`	`struct EachViewItemData<'self> {`
`@@ -679,7 +679,7 @@ impl<'self> Visitor<()> for EachViewItemData<'self> {`
`679`	`679`	`}`
`680`	`680`
`681`	`681`	`impl EachViewItem for ast::Crate {`
`682`		`- fn each_view_item(&self, f: &fn(&ast::view_item) -> bool) -> bool {`
	`682`	`+ fn each_view_item(&self, f: \|&ast::view_item\| -> bool) -> bool {`
`683`	`683`	`let mut visit = EachViewItemData {`
`684`	`684`	`callback: f,`
`685`	`685`	`};`
Original file line number	Diff line number	Diff line change
`@@ -347,9 +347,11 @@ fn print_macro_backtrace(cm: @codemap::CodeMap, sp: Span) {`
`347`	`347`	`}`
`348`	`348`	`}`
`349`	`349`
`350`		`-pub fn expect<T:Clone>(diag: @mut span_handler,`
`351`		`- opt: Option<T>,`
`352`		`- msg: &fn() -> ~str) -> T {`
	`350`	`+pub fn expect<T:Clone>(`
	`351`	`+ diag: @mut span_handler,`
	`352`	`+ opt: Option<T>,`
	`353`	`+ msg: \|\| -> ~str)`
	`354`	`+ -> T {`
`353`	`355`	`match opt {`
`354`	`356`	`Some(ref t) => (*t).clone(),`
`355`	`357`	`None => diag.handler().bug(msg()),`
Original file line number	Diff line number	Diff line change
`@@ -381,7 +381,7 @@ pub trait ast_fold {`
`381`	`381`	`}`
`382`	`382`	`}`
`383`	`383`
`384`		`- fn map_exprs(&self, f: &fn(@Expr) -> @Expr, es: &[@Expr]) -> ~[@Expr] {`
	`384`	`+ fn map_exprs(&self, f: \|@Expr\| -> @Expr, es: &[@Expr]) -> ~[@Expr] {`
`385`	`385`	`es.map(\|x\| f(*x))`
`386`	`386`	`}`
`387`	`387`
Original file line number	Diff line number	Diff line change
`@@ -50,14 +50,14 @@ impl<T> OptVec<T> {`
`50`	`50`	`*self = Vec(~[t]);`
`51`	`51`	`}`
`52`	`52`
`53`		`- pub fn map<U>(&self, op: &fn(&T) -> U) -> OptVec<U> {`
	`53`	`+ pub fn map<U>(&self, op: \|&T\| -> U) -> OptVec<U> {`
`54`	`54`	`match *self {`
`55`	`55`	`Empty => Empty,`
`56`	`56`	`Vec(ref v) => Vec(v.map(op))`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`		`- pub fn map_move<U>(self, op: &fn(T) -> U) -> OptVec<U> {`
	`60`	`+ pub fn map_move<U>(self, op: \|T\| -> U) -> OptVec<U> {`
`61`	`61`	`match self {`
`62`	`62`	`Empty => Empty,`
`63`	`63`	`Vec(v) => Vec(v.move_iter().map(op).collect())`
`@@ -91,11 +91,11 @@ impl<T> OptVec<T> {`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`#[inline]`
`94`		`- pub fn map_to_vec<B>(&self, op: &fn(&T) -> B) -> ~[B] {`
	`94`	`+ pub fn map_to_vec<B>(&self, op: \|&T\| -> B) -> ~[B] {`
`95`	`95`	`self.iter().map(op).collect()`
`96`	`96`	`}`
`97`	`97`
`98`		`- pub fn mapi_to_vec<B>(&self, op: &fn(uint, &T) -> B) -> ~[B] {`
	`98`	`+ pub fn mapi_to_vec<B>(&self, op: \|uint, &T\| -> B) -> ~[B] {`
`99`	`99`	`let mut index = 0;`
`100`	`100`	`self.map_to_vec(\|a\| {`
`101`	`101`	`let i = index;`