Let's make a closure:
```{rust}
-let add_one = |&: x| { 1 + x };
+let add_one = |x| { 1 + x };
println!("The sum of 5 plus 1 is {}.", add_one(5));
```
Let's compare syntax. The two are pretty close:
```{rust}
-let add_one = |&: x: i32| -> i32 { 1 + x };
-fn add_one (x: i32) -> i32 { 1 + x }
+let add_one = |x: i32| -> i32 { 1 + x };
+fn add_one (x: i32) -> i32 { 1 + x }
```
As you may have noticed, closures infer their argument and return types, so you
fn main() {
let x: i32 = 5;
- let printer = |&:| { println!("x is: {}", x); };
+ let printer = || { println!("x is: {}", x); };
printer(); // prints "x is: 5"
}
fn main() {
let mut x: i32 = 5;
- let printer = |&:| { println!("x is: {}", x); };
+ let printer = || { println!("x is: {}", x); };
x = 6; // error: cannot assign to `x` because it is borrowed
}
}
fn main() {
- let square = |&: x: i32| { x * x };
+ let square = |x: i32| { x * x };
twice(5, square); // evaluates to 50
}
Let's break the example down, starting with `main`:
```{rust}
-let square = |&: x: i32| { x * x };
+let square = |x: i32| { x * x };
```
We've seen this before. We make a closure that takes an integer, and returns
```{rust}
# fn twice<F: Fn(i32) -> i32>(x: i32, f: F) -> i32 { f(x) + f(x) }
-# let square = |&: x: i32| { x * x };
+# let square = |x: i32| { x * x };
twice(5, square); // evaluates to 50
```
fn main() {
compose(5,
- |&: n: i32| { n + 42 },
- |&: n: i32| { n * 2 }); // evaluates to 94
+ |n: i32| { n + 42 },
+ |n: i32| { n * 2 }); // evaluates to 94
}
```