闭包是内在的灵活性，并会做哪些需要的功能，使撤销工作无需注释。这允许捕捉灵活适应使用的情况，有时会移动，有时借用。闭包可以捕捉变量：
&T
&mut T
T
它们优先通过引用捕获变量并仅在需要时使用。
fn main() {
let color = "green";
// A closure to print `color` which immediately borrows (`&`)
// `color` and stores the borrow and closure in the `print`
// variable. It will remain borrowed until `print` goes out of
// scope. `println!` only requires `by reference` so it doesn't
// impose anything more restrictive.
let print = || println!("`color`: {}", color);
// Call the closure using the borrow.
print();
print();
let mut count = 0;
// A closure to increment `count` could take either `&mut count`
// or `count` but `&mut count` is less restrictive so it takes
// that. Immediately borrows `count`.
//
// A `mut` is required on `inc` because a `&mut` is stored inside.
// Thus, calling the closure mutates the closure which requires
// a `mut`.
let mut inc = || {
count += 1;
println!("`count`: {}", count);
};
// Call the closure.
inc();
inc();
//let reborrow = &mut count;
// ^ TODO: try uncommenting this line.
// A non-copy type.
let movable = Box::new(3);
// `drop` requires `T` so this must take by value. A copy type
// would copy into the closure leaving the original untouched.
// A non-copy must move and so `movable` immediately moves into
// the closure.
let consume = || {
println!("`movable`: {:?}", movable);
drop(movable);
};
// `consume` consumes the variable so this can only be called once.
consume();
//consume();
// ^ TODO: Try uncommenting this line.
}
