---

yaml
---
r: 90095
b: refs/heads/master
c: 7dcc066
h: refs/heads/master
i:
  90093: 02be4e8
  90091: 4dccde9
  90087: 7fa8e6d
  90079: 373c8e6
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: fb52956fe40c2407bed467514fb8be44ce9ce194
+refs/heads/master: 7dcc066bd2e83513a3d55df38109ddcfada67497
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
 refs/heads/try: b160761e35efcd1207112b3b782c06633cf441a8

trunk/configure

@@ -878,13 +878,6 @@ do
         # Try to have LLVM pull in as few dependencies as possible (#9397)
         LLVM_OPTS="$LLVM_OPTS --disable-zlib --disable-libffi"
 
-        # pthreads works badly on mingw-w64 systems: #8996
-        case "$CFG_BUILD" in
-            (*w64-mingw32)
-            LLVM_OPTS="$LLVM_OPTS --disable-pthreads"
-            ;;
-        esac
-
         case "$CFG_C_COMPILER" in
             ("ccache clang")
             LLVM_CXX_32="ccache clang++ -m32 -Qunused-arguments"

trunk/doc/po/ja/rust.md.po

@@ -1817,10 +1817,10 @@ msgstr ""
 #, no-wrap
 msgid ""
 "~~~~ {.xfail-test}\n"
-"fn iter<T>(seq: &[T], f: |T|) {\n"
+"fn iter<T>(seq: &[T], f: &fn(T)) {\n"
 "    for elt in seq.iter() { f(elt); }\n"
 "}\n"
-"fn map<T, U>(seq: &[T], f: |T| -> U) -> ~[U] {\n"
+"fn map<T, U>(seq: &[T], f: &fn(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, |T|);\n"
+"   fn iter(&self, &fn(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 "
-"```|| { }``` expression), the lambda expression captures its environment "
+"```&fn() { }``` 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: |int|) {\n"
+"fn ten_times(f: &fn(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: |int|) { } # fn g(i: int) { }"
+msgid "~~~~ # fn f(f: &fn(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: |int|) { } # fn l(i: int) { }"
+msgid "~~~~ # fn k(x:int, f: &fn(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 |int,int| -> int; let bo: Binop = add; x = "
+"type Binop<'self> = &'self fn(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: |A| -> B, xs: &[A]) -> ~[B] {\n"
+"fn map<A: Clone, B: Clone>(f: &fn(A) -> B, xs: &[A]) -> ~[B] {\n"
 "    if xs.len() == 0 {\n"
 "       return ~[];\n"
 "    }\n"

trunk/doc/po/ja/tutorial.md.po

@@ -3340,10 +3340,10 @@ msgstr ""
 
 #. type: Plain text
 #: doc/tutorial.md:1434
-msgid "~~~~ fn call_closure_with_ten(b: |int|) { b(10); }"
+msgid "~~~~ fn call_closure_with_ten(b: &fn(int)) { b(10); }"
 msgstr ""
 "~~~~\n"
-"fn call_closure_with_ten(b: |int|) { b(10); }"
+"fn call_closure_with_ten(b: &fn(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 `||` and can directly access local "
+"called a _stack closure_, has type `&fn` 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 `||`. Thus, when writing a higher-order function that only calls "
+"expect a `&fn()`. 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 `||`. That way, callers may "
+"always declare the type of that argument as `&fn()`. 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: ||) { f(); f(); } let closure = || { \"I'm a "
+"~~~~ fn call_twice(f: &fn()) { 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: ||) { f(); f(); }\n"
+"fn call_twice(f: &fn()) { 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: |v: &int|) {\n"
+"fn each(v: &[int], op: &fn(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: |v: &int|) { }\n"
+"# fn each(v: &[int], op: &fn(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: |v: &int|) { }\n"
+"# fn each(v: &[int], op: &fn(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: |v: &T| -> U) -> ~[U] {\n"
+"fn map<T, U>(vector: &[T], function: &fn(v: &T) -> U) -> ~[U] {\n"
 "    let mut accumulator = ~[];\n"
 "    for element in vector.iter() {\n"
 "        accumulator.push(function(element));\n"

trunk/doc/po/rust.md.pot

@@ -1817,10 +1817,10 @@ msgstr ""
 #, no-wrap
 msgid ""
 "~~~~ {.xfail-test}\n"
-"fn iter<T>(seq: &[T], f: |T|) {\n"
+"fn iter<T>(seq: &[T], f: &fn(T)) {\n"
 "    for elt in seq.iter() { f(elt); }\n"
 "}\n"
-"fn map<T, U>(seq: &[T], f: |T| -> U) -> ~[U] {\n"
+"fn map<T, U>(seq: &[T], f: &fn(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, |T|);\n"
+"   fn iter(&self, &fn(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 "
-"```|| { }``` expression), the lambda expression captures its environment "
+"```&fn() { }``` 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: |int|) {\n"
+"fn ten_times(f: &fn(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: |int|) { } # fn g(i: int) { }"
+msgid "~~~~ # fn f(f: &fn(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: |int|) { } # fn l(i: int) { }"
+msgid "~~~~ # fn k(x:int, f: &fn(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 |int,int| -> int; let bo: Binop = add; x = "
+"type Binop<'self> = &'self fn(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: |A| -> B, xs: &[A]) -> ~[B] {\n"
+"fn map<A: Clone, B: Clone>(f: &fn(A) -> B, xs: &[A]) -> ~[B] {\n"
 "    if xs.len() == 0 {\n"
 "       return ~[];\n"
 "    }\n"

trunk/doc/po/tutorial.md.pot

@@ -2558,7 +2558,7 @@ msgstr ""
 
 #. type: Plain text
 #: doc/tutorial.md:1434
-msgid "~~~~ fn call_closure_with_ten(b: |int|) { b(10); }"
+msgid "~~~~ fn call_closure_with_ten(b: &fn(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 `||` and can directly access local "
+"called a _stack closure_, has type `&fn` 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 `||`. Thus, when writing a higher-order function that only calls "
+"expect a `&fn()`. 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 `||`. That way, callers may "
+"always declare the type of that argument as `&fn()`. That way, callers may "
 "pass any kind of closure."
 msgstr ""
 
 #. type: Plain text
 #: doc/tutorial.md:1527
 msgid ""
-"~~~~ fn call_twice(f: ||) { f(); f(); } let closure = || { \"I'm a "
+"~~~~ fn call_twice(f: &fn()) { 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: |v: &int|) {\n"
+"fn each(v: &[int], op: &fn(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: |v: &int|) { }\n"
+"# fn each(v: &[int], op: &fn(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: |v: &int|) { }\n"
+"# fn each(v: &[int], op: &fn(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: |v: &T| -> U) -> ~[U] {\n"
+"fn map<T, U>(vector: &[T], function: &fn(v: &T) -> U) -> ~[U] {\n"
 "    let mut accumulator = ~[];\n"
 "    for element in vector.iter() {\n"
 "        accumulator.push(function(element));\n"