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 over callables, supports captures, generic. fn is a type; Fn is a trait.

fn — function pointer:

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

1fn negate(x: i32) -> i32 { -x }
2
3let f: fn(i32) -> i32 = negate;
4println!("{}", f(5));  // -5
5
6// In a struct
7struct MathOp {
8    name: String,
9    func: fn(f64) -> f64,
10}
11
12let ops = vec![
13    MathOp { name: "sqrt".into(), func: f64::sqrt },
14    MathOp { name: "abs".into(), func: f64::abs },
15];

Fn — closure trait:

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

1let threshold = 100;
2let is_large = |x: i32| x > threshold;  // Fn
3println!("{}", is_large(50));   // false
4println!("{}", is_large(150));  // true
5
6fn filter<F: Fn(&i32) -> bool>(items: &[i32], predicate: F) -> Vec<&i32> {
7    items.iter().filter(|x| predicate(x)).collect()
8}
9
10let data = vec![10, 50, 150, 200, 75];
11let large = filter(&data, &is_large);
12println!("{:?}", large);  // [150, 200]

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.