Rust: What is the difference between fn and Fn?

fn (lowercase) is a concrete function pointer type. Fn (uppercase) is a trait that closures and functions implement — it's an abstraction over anything callable.

fn — function pointer:

• A concrete type pointing to a function's address.
• Cannot capture environment variables.
• Zero-sized type (just a pointer).
• Used as type annotation: fn(i32) -> i32.

1fn double(x: i32) -> i32 {
2    x * 2
3}
4
5let f: fn(i32) -> i32 = double;
6println!("{}", f(5));  // 10
7
8// Function pointer in a struct
9struct Callback {
10    handler: fn(i32) -> i32,
11}
12
13let cb = Callback { handler: double };
14println!("{}", (cb.handler)(10));  // 20

Fn — closure trait:

• A trait implemented by all callables.
• Three variants: Fn (immutable capture), FnMut (mutable capture), FnOnce (consume).
• Can capture environment variables.
• Generic — allows polymorphic callable handling.

1let multiplier = 3;
2let multiply = |x| x * multiplier;  // implements Fn
3println!("{}", multiply(7));  // 21
4
5// Generic function accepting Fn
6fn map_vec<F: Fn(i32) -> i32>(vec: &[i32], f: F) -> Vec<i32> {
7    vec.iter().map(|&x| f(x)).collect()
8}
9
10let nums = vec![1, 2, 3, 4, 5];
11let doubled = map_vec(&nums, |x| x * 2);
12println!("{:?}", doubled);  // [2, 4, 6, 8, 10]

When to use fn:

• FFI callbacks, function pointers in structs.
• When captures aren't needed and zero overhead is desired.
• Static dispatch with known function.

When to use Fn/FnMut/FnOnce:

• Closures that capture environment.
• Generic callback parameters.
• Iterator adapters and functional patterns.

Common mistakes:

• Passing closures to fn parameters (won't compile if closure captures).
• Confusing fn (type) with Fn (trait).
• Not using FnMut/FnOnce when closure needs to modify captured data.