What is the difference between fn and Fn?

Question

Accepted Answer

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

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

```rust
fn wrap(x: i32) -> String {
    format!("[{}]", x)
}

let formatter: fn(i32) -> String = wrap;
println!("{}", formatter(42));  // [42]

// Function table
let formatters: &[fn(i32) -> String] = &[
    |x| format!("hex: {:x}", x),
    |x| format!("oct: {:o}", x),
    wrap,
];
```

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

```rust
let prefix = "LOG:";
let log_msg = |msg| format!("{} {}", prefix, msg);  // Fn
println!("{}", log_msg("started"));  // LOG: started

fn execute<F: FnOnce() -> String>(f: F) -> String {
    f()  // FnOnce: can only be called once
}

let name = String::from("Rust");
let result = execute(move || format!("Hello, {}!", name));
println!("{}", result);  // Hello, Rust!
```

**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.

Rust: What is the difference between fn and Fn?