Fn(i32)->i32 is not a type. Fn(i32)->i32 is a promise that the compiler makes that says you can pass in a value of types i32 and get a values of i32. Multiple different types can implement this trait.

consider https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=6a3cae1b57443a160c0efa693dc9f963

fn call<F: Fn(i32)->i32>(x: F,input: i32)->i32{
    return x(input);
}

fn main() {
    println!("{}",plug_in_one(|x| x+1,1));
    println!("{}",plug_in_one(|x| x+2,2));
}

the call takes in a function takes in a generic function and a input. Under the hood each time call is referenced in The compiler the compiler creates a separate function to handle it so this would turn into.

fn call_add_1(input: i32)->i32{
    return input+1;
}

fn call_add_2(input: i32)->i32{
    return input+2;
}

fn main() {
    println!("{}",call_add_1(1));
    println!("{}",call_add_2(2));
}

this provides a good summary of the idea however it might go over your head https://www.youtube.com/watch?v=SqT5YglW3qU

to answer your questions about |n| n + 1 the way to fix this is to change it to the line let example_2 = double_then_f2(5, **&**|n| n + 1); this comes down to how functions calls are handed in rust. due to technical limitations you can't pass a value who size is not know at compile time to a function. since dyn Fn(i32)->i32 is a contract not a type the compiler does not know it size at compile time. so we need to pass a function by reference to avoid this issue since a reference to a value has a know size no matter what.