nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-23 07:14:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Patrick Walton 2013-11-19 12:21:21 -08:00
parent 18a30aff45
commit 492677ec1e
16 changed files with 139 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/libsyntax/abi.rs
View File

@ -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))
}

7
src/libsyntax/ast_map.rs
View File

@ -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)

6
src/libsyntax/ast_util.rs
View File

@ -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,
};

8
src/libsyntax/diagnostic.rs
View File

@ -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()),

23
src/libsyntax/ext/base.rs
View File

@ -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);

7
src/libsyntax/ext/deriving/decodable.rs
View File

@ -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() {

27
src/libsyntax/ext/deriving/generic.rs
View File

@ -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 {

6
src/libsyntax/ext/deriving/rand.rs
View File

@ -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() {

2
src/libsyntax/fold.rs
View File

@ -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))
}

8
src/libsyntax/opt_vec.rs
View File

@ -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;

16
src/libsyntax/parse/lexer.rs
View File

@ -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()))

21
src/libsyntax/parse/mod.rs
View File

@ -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");

2
src/libsyntax/parse/obsolete.rs
View File

@ -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",

99
src/libsyntax/parse/parser.rs
View File

@ -581,10 +581,8 @@ impl Parser {
}
// Parse a sequence bracketed by `|` and `|`, stopping before the `|`.
fn parse_seq_to_before_or<T>(&self,
sep: &token::Token,
f: &fn(&Parser) -> T)
-> ~[T] {
fn parse_seq_to_before_or<T>(&self, sep: &token::Token, f: |&Parser| -> T)
-> ~[T] {
let mut first = true;
let mut vector = ~[];
while *self.token != token::BINOP(token::OR) &&
@ -619,10 +617,11 @@ impl Parser {
// parse a sequence bracketed by '<' and '>', stopping
// before the '>'.
pub fn parse_seq_to_before_gt<T>(&self,
sep: Option<token::Token>,
f: &fn(&Parser) -> T)
-> OptVec<T> {
pub fn parse_seq_to_before_gt<T>(
&self,
sep: Option<token::Token>,
f: |&Parser| -> T)
-> OptVec<T> {
let mut first = true;
let mut v = opt_vec::Empty;
while *self.token != token::GT
@ -639,10 +638,11 @@ impl Parser {
return v;
}
pub fn parse_seq_to_gt<T>(&self,
sep: Option<token::Token>,
f: &fn(&Parser) -> T)
-> OptVec<T> {
pub fn parse_seq_to_gt<T>(
&self,
sep: Option<token::Token>,
f: |&Parser| -> T)
-> OptVec<T> {
let v = self.parse_seq_to_before_gt(sep, f);
self.expect_gt();
return v;
@ -651,11 +651,12 @@ impl Parser {
// parse a sequence, including the closing delimiter. The function
// f must consume tokens until reaching the next separator or
// closing bracket.
pub fn parse_seq_to_end<T>(&self,
ket: &token::Token,
sep: SeqSep,
f: &fn(&Parser) -> T)
-> ~[T] {
pub fn parse_seq_to_end<T>(
&self,
ket: &token::Token,
sep: SeqSep,
f: |&Parser| -> T)
-> ~[T] {
let val = self.parse_seq_to_before_end(ket, sep, f);
self.bump();
val
@ -664,11 +665,12 @@ impl Parser {
// parse a sequence, not including the closing delimiter. The function
// f must consume tokens until reaching the next separator or
// closing bracket.
pub fn parse_seq_to_before_end<T>(&self,
ket: &token::Token,
sep: SeqSep,
f: &fn(&Parser) -> T)
-> ~[T] {
pub fn parse_seq_to_before_end<T>(
&self,
ket: &token::Token,
sep: SeqSep,
f: |&Parser| -> T)
-> ~[T] {
let mut first: bool = true;
let mut v: ~[T] = ~[];
while *self.token != *ket {
@ -688,12 +690,13 @@ impl Parser {
// parse a sequence, including the closing delimiter. The function
// f must consume tokens until reaching the next separator or
// closing bracket.
pub fn parse_unspanned_seq<T>(&self,
bra: &token::Token,
ket: &token::Token,
sep: SeqSep,
f: &fn(&Parser) -> T)
-> ~[T] {
pub fn parse_unspanned_seq<T>(
&self,
bra: &token::Token,
ket: &token::Token,
sep: SeqSep,
f: |&Parser| -> T)
-> ~[T] {
self.expect(bra);
let result = self.parse_seq_to_before_end(ket, sep, f);
self.bump();
@ -702,12 +705,13 @@ impl Parser {
// NB: Do not use this function unless you actually plan to place the
// spanned list in the AST.
pub fn parse_seq<T>(&self,
bra: &token::Token,
ket: &token::Token,
sep: SeqSep,
f: &fn(&Parser) -> T)
-> Spanned<~[T]> {
pub fn parse_seq<T>(
&self,
bra: &token::Token,
ket: &token::Token,
sep: SeqSep,
f: |&Parser| -> T)
-> Spanned<~[T]> {
let lo = self.span.lo;
self.expect(bra);
let result = self.parse_seq_to_before_end(ket, sep, f);
@ -765,8 +769,8 @@ impl Parser {
}
return (4 - *self.buffer_start) + *self.buffer_end;
}
pub fn look_ahead<R>(&self, distance: uint, f: &fn(&token::Token) -> R)
-> R {
pub fn look_ahead<R>(&self, distance: uint, f: |&token::Token| -> R)
-> R {
let dist = distance as int;
while self.buffer_length() < dist {
self.buffer[*self.buffer_end] = self.reader.next_token();
@ -1272,7 +1276,8 @@ impl Parser {
// parse the type following a @ or a ~
pub fn parse_box_or_uniq_pointee(&self,
sigil: ast::Sigil,
ctor: &fn(v: mt) -> ty_) -> ty_ {
ctor: |v: mt| -> ty_)
-> ty_ {
// ~'foo fn() or ~fn() are parsed directly as obsolete fn types:
match *self.token {
token::LIFETIME(*) => {
@ -2467,8 +2472,8 @@ impl Parser {
// this is used both in parsing a lambda expr
// and in parsing a block expr as e.g. in for...
pub fn parse_lambda_expr_(&self,
parse_decl: &fn() -> fn_decl,
parse_body: &fn() -> @Expr)
parse_decl: || -> fn_decl,
parse_body: || -> @Expr)
-> @Expr {
let lo = self.last_span.lo;
let decl = parse_decl();
@ -2513,10 +2518,11 @@ impl Parser {
// parse a 'for' or 'do'.
// the 'for' and 'do' expressions parse as calls, but look like
// function calls followed by a closure expression.
pub fn parse_sugary_call_expr(&self, lo: BytePos,
pub fn parse_sugary_call_expr(&self,
lo: BytePos,
keyword: ~str,
sugar: CallSugar,
ctor: &fn(v: @Expr) -> Expr_)
ctor: |v: @Expr| -> Expr_)
-> @Expr {
// Parse the callee `foo` in
// for foo || {
@ -3611,11 +3617,12 @@ impl Parser {
// parse the argument list and result type of a function
// that may have a self type.
fn parse_fn_decl_with_self(&self, parse_arg_fn: &fn(&Parser) -> arg)
-> (explicit_self, fn_decl) {
fn maybe_parse_explicit_self(cnstr: &fn(v: Mutability) -> ast::explicit_self_,
p: &Parser) -> ast::explicit_self_ {
fn parse_fn_decl_with_self(&self, parse_arg_fn: |&Parser| -> arg)
-> (explicit_self, fn_decl) {
fn maybe_parse_explicit_self(cnstr: |v: Mutability| ->
ast::explicit_self_,
p: &Parser)
-> ast::explicit_self_ {
// We need to make sure it isn't a type
if p.look_ahead(1, |t| token::is_keyword(keywords::Self, t)) ||
((p.look_ahead(1, |t| token::is_keyword(keywords::Const, t)) ||

12
src/libsyntax/print/pprust.rs
View File

@ -331,7 +331,7 @@ pub fn synth_comment(s: @ps, text: ~str) {
word(s.s, "*/");
}
pub fn commasep<T>(s: @ps, b: breaks, elts: &[T], op: &fn(@ps, &T)) {
pub fn commasep<T>(s: @ps, b: breaks, elts: &[T], op: |@ps, &T|) {
box(s, 0u, b);
let mut first = true;
for elt in elts.iter() {
@ -342,8 +342,12 @@ pub fn commasep<T>(s: @ps, b: breaks, elts: &[T], op: &fn(@ps, &T)) {
}
pub fn commasep_cmnt<T>(s: @ps, b: breaks, elts: &[T], op: &fn(@ps, &T),
get_span: &fn(&T) -> codemap::Span) {
pub fn commasep_cmnt<T>(
s: @ps,
b: breaks,
elts: &[T],
op: |@ps, &T|,
get_span: |&T| -> codemap::Span) {
box(s, 0u, b);
let len = elts.len();
let mut i = 0u;
@ -2289,7 +2293,7 @@ pub fn print_string(s: @ps, st: &str, style: ast::StrStyle) {
word(s.s, st);
}
pub fn to_str<T>(t: &T, f: &fn(@ps, &T), intr: @ident_interner) -> ~str {
pub fn to_str<T>(t: &T, f: |@ps, &T|, intr: @ident_interner) -> ~str {
let wr = @mut MemWriter::new();
let s = rust_printer(wr as @mut io::Writer, intr);
f(s, t);

2
src/libsyntax/util/parser_testing.rs
View File

@ -39,7 +39,7 @@ pub fn string_to_parser(source_str: @str) -> Parser {
p
}
fn with_error_checking_parse<T>(s: @str, f: &fn(&mut Parser) -> T) -> T {
fn with_error_checking_parse<T>(s: @str, f: |&mut Parser| -> T) -> T {
let mut p = string_to_parser(s);
let x = f(&mut p);
p.abort_if_errors();