Rust: What is the difference between fn and Fn?

fn (lowercase) is a function pointer — a concrete type representing a specific function address. Fn (uppercase) is a trait — an abstraction that any callable (closures, functions, function pointers) can implement.

fn — function pointer type:

• A concrete, Sized type that holds a pointer to a function.
• Cannot capture variables from the enclosing scope.
• Can be stored in structs, arrays, and passed directly.
• Used as a type annotation: fn(i32) -> i32.

1fn square(x: i32) -> i32 {
2    x * x
3}
4
5let f: fn(i32) -> i32 = square;
6println!("{}", f(5));  // 25
7
8// Can be stored in collections
9let operations: Vec<fn(i32) -> i32> = vec![square, |x| x + 1];

Fn — closure trait:

• A trait with three sub-traits: Fn, FnMut, FnOnce.
• Implemented by closures that capture by reference (Fn), mutable reference (FnMut), or by value (FnOnce).
• Generic — allows writing functions that accept any callable.
• Cannot be stored directly (use Box<dyn Fn(i32) -> i32> for type-erased storage).

1let name = "World";
2let greet = || format!("Hello, {}!", name);  // implements Fn
3println!("{}", greet());  // Hello, World!
4
5fn do_twice<F: Fn(i32) -> i32>(f: F, x: i32) -> i32 {
6    f(f(x))
7}
8println!("{}", do_twice(|x| x + 1, 5));  // 7
9
10// FnMut — closure that modifies captured state
11let mut count = 0;
12let mut counter = || { count += 1; count };  // implements FnMut
13println!("{}", counter());  // 1
14println!("{}", counter());  // 2

When to use fn:

• FFI callbacks or platform APIs expecting function pointers.
• When you need a concrete, known function without captures.
• Performance-critical code avoiding dynamic dispatch.

When to use Fn/FnMut/FnOnce:

• Generic callback parameters (.map(), .filter(), .sort_by()).
• When closures need to capture environment.
• Flexible APIs that accept any callable.

Common mistakes:

• Confusing fn (type) with Fn (trait) — fn is lowercase, Fn is uppercase.
• Trying to pass a closure where fn is expected — closures don't coerce to fn pointers if they capture variables.
• Using Fn instead of FnMut when the closure needs to modify captured state.