fn main() {
let mut a = String::from("a");
let closure = || {
a.push_str("b");
};
closure();
}
This won't compile:
error[E0596]: cannot borrow immutable local variable `closure` as mutable
--> src/main.rs:7:5
|
3 | let closure = || {
| ------- consider changing this to `mut closure`
...
7 | closure();
| ^^^^^^^ cannot borrow mutably
If I return a
in the closure without adding mut
, it can be compiled:
fn main() {
let mut a = String::from("a");
let closure = || {
a.push_str("b");
a
};
closure();
}
This confuses me a lot. It seems like when I call closure()
, closure
will be borrowed if something is mutable inside it. Why won't it be borrowed when I return a
?
There are 3 function traits in Rust: Fn
, FnMut
and FnOnce
. Going backward:
FnOnce
only guarantees that the value can be called once,FnMut
only guarantees that the value can be called if it is mutable,Fn
guarantees that the value can be called, multiple times, and without being mutable.A closure will automatically implement those traits, depending on what it captures and how it uses it. By default, the compiler will pick the least restrictive trait; so favor Fn
over FnMut
and FnMut
over FnOnce
.
In your second case:
let mut a = String::from("a");
let closure = || {
a.push_str("b");
a
};
This closure requires being able to return a
, which requires FnOnce
. It moves a
into the capture. If you tried to call your closure a second time, it would fail to compile. If you tried to access a
, it would fail to compile too.
This is why FnOnce
is a "last resort" implementation.
On the other hand your first case:
let mut a = String::from("a");
let closure = || {
a.push_str("b");
};
At most requires a mutable reference to a
, and therefore the capture occurs by mutable reference. Since it captures a mutable reference, the closure implements FnMut
, and therefore can only be called if it is itself mutable.
If you remove mut
, in front of a
, the compiler will signal to you it needs to borrow a
mutably.
The compiler does not require that closure
itself be declared mutably until you attempt to call it; after all you could pass it by value to a function without calling it (yourself), in which case mut
would be superfluous.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With