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 parse_int(s: &str) -> Result<i32, std::num::ParseIntError> {
2    s.parse()
3}
4
5let parser: fn(&str) -> Result<i32, _> = parse_int;
6println!("{:?}", parser("42"));  // Ok(42)
7
8// Store in struct
9struct Rule {
10    name: String,
11    check: fn(&str) -> bool,
12}
13
14let rules = vec![
15    Rule { name: "non-empty".into(), check: |s| !s.is_empty() },
16    Rule { name: "numeric".into(), check: |s| s.chars().all(|c| c.is_numeric()) },
17];

Fn — closure trait:

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

1let min_len = 3;
2let validator = |s: &str| s.len() >= min_len;  // Fn
3
4fn validate_all<F: Fn(&str) -> bool>(items: &[&str], rule: F) -> Vec<&str> {
5    items.iter().filter(|&&s| rule(s)).copied().collect()
6}
7
8let words = vec!["hi", "hello", "hey", "world"];
9let long_words = validate_all(&words, validator);
10println!("{:?}", long_words);  // ["hello", "world"]

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.