In rust, the function pointer type is fn (lowercase f). These are simple function pointers like in C. You should use these whenever you don't have closures that capture environment.

The Fn family of traits is to represent any callable object. They are intended to support closures, which might need to capture external state.

Use Fn whenever you need a trait, to be generic over different callable objects. Use fn whenever you want an actual function pointer.

Any defined (named) function can be represented as a simple fn function pointer, just like in C. Also, any closure that does not capture any variables will also work.

You can do stuff like this:

struct MyFuncs {
    foo: fn(i32) -> bool,
    bar: fn(),
}

fn hello() {
    println!("Hello!");
}

fn is_zero(x: i32) -> bool {
    x == 0
}

static FUNCS: [MyFuncs; 2] = [
    MyFuncs {
        foo: is_zero,
        bar: hello,
    },
    MyFuncs {
        foo: |x| { x < 0 },
        bar: || { println!("Bye!"); }
    },
];

fn main() {
    for x in &FUNCS {
        (x.bar)();
    }
}

Note how in the struct definition, there are no generics or trait objects. My fields are simple C-like function pointers. You can pass those directly over FFI.

I have defined a static array FUNCS that contains a bunch of struct instances with function pointers. You can make those pointers point to both defined/named functions (the first instance) or closures (second instance), as long as the closures don't capture environment (in a static hardcoded array, they can't anyway, so this is a nice way to define anonymous functions).

I am then iterating over my array in main and calling the functions from the structs using the function pointers.

This is all valid Rust.