Skip to content

test: Remove most uses of &fn() from the tests. #10572

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 3 commits into from
+498 −486
Closed

test: Remove most uses of &fn() from the tests. #10572

Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
2049016
test: Remove most uses of `&fn()` from the tests.
pcwalton Nov 20, 2013
5d57c24
librustc: Remove remaining uses of `&fn()` in favor of `||`.
pcwalton Nov 20, 2013
3b26855
libsyntax: Remove the old-style borrowed closure type syntax from the
pcwalton Nov 20, 2013
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
18 changes: 9 additions & 9 deletions doc/po/ja/rust.md.po
View file
Original file line number Diff line number Diff line change
@@ -1817,10 +1817,10 @@ msgstr ""
#, no-wrap
msgid ""
"~~~~ {.xfail-test}\n"
"fn iter<T>(seq: &[T], f: &fn(T)) {\n"
"fn iter<T>(seq: &[T], f: |T|) {\n"
" for elt in seq.iter() { f(elt); }\n"
"}\n"
"fn map<T, U>(seq: &[T], f: &fn(T) -> U) -> ~[U] {\n"
"fn map<T, U>(seq: &[T], f: |T| -> U) -> ~[U] {\n"
" let mut acc = ~[];\n"
" for elt in seq.iter() { acc.push(f(elt)); }\n"
" acc\n"
@@ -2404,7 +2404,7 @@ msgid ""
"trait Seq<T> {\n"
" fn len(&self) -> uint;\n"
" fn elt_at(&self, n: uint) -> T;\n"
" fn iter(&self, &fn(T));\n"
" fn iter(&self, |T|);\n"
"}\n"
"~~~~\n"
msgstr ""
@@ -4243,7 +4243,7 @@ msgid ""
"[function definitions](#functions) do not. The exact type of capture "
"depends on the [function type](#function-types) inferred for the lambda "
"expression. In the simplest and least-expensive form (analogous to a "
"```&fn() { }``` expression), the lambda expression captures its environment "
"```|| { }``` expression), the lambda expression captures its environment "
"by reference, effectively borrowing pointers to all outer variables "
"mentioned inside the function. Alternately, the compiler may infer that a "
"lambda expression should copy or move values (depending on their type.) "
@@ -4262,7 +4262,7 @@ msgstr ""
#, no-wrap
msgid ""
"~~~~\n"
"fn ten_times(f: &fn(int)) {\n"
"fn ten_times(f: |int|) {\n"
" let mut i = 0;\n"
" while i < 10 {\n"
" f(i);\n"
@@ -4455,7 +4455,7 @@ msgstr ""

#. type: Plain text
#: doc/rust.md:2339
msgid "~~~~ # fn f(f: &fn(int)) { } # fn g(i: int) { }"
msgid "~~~~ # fn f(f: |int|) { } # fn g(i: int) { }"
msgstr ""

#. type: Plain text
@@ -4481,7 +4481,7 @@ msgstr ""

#. type: Plain text
#: doc/rust.md:2352
msgid "~~~~ # fn k(x:int, f: &fn(int)) { } # fn l(i: int) { }"
msgid "~~~~ # fn k(x:int, f: |int|) { } # fn l(i: int) { }"
msgstr ""

#. type: Plain text
@@ -5383,7 +5383,7 @@ msgstr ""
#. type: Plain text
#: doc/rust.md:2849
msgid ""
"type Binop<'self> = &'self fn(int,int) -> int; let bo: Binop = add; x = "
"type Binop<'self> = 'self |int,int| -> int; let bo: Binop = add; x = "
"bo(5,7); ~~~~~~~~"
msgstr ""

@@ -5483,7 +5483,7 @@ msgstr ""
#, no-wrap
msgid ""
"~~~~~~~\n"
"fn map<A: Clone, B: Clone>(f: &fn(A) -> B, xs: &[A]) -> ~[B] {\n"
"fn map<A: Clone, B: Clone>(f: |A|) -> B, xs: &[A]) -> ~[B] {\n"
" if xs.len() == 0 {\n"
" return ~[];\n"
" }\n"
28 changes: 14 additions & 14 deletions doc/po/ja/tutorial.md.po
View file
Original file line number Diff line number Diff line change
@@ -3340,10 +3340,10 @@ msgstr ""

#. type: Plain text
#: doc/tutorial.md:1434
msgid "~~~~ fn call_closure_with_ten(b: &fn(int)) { b(10); }"
msgid "~~~~ fn call_closure_with_ten(b: |int|) { b(10); }"
msgstr ""
"~~~~\n"
"fn call_closure_with_ten(b: &fn(int)) { b(10); }"
"fn call_closure_with_ten(b: |int|) { b(10); }"

#. type: Plain text
#: doc/tutorial.md:1437
@@ -3400,11 +3400,11 @@ msgstr ""
#: doc/tutorial.md:1459
msgid ""
"There are several forms of closure, each with its own role. The most common, "
"called a _stack closure_, has type `&fn` and can directly access local "
"called a _stack closure_, has type `||` and can directly access local "
"variables in the enclosing scope."
msgstr ""
"クロージャにはいくつかの形態があり、それぞれに独自の役割があります。最も一般"
"的なのはスタッククロージャと呼ばれるもので、 `&fn` という型を持ち、外側のロー"
"的なのはスタッククロージャと呼ばれるもので、 `||` という型を持ち、外側のロー"
"カル変数に直接アクセスすることができます。"

#. type: Plain text
@@ -3531,27 +3531,27 @@ msgstr "## クロージャの互換性"
msgid ""
"Rust closures have a convenient subtyping property: you can pass any kind of "
"closure (as long as the arguments and return types match) to functions that "
"expect a `&fn()`. Thus, when writing a higher-order function that only calls "
"expect a `||`. Thus, when writing a higher-order function that only calls "
"its function argument, and does nothing else with it, you should almost "
"always declare the type of that argument as `&fn()`. That way, callers may "
"always declare the type of that argument as `||`. That way, callers may "
"pass any kind of closure."
msgstr ""
"Rust のクロージャは型の派生 (subtyping) という便利な性質を持っています。この"
"性質により、`&fn()` 型を期待する関数には (引数と戻り値の型が一致する限り) 任"
"性質により、`||` 型を期待する関数には (引数と戻り値の型が一致する限り) 任"
"意の種類のクロージャを渡すことができます。したがって、引数で渡された関数につ"
"いては呼び出すだけで他に何もしない高階関数を書くときには、ほぼすべてのケース"
"で引数の型を `&fn` と宣言するべきです。そうすることで、呼び出し元は任意の種類"
"で引数の型を `||` と宣言するべきです。そうすることで、呼び出し元は任意の種類"
"のクロージャを渡すことができるよになります。"

#. type: Plain text
#: doc/tutorial.md:1527
msgid ""
"~~~~ fn call_twice(f: &fn()) { f(); f(); } let closure = || { \"I'm a "
"~~~~ fn call_twice(f: ||) { f(); f(); } let closure = || { \"I'm a "
"closure, and it doesn't matter what type I am\"; }; fn function() { \"I'm a "
"normal function\"; } call_twice(closure); call_twice(function); ~~~~"
msgstr ""
"~~~~\n"
"fn call_twice(f: &fn()) { f(); f(); }\n"
"fn call_twice(f: ||) { f(); f(); }\n"
"let closure = || { \"I'm a closure, and it doesn't matter what type I am"
"\"; };\n"
"fn function() { \"I'm a normal function\"; }\n"
@@ -3598,7 +3598,7 @@ msgstr ""
#, no-wrap
msgid ""
"~~~~\n"
"fn each(v: &[int], op: &fn(v: &int)) {\n"
"fn each(v: &[int], op: |v: &int|) {\n"
" let mut n = 0;\n"
" while n < v.len() {\n"
" op(&v[n]);\n"
@@ -3622,7 +3622,7 @@ msgstr ""
#, no-wrap
msgid ""
"~~~~\n"
"# fn each(v: &[int], op: &fn(v: &int)) { }\n"
"# fn each(v: &[int], op: |v: &int|) { }\n"
"# fn do_some_work(i: &int) { }\n"
"each([1, 2, 3], |n| {\n"
" do_some_work(n);\n"
@@ -3644,7 +3644,7 @@ msgstr ""
#, no-wrap
msgid ""
"~~~~\n"
"# fn each(v: &[int], op: &fn(v: &int)) { }\n"
"# fn each(v: &[int], op: |v: &int|) { }\n"
"# fn do_some_work(i: &int) { }\n"
"do each([1, 2, 3]) |n| {\n"
" do_some_work(n);\n"
@@ -4011,7 +4011,7 @@ msgstr ""
#, no-wrap
msgid ""
"~~~~\n"
"fn map<T, U>(vector: &[T], function: &fn(v: &T) -> U) -> ~[U] {\n"
"fn map<T, U>(vector: &[T], function: |v: &T| -> U) -> ~[U] {\n"
" let mut accumulator = ~[];\n"
" for element in vector.iter() {\n"
" accumulator.push(function(element));\n"
18 changes: 9 additions & 9 deletions doc/po/rust.md.pot
View file
Original file line number Diff line number Diff line change
@@ -1817,10 +1817,10 @@ msgstr ""
#, no-wrap
msgid ""
"~~~~ {.xfail-test}\n"
"fn iter<T>(seq: &[T], f: &fn(T)) {\n"
"fn iter<T>(seq: &[T], f: |T|) {\n"
" for elt in seq.iter() { f(elt); }\n"
"}\n"
"fn map<T, U>(seq: &[T], f: &fn(T) -> U) -> ~[U] {\n"
"fn map<T, U>(seq: &[T], f: |T| -> U) -> ~[U] {\n"
" let mut acc = ~[];\n"
" for elt in seq.iter() { acc.push(f(elt)); }\n"
" acc\n"
@@ -2404,7 +2404,7 @@ msgid ""
"trait Seq<T> {\n"
" fn len(&self) -> uint;\n"
" fn elt_at(&self, n: uint) -> T;\n"
" fn iter(&self, &fn(T));\n"
" fn iter(&self, |T|);\n"
"}\n"
"~~~~\n"
msgstr ""
@@ -4230,7 +4230,7 @@ msgid ""
"[function definitions](#functions) do not. The exact type of capture "
"depends on the [function type](#function-types) inferred for the lambda "
"expression. In the simplest and least-expensive form (analogous to a "
"```&fn() { }``` expression), the lambda expression captures its environment "
"```|| { }``` expression), the lambda expression captures its environment "
"by reference, effectively borrowing pointers to all outer variables "
"mentioned inside the function. Alternately, the compiler may infer that a "
"lambda expression should copy or move values (depending on their type.) "
@@ -4249,7 +4249,7 @@ msgstr ""
#, no-wrap
msgid ""
"~~~~\n"
"fn ten_times(f: &fn(int)) {\n"
"fn ten_times(f: |int|) {\n"
" let mut i = 0;\n"
" while i < 10 {\n"
" f(i);\n"
@@ -4442,7 +4442,7 @@ msgstr ""

#. type: Plain text
#: doc/rust.md:2339
msgid "~~~~ # fn f(f: &fn(int)) { } # fn g(i: int) { }"
msgid "~~~~ # fn f(f: |int|) { } # fn g(i: int) { }"
msgstr ""

#. type: Plain text
@@ -4468,7 +4468,7 @@ msgstr ""

#. type: Plain text
#: doc/rust.md:2352
msgid "~~~~ # fn k(x:int, f: &fn(int)) { } # fn l(i: int) { }"
msgid "~~~~ # fn k(x:int, f: |int|) { } # fn l(i: int) { }"
msgstr ""

#. type: Plain text
@@ -5370,7 +5370,7 @@ msgstr ""
#. type: Plain text
#: doc/rust.md:2849
msgid ""
"type Binop<'self> = &'self fn(int,int) -> int; let bo: Binop = add; x = "
"type Binop<'self> = 'self |int,int| -> int; let bo: Binop = add; x = "
"bo(5,7); ~~~~~~~~"
msgstr ""

@@ -5470,7 +5470,7 @@ msgstr ""
#, no-wrap
msgid ""
"~~~~~~~\n"
"fn map<A: Clone, B: Clone>(f: &fn(A) -> B, xs: &[A]) -> ~[B] {\n"
"fn map<A: Clone, B: Clone>(f: |A| -> B, xs: &[A]) -> ~[B] {\n"
" if xs.len() == 0 {\n"
" return ~[];\n"
" }\n"
18 changes: 9 additions & 9 deletions doc/po/tutorial.md.pot
View file
Original file line number Diff line number Diff line change
@@ -2558,7 +2558,7 @@ msgstr ""

#. type: Plain text
#: doc/tutorial.md:1434
msgid "~~~~ fn call_closure_with_ten(b: &fn(int)) { b(10); }"
msgid "~~~~ fn call_closure_with_ten(b: |int|) { b(10); }"
msgstr ""

#. type: Plain text
@@ -2601,7 +2601,7 @@ msgstr ""
#: doc/tutorial.md:1459
msgid ""
"There are several forms of closure, each with its own role. The most common, "
"called a _stack closure_, has type `&fn` and can directly access local "
"called a _stack closure_, has type `||` and can directly access local "
"variables in the enclosing scope."
msgstr ""

@@ -2700,16 +2700,16 @@ msgstr ""
msgid ""
"Rust closures have a convenient subtyping property: you can pass any kind of "
"closure (as long as the arguments and return types match) to functions that "
"expect a `&fn()`. Thus, when writing a higher-order function that only calls "
"expect a `||`. Thus, when writing a higher-order function that only calls "
"its function argument, and does nothing else with it, you should almost "
"always declare the type of that argument as `&fn()`. That way, callers may "
"always declare the type of that argument as `||`. That way, callers may "
"pass any kind of closure."
msgstr ""

#. type: Plain text
#: doc/tutorial.md:1527
msgid ""
"~~~~ fn call_twice(f: &fn()) { f(); f(); } let closure = || { \"I'm a "
"~~~~ fn call_twice(f: ||) { f(); f(); } let closure = || { \"I'm a "
"closure, and it doesn't matter what type I am\"; }; fn function() { \"I'm a "
"normal function\"; } call_twice(closure); call_twice(function); ~~~~"
msgstr ""
@@ -2746,7 +2746,7 @@ msgstr ""
#, no-wrap
msgid ""
"~~~~\n"
"fn each(v: &[int], op: &fn(v: &int)) {\n"
"fn each(v: &[int], op: |v: &int|) {\n"
" let mut n = 0;\n"
" while n < v.len() {\n"
" op(&v[n]);\n"
@@ -2768,7 +2768,7 @@ msgstr ""
#, no-wrap
msgid ""
"~~~~\n"
"# fn each(v: &[int], op: &fn(v: &int)) { }\n"
"# fn each(v: &[int], op: |v: &int|) { }\n"
"# fn do_some_work(i: &int) { }\n"
"each([1, 2, 3], |n| {\n"
" do_some_work(n);\n"
@@ -2788,7 +2788,7 @@ msgstr ""
#, no-wrap
msgid ""
"~~~~\n"
"# fn each(v: &[int], op: &fn(v: &int)) { }\n"
"# fn each(v: &[int], op: |v: &int|) { }\n"
"# fn do_some_work(i: &int) { }\n"
"do each([1, 2, 3]) |n| {\n"
" do_some_work(n);\n"
@@ -3080,7 +3080,7 @@ msgstr ""
#, no-wrap
msgid ""
"~~~~\n"
"fn map<T, U>(vector: &[T], function: &fn(v: &T) -> U) -> ~[U] {\n"
"fn map<T, U>(vector: &[T], function: |v: &T| -> U) -> ~[U] {\n"
" let mut accumulator = ~[];\n"
" for element in vector.iter() {\n"
" accumulator.push(function(element));\n"
18 changes: 9 additions & 9 deletions doc/rust.md
View file
Original file line number Diff line number Diff line change
@@ -950,10 +950,10 @@ declared, in an angle-bracket-enclosed, comma-separated list following
the function name.

~~~~ {.xfail-test}
fn iter<T>(seq: &[T], f: &fn(T)) {
fn iter<T>(seq: &[T], f: |T|) {
for elt in seq.iter() { f(elt); }
}
fn map<T, U>(seq: &[T], f: &fn(T) -> U) -> ~[U] {
fn map<T, U>(seq: &[T], f: |T| -> U) -> ~[U] {
let mut acc = ~[];
for elt in seq.iter() { acc.push(f(elt)); }
acc
@@ -1315,7 +1315,7 @@ These appear after the trait name, using the same syntax used in [generic functi
trait Seq<T> {
fn len(&self) -> uint;
fn elt_at(&self, n: uint) -> T;
fn iter(&self, &fn(T));
fn iter(&self, |T|);
}
~~~~

@@ -2608,7 +2608,7 @@ as an abbreviation for defining and capturing a separate function.
Significantly, lambda expressions _capture their environment_,
which regular [function definitions](#functions) do not.
The exact type of capture depends on the [function type](#function-types) inferred for the lambda expression.
In the simplest and least-expensive form (analogous to a ```&fn() { }``` expression),
In the simplest and least-expensive form (analogous to a ```|| { }``` expression),
the lambda expression captures its environment by reference,
effectively borrowing pointers to all outer variables mentioned inside the function.
Alternately, the compiler may infer that a lambda expression should copy or move values (depending on their type.)
@@ -2618,7 +2618,7 @@ In this example, we define a function `ten_times` that takes a higher-order func
and call it with a lambda expression as an argument.

~~~~
fn ten_times(f: &fn(int)) {
fn ten_times(f: |int|) {
let mut i = 0;
while i < 10 {
f(i);
@@ -2727,7 +2727,7 @@ If the `expr` is a [field expression](#field-expressions), it is parsed as thoug
In this example, both calls to `f` are equivalent:

~~~~
# fn f(f: &fn(int)) { }
# fn f(f: |int|) { }
# fn g(i: int) { }

f(|j| g(j));
@@ -2740,7 +2740,7 @@ do f |j| {
In this example, both calls to the (binary) function `k` are equivalent:

~~~~
# fn k(x:int, f: &fn(int)) { }
# fn k(x:int, f: |int|) { }
# fn l(i: int) { }

k(3, |j| l(j));
@@ -3195,7 +3195,7 @@ fn add(x: int, y: int) -> int {

let mut x = add(5,7);

type Binop<'self> = &'self fn(int,int) -> int;
type Binop<'self> = 'self |int,int| -> int;
let bo: Binop = add;
x = bo(5,7);
~~~~
@@ -3242,7 +3242,7 @@ and the cast expression in `main`.
Within the body of an item that has type parameter declarations, the names of its type parameters are types:

~~~~
fn map<A: Clone, B: Clone>(f: &fn(A) -> B, xs: &[A]) -> ~[B] {
fn map<A: Clone, B: Clone>(f: |A| -> B, xs: &[A]) -> ~[B] {
if xs.len() == 0 {
return ~[];
}
Loading