Rust: What is the difference between fn and Fn?

fn (lowercase) is a function pointer type — it refers to a specific function in memory. Fn (uppercase) is a trait — it represents anything callable, including closures and function pointers.

fn — function pointer:

• A concrete type that points to a function.
• Cannot capture environment variables.
• Has a known, fixed address at compile/link time.
• Used as a type annotation: fn(i32) -> i32.

1fn add(a: i32, b: i32) -> i32 {
2    a + b
3}
4
5let f: fn(i32, i32) -> i32 = add;  // Function pointer
6println!("{}", f(2, 3));  // 5
7
8// Passing function pointer as argument
9fn apply(f: fn(i32, i32) -> i32, a: i32, b: i32) -> i32 {
10    f(a, b)
11}
12println!("{}", apply(add, 10, 20));  // 30

Fn — closure trait:

• A trait implemented by closures and functions.
• Three variants: Fn (immutable capture), FnMut (mutable capture), FnOnce (consume capture).
• Can capture environment variables from surrounding scope.
• Generic — works with any callable.

1let multiplier = 3;
2
3// Closure captures `multiplier` from environment
4let multiply = |x| x * multiplier;  // implements Fn
5println!("{}", multiply(5));  // 15
6
7// fn CANNOT do this:
8// fn bad(x: i32) -> i32 { x * multiplier }  // Error!
9
10// Fn trait as generic parameter
11fn apply_twice<F: Fn(i32) -> i32>(f: F, x: i32) -> i32 {
12    f(f(x))
13}
14println!("{}", apply_twice(|x| x + 1, 5));  // 7

When to use fn:

• When you need a concrete function pointer (e.g., in FFI callbacks).
• When you know exactly which function will be called.
• For performance — no dynamic dispatch overhead.

When to use Fn/FnMut/FnOnce:

• When you need closures that capture environment.
• For generic code that accepts any callable (iterators, callbacks).
• When you want flexibility in what gets passed.

Common mistakes:

• Confusing fn type with Fn trait — fn is a type, Fn is a trait.
• Forgetting that Fn is automatically implemented by fn pointers (a fn pointer satisfies Fn).
• Using fn when you need closure captures — the compiler will reject it.