Rust: What is the difference between fn and Fn?

fn is a function pointer type — concrete, no captures, zero-cost. Fn is a trait — abstraction, captures, generic. fn = type, Fn = trait.

fn — function pointer:

• Type: fn(Args) -> Output.
• Points to a function in memory.
• Cannot capture environment.
• Zero-cost, statically dispatched.

1fn to_uppercase(s: &str) -> String {
2    s.to_uppercase()
3}
4
5let transform: fn(&str) -> String = to_uppercase;
6println!("{}", transform("hello"));  // HELLO
7
8fn apply_transforms(text: &str, transforms: &[fn(&str) -> String]) -> String {
9    transforms.iter().fold(text.to_string(), |acc, t| t(&acc))
10}

Fn — closure trait:

• A trait implemented by all callables.
• Three variants: Fn, FnMut, FnOnce.
• Can capture environment.
• Generic — accepts any implementing type.

1let offset = 10;
2let add_offset = |x: i32| x + offset;  // Fn
3println!("{}", add_offset(5));  // 15
4
5fn pipeline<F: Fn(i32) -> i32, G: Fn(i32) -> i32>(
6    value: i32,
7    f: F,
8    g: G,
9) -> i32 {
10    g(f(value))
11}
12
13let result = pipeline(5, |x| x * 2, |x| x + 1);
14println!("{}", result);  // 11

When to use fn:

• FFI callbacks, function tables.
• When captures aren't needed.
• Zero-overhead function passing.

When to use Fn/FnMut/FnOnce:

• Closures with environment access.
• Generic callable parameters.
• Iterator adapters.

Common mistakes:

• Passing closures to fn parameters (captures prevent coercion).
• Confusing fn (type) with Fn (trait).
• Using Fn instead of FnMut for closures modifying captured data.