When does a closure implement Fn, FnMut and FnOnce?

rust closures
Denilson Amorim picture Denilson Amorim · May 11, 2015 · Viewed 22.2k times · Source

What are the specific conditions for a closure to implement the Fn, FnMut and FnOnce traits?

That is:

  • When does a closure not implement the FnOnce trait?
  • When does a closure not implement the FnMut trait?
  • When does a closure not implement the Fn trait?

For instance, mutating the state of the closure on it's body makes the compiler not implement Fn on it.

Answer

huon picture huon · May 14, 2015

The traits each represent more and more restrictive properties about closures/functions, indicated by the signatures of their call_... method, and particularly the type of self:

  • FnOnce (self) are functions that can be called once
  • FnMut (&mut self) are functions that can be called if they have &mut access to their environment
  • Fn (&self) are functions that can be called if they only have & access to their environment

A closure |...| ... will automatically implement as many of those as it can.

  • All closures implement FnOnce: a closure that can't be called once doesn't deserve the name. Note that if a closure only implements FnOnce, it can be called only once.
  • Closures that don't move out of their captures implement FnMut, allowing them to be called more than once (if there is unaliased access to the function object).
  • Closures that don't need unique/mutable access to their captures implement Fn, allowing them to be called essentially everywhere.

These restrictions follow directly from the type of self and the "desugaring" of closures into structs; described in my blog post Finding Closure in Rust.

For information on closures, see Closures: Anonymous Functions that Can Capture Their Environment in The Rust Programming Language.

Related questions

How do I store a closure in a struct in Rust?

Before Rust 1.0, I could write a structure using this obsolete closure syntax: struct Foo { pub foo: |usize| -> usize, } Now I can do something like: struct Foo<F: FnMut(usize) -> usize> { pub foo: F, } But …

Read More
Is it possible to make a recursive closure in Rust?

This is a very simple example, but how would I do something similar to: let fact = |x: u32| { match x { 0 => 1, _ => x * fact(x - 1), } }; I know that this specific example can be easily done with iteration, but I'm …

Read More
Convert a String to int in Rust?

Note: this question contains deprecated pre-1.0 code! The answer is correct, though. To convert a str to an int in Rust, I can do this: let my_int = from_str::<int>(my_str); The only way I know …

Read More