---

yaml
---
r: 169335
b: refs/heads/master
c: ca17d08
h: refs/heads/master
i:
  169333: 94781fe
  169331: 1802d35
  169327: 85309da
v: v3

Author: Jorge Aparicio

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 8d0d7521d65eff290183e9d19858c6ca8779fe01
+refs/heads/master: ca17d0812686012307e364a4dce7b84af6886f91
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 5b3cd3900ceda838f5798c30ab96ceb41f962534
 refs/heads/try: 5204084bd2e46af7cc6e0147430e44dd0d657bbb

trunk/src/test/auxiliary/cci_impl_lib.rs

@@ -11,12 +11,12 @@
 #![crate_name="cci_impl_lib"]
 
 pub trait uint_helpers {
-    fn to(&self, v: uint, f: |uint|);
+    fn to<F>(&self, v: uint, f: F) where F: FnMut(uint);
 }
 
 impl uint_helpers for uint {
     #[inline]
-    fn to(&self, v: uint, f: |uint|) {
+    fn to<F>(&self, v: uint, mut f: F) where F: FnMut(uint) {
         let mut i = *self;
         while i < v {
             f(i);

trunk/src/test/auxiliary/cci_iter_lib.rs

@@ -11,7 +11,7 @@
 #![crate_name="cci_iter_lib"]
 
 #[inline]
-pub fn iter<T>(v: &[T], f: |&T|) {
+pub fn iter<T, F>(v: &[T], mut f: F) where F: FnMut(&T) {
     let mut i = 0u;
     let n = v.len();
     while i < n {

trunk/src/test/auxiliary/cci_no_inline_lib.rs

@@ -12,7 +12,7 @@
 
 
 // same as cci_iter_lib, more-or-less, but not marked inline
-pub fn iter(v: Vec<uint> , f: |uint|) {
+pub fn iter<F>(v: Vec<uint> , mut f: F) where F: FnMut(uint) {
     let mut i = 0u;
     let n = v.len();
     while i < n {

trunk/src/test/auxiliary/iss.rs

@@ -12,12 +12,12 @@
 
 // part of issue-6919.rs
 
-pub struct C<'a> {
-    pub k: ||: 'a,
+pub struct C<K> where K: FnOnce() {
+    pub k: K,
 }
 
 fn no_op() { }
-pub const D : C<'static> = C {
-    k: no_op
+pub const D : C<fn()> = C {
+    k: no_op as fn()
 };
 

trunk/src/test/auxiliary/issue13507.rs

@@ -21,7 +21,6 @@ pub mod testtypes {
         ids.push(TypeId::of::<FooEnum>());
         ids.push(TypeId::of::<FooUniq>());
         ids.push(TypeId::of::<FooPtr>());
-        ids.push(TypeId::of::<FooClosure>());
         ids.push(TypeId::of::<&'static FooTrait>());
         ids.push(TypeId::of::<FooStruct>());
         ids.push(TypeId::of::<FooTuple>());
@@ -68,9 +67,6 @@ pub mod testtypes {
 
     // Skipping ty_bare_fn (how do you get a bare function type, rather than proc or closure?)
 
-    // Tests ty_closure (does not test all types of closures)
-    pub type FooClosure = |arg: u8|: 'static -> u8;
-
     // Tests ty_trait
     pub trait FooTrait {
         fn foo_method(&self) -> uint;

trunk/src/test/auxiliary/logging_right_crate.rs

@@ -13,5 +13,5 @@
 
 pub fn foo<T>() {
     fn death() -> int { panic!() }
-    debug!("{}", (||{ death() })());
+    debug!("{}", (|&:|{ death() })());
 }

trunk/src/test/run-pass/argument-passing.rs

@@ -20,7 +20,7 @@ fn f1(a: &mut X, b: &mut int, c: int) -> int {
     return r;
 }
 
-fn f2(a: int, f: |int|) -> int { f(1); return a; }
+fn f2<F>(a: int, f: F) -> int where F: FnOnce(int) { f(1); return a; }
 
 pub fn main() {
     let mut a = X {x: 1};

trunk/src/test/run-pass/autobind.rs

@@ -11,11 +11,11 @@
 
 fn f<T>(x: Vec<T>) -> T { return x.into_iter().next().unwrap(); }
 
-fn g(act: |Vec<int> | -> int) -> int { return act(vec!(1, 2, 3)); }
+fn g<F>(act: F) -> int where F: FnOnce(Vec<int>) -> int { return act(vec!(1, 2, 3)); }
 
 pub fn main() {
     assert_eq!(g(f), 1);
-    let f1: |Vec<String>| -> String = f;
+    let f1 = f;
     assert_eq!(f1(vec!["x".to_string(), "y".to_string(), "z".to_string()]),
                "x".to_string());
 }

trunk/src/test/run-pass/block-arg-call-as.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn asBlock(f: || -> uint) -> uint {
+fn asBlock<F>(f: F) -> uint where F: FnOnce() -> uint {
    return f();
 }
 

trunk/src/test/run-pass/block-explicit-types.rs

@@ -9,6 +9,6 @@
 // except according to those terms.
 
 pub fn main() {
-    fn as_buf<T>(s: String, f: |String| -> T) -> T { f(s) }
+    fn as_buf<T, F>(s: String, f: F) -> T where F: FnOnce(String) -> T { f(s) }
     as_buf("foo".to_string(), |foo: String| -> () println!("{}", foo) );
 }

trunk/src/test/run-pass/block-fn-coerce.rs

@@ -8,10 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn force(f: || -> int) -> int { return f(); }
+fn force<F>(f: F) -> int where F: FnOnce() -> int { return f(); }
+
 pub fn main() {
     fn f() -> int { return 7; }
     assert_eq!(force(f), 7);
-    let g = {||force(f)};
+    let g = {|&:|force(f)};
     assert_eq!(g(), 7);
 }

trunk/src/test/run-pass/block-iter-1.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn iter_vec<T>(v: Vec<T> , f: |&T|) { for x in v.iter() { f(x); } }
+fn iter_vec<T, F>(v: Vec<T> , mut f: F) where F: FnMut(&T) { for x in v.iter() { f(x); } }
 
 pub fn main() {
     let v = vec!(1i, 2, 3, 4, 5, 6, 7);

trunk/src/test/run-pass/block-iter-2.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn iter_vec<T>(v: Vec<T> , f: |&T|) { for x in v.iter() { f(x); } }
+fn iter_vec<T, F>(v: Vec<T>, mut f: F) where F: FnMut(&T) { for x in v.iter() { f(x); } }
 
 pub fn main() {
     let v = vec!(1i, 2, 3, 4, 5);

trunk/src/test/run-pass/borrowck-borrow-from-expr-block.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 
-fn borrow(x: &int, f: |x: &int|) {
+fn borrow<F>(x: &int, f: F) where F: FnOnce(&int) {
     f(x)
 }
 

trunk/src/test/run-pass/borrowck-closures-two-imm.rs

@@ -15,10 +15,10 @@
 // the closures are in scope. Issue #6801.
 
 fn a() -> int {
-    let mut x = 3;
+    let mut x = 3i;
     x += 1;
-    let c1 = || x * 4;
-    let c2 = || x * 5;
+    let c1 = |&:| x * 4;
+    let c2 = |&:| x * 5;
     c1() * c2() * x
 }
 
@@ -29,16 +29,16 @@ fn get(x: &int) -> int {
 fn b() -> int {
     let mut x = 3;
     x += 1;
-    let c1 = || get(&x);
-    let c2 = || get(&x);
+    let c1 = |&:| get(&x);
+    let c2 = |&:| get(&x);
     c1() * c2() * x
 }
 
 fn c() -> int {
     let mut x = 3;
     x += 1;
-    let c1 = || x * 5;
-    let c2 = || get(&x);
+    let c1 = |&:| x * 5;
+    let c2 = |&:| get(&x);
     c1() * c2() * x
 }
 

trunk/src/test/run-pass/borrowck-mut-uniq.rs

@@ -21,7 +21,7 @@ fn add_int(x: &mut Ints, v: int) {
     swap(&mut values, &mut x.values);
 }
 
-fn iter_ints(x: &Ints, f: |x: &int| -> bool) -> bool {
+fn iter_ints<F>(x: &Ints, mut f: F) -> bool where F: FnMut(&int) -> bool {
     let l = x.values.len();
     range(0u, l).all(|i| f(&x.values[i]))
 }

trunk/src/test/run-pass/call-closure-from-overloaded-op.rs

@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// ignore-test FIXME(japaric) this ICEs
 
 fn foo() -> int { 22 }
 

trunk/src/test/run-pass/capture-clauses-boxed-closures.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn each<T>(x: &[T], f: |&T|) {
+fn each<T, F>(x: &[T], mut f: F) where F: FnMut(&T) {
     for val in x.iter() {
         f(val)
     }

trunk/src/test/run-pass/closure-inference.rs

@@ -11,9 +11,9 @@
 
 fn foo(i: int) -> int { i + 1 }
 
-fn apply<A>(f: |A| -> A, v: A) -> A { f(v) }
+fn apply<A, F>(f: F, v: A) -> A where F: FnOnce(A) -> A { f(v) }
 
 pub fn main() {
-    let f = {|i| foo(i)};
+    let f = {|: i| foo(i)};
     assert_eq!(apply(f, 2), 3);
 }

trunk/src/test/run-pass/closure-inference2.rs

@@ -11,7 +11,7 @@
 // Test a rather underspecified example:
 
 pub fn main() {
-    let f = {|i| i};
+    let f = {|&: i| i};
     assert_eq!(f(2i), 2i);
     assert_eq!(f(5i), 5i);
 }

trunk/src/test/run-pass/closure-reform.rs

@@ -22,25 +22,14 @@ fn call_it<F>(f: F)
     println!("{}", f("Fred".to_string()))
 }
 
-fn call_a_thunk(f: ||) {
+fn call_a_thunk<F>(f: F) where F: FnOnce() {
     f();
 }
 
-fn call_this(f: |&str|:Send) {
+fn call_this<F>(f: F) where F: FnOnce(&str) + Send {
     f("Hello!");
 }
 
-fn call_that(f: <'a>|&'a int, &'a int| -> int) {
-    let (ten, forty_two) = (10, 42);
-    println!("Your lucky number is {}", f(&ten, &forty_two));
-}
-
-fn call_cramped(f:||->uint,g:<'a>||->&'a uint) {
-    let number = f();
-    let other_number = *g();
-    println!("Ticket {} wins an all-expenses-paid trip to Mountain View", number + other_number);
-}
-
 fn call_bare(f: fn(&str)) {
     f("Hello world!")
 }
@@ -71,16 +60,6 @@ pub fn main() {
 
     call_this(|s| println!("{}", s));
 
-    call_that(|x, y| *x + *y);
-
-    let z = 100;
-    call_that(|x, y| *x + *y - z);
-
-    call_cramped(|| 1, || unsafe {
-        static a: uint = 100;
-        mem::transmute(&a)
-    });
-
     // External functions
 
     call_bare(println);