Rust: What is the difference between fn and Fn?

fn is a function pointer type — a concrete, zero-sized type pointing to a function. Fn is a trait — an abstraction implemented by closures, functions, and anything callable.

fn — concrete function pointer:

• Stores the address of a function in memory.
• Cannot capture variables from surrounding scope.
• Used as a type: fn(i32, i32) -> i32.
• Always available — any named function can be cast to fn.

1fn multiply(a: i32, b: i32) -> i32 {
2    a * b
3}
4
5let op: fn(i32, i32) -> i32 = multiply;
6println!("{}", op(3, 4));  // 12
7
8fn execute(f: fn(i32, i32) -> i32, x: i32, y: i32) -> i32 {
9    f(x, y)
10}
11println!("{}", execute(multiply, 5, 6));  // 30

Fn — callable trait:

• A trait with methods: call(&self, args) -> Output.
• Three variants: Fn (shared ref capture), FnMut (mutable ref capture), FnOnce (consume capture).
• Can capture environment variables.
• Generic — accepts any type implementing the trait.

1let base = 100;
2let add_base = |x| x + base;  // Captures `base` — implements Fn
3println!("{}", add_base(50));  // 150
4
5// Generic function accepting Fn trait
6fn apply<F: Fn(i32) -> i32>(f: F, value: i32) -> i32 {
7    f(value)
8}
9
10println!("{}", apply(|x| x * 2, 21));   // 42
11println!("{}", apply(add_base, 50));     // 150
12println!("{}", apply(multiply_three, 3)); // 9 (if defined)

When to use fn:

• FFI callbacks, function tables, dispatch tables.
• When you don't need captures and want zero overhead.
• Type annotations in struct fields.

When to use Fn/FnMut/FnOnce:

• Iterator adapters, sorting, filtering.
• Callbacks that need environment access.
• Generic APIs accepting any callable.

Common mistakes:

• Using fn when you need captures — closures won't coerce.
• Confusing fn (type) with Fn (trait).
• Forgetting FnMut/FnOnce for closures that modify or consume captured data.