Baffled By The Borrow Checker

[parasyte]

@Bender-Rodriguez

Why does this resultant closure type only to FnOnce and not FnMut?

The compiler determines which Fn* trait a closure implements by analyzing how the closure body uses the captures in its environment. If the closure moves and drops any of its captures, then it can only implement FnOnce. If it only uses its captures as &mut T, then it can implement FnMut. If it only uses its captures as &T, then it can implement Fn. ^[1]

Rust Playground

There is some real subtlety, here! move closures do not control which trait is implemented. Only how the captures are used influences it. This point came up a short while ago in another thread:

Changing member structure with lifetime

The compiler does not really know how many times a function will be called. FnOnce is defined in terms of move semantics: FnOnce::call_once takes self by value. The closure owns all of its captures and will drop everything after it runs. Therefore it would be unsound to call the function more than once. This property means that FnOnce can be called at most once. Taking self by value is the mechanism for enforcing the property. Not speaking for quinedot, but a closure that owns its captures is…

---

@Bender-Rodriguez

The compiler tells us, helpfully, that "closure is FnOnce because it moves the variable _client out of its environment - but doesn't the previous version (that compiles) do the same thing?

In short, no! As explained by others, Option::take() only moves the inner T out of the Option. The Option itself doesn't get dropped. If it did, that would make the closure implement FnOnce instead of FnMut. Just like the demonstration closures in the playground.

---

1. Note that the closure does not have to use all of its captures in these ways. The trait that gets implemented (by the compiler) is selected by the capture use that has the most restriction. Even if most captures are used by &T, just one use by &mut T of any capture will make the closure FnMut. If that makes sense... ↩︎