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 — concrete function pointer:

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

1fn square(x: f64) -> f64 { x * x }
2
3let op: fn(f64) -> f64 = square;
4println!("{}", op(4.0));  // 16.0
5
6fn apply_all(fns: &[fn(f64) -> f64], x: f64) -> Vec<f64> {
7    fns.iter().map(|f| f(x)).collect()
8}
9
10let results = apply_all(&[f64::sqrt, f64::abs, square], 9.0);
11println!("{:?}", results);  // [3.0, 9.0, 81.0]

Fn — closure trait:

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

1let name = "Rust";
2let greet = || format!("Hello, {}!", name);  // Fn
3println!("{}", greet());  // Hello, Rust!
4
5fn bench<F: Fn(u32) -> u32>(name: &str, f: F, n: u32) {
6    let start = std::time::Instant::now();
7    for _ in 0..n { f(42); }
8    println!("{}: {:?}", name, start.elapsed());
9}
10
11bench("square", |x| x * x, 1000);
12bench("double", |x| x * 2, 1000);

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.