Rust: What is the difference between fn and Fn?

fn is a function pointer type (concrete, zero-cost). Fn is a trait (abstraction, flexible). fn is a type; Fn is a trait. Any function pointer satisfies the Fn trait.

fn — concrete function pointer:

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

1fn add(a: i32, b: i32) -> i32 { a + b }
2fn sub(a: i32, b: i32) -> i32 { a - b }
3
4let ops: Vec<fn(i32, i32) -> i32> = vec![add, sub];
5for op in ops {
6    println!("Result: {}", op(10, 3));
7}

Fn — callable trait:

• A trait implemented by closures, functions, and anything callable.
• Three sub-traits: Fn, FnMut, FnOnce.
• Can capture environment.
• Generic — accepts any type implementing the trait.

1use std::collections::HashMap;
2
3let mut cache: HashMap<String, Box<dyn Fn(i32) -> i32>> = HashMap::new();
4let base = 10;
5cache.insert("double".into(), Box::new(|x| x * 2));
6cache.insert("add_base".into(), Box::new(move |x| x + base));
7
8if let Some(f) = cache.get("double") {
9    println!("{}", f(5));  // 10
10}

When to use fn:

• FFI, static dispatch, function tables.
• When you know the exact function at compile time.
• Zero-overhead function passing.

When to use Fn/FnMut/FnOnce:

• Closures with environment captures.
• Generic callback parameters.
• Iterator adapters and functional patterns.

Common mistakes:

• Passing closures where fn is expected (captures prevent coercion).
• Confusing fn (type) with Fn (trait).
• Using Fn instead of FnMut when closure needs to modify captured data.