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 is_even(x: i32) -> bool { x % 2 == 0 }
2fn is_positive(x: i32) -> bool { x > 0 }
3
4let predicates: Vec<fn(i32) -> bool> = vec![is_even, is_positive];
5let numbers = vec![-3, -2, 0, 1, 2, 3];
6
7for pred in &predicates {
8    let matches: Vec<_> = numbers.iter().filter(|&&x| pred(x)).collect();
9    println!("{:?} -> {:?}", pred, matches);
10}

Fn — closure trait:

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

1let base = 10;
2let add_base = |x| x + base;  // Fn
3println!("{}", add_base(5));  // 15
4
5fn transform<F: Fn(i32) -> i32>(items: Vec<i32>, f: F) -> Vec<i32> {
6    items.into_iter().map(f).collect()
7}
8
9let result = transform(vec![1, 2, 3], |x| x * x);
10println!("{:?}", result);  // [1, 4, 9]

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.