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.
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))
}
}
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()),
}
}
-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)
}
}
-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;
}
}
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> {
}
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,
};
}
}
-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()),
// 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");
}
// ... 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) {
}
// 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
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);
/// 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() {
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 {
~~~
*/
#[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, ...)
*/
#[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 {
_ => 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() {
}
}
- 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))
}
*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())
}
#[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;
/// 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()))
// 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");
),
ObsoleteBareFnType => (
"bare function type",
- "use `&fn` or `extern fn` instead"
+ "use `|A| -> B` or `extern fn(A) -> B` instead"
),
ObsoleteNamedExternModule => (
"named external module",
}
// 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) &&
// 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
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;
// 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
// 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 {
// 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();
// 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);
}
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();
// 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(*) => {
// 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();
// 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 || {
// 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)) ||
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() {
}
-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;
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);
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();
projects / rust.git / commitdiff