Allow coercing non-capturing closures to function pointers

[archshift]

In C++, you are able to pass a non-capturing lambda as a function pointer, as, for example, a function argument:

void foo(void (*foobar)(void)) {
    // impl
}
void bar() {
    foo([]() { /* do something */ });
}

It would be incredibly convenient for rust to be able to do the same:

fn foo(foobar: fn()) {
    // impl
}
fn bar() {
    foo(|| { /* do something */ });
}

A use case would be a static (const) array of function pointers, where dynamic dispatch is not necessary.
Example in current rust (this is a compilable example):

extern {
  static mut b: u32;
  static n: usize;
}

const a: [&'static Fn(); 4] = [
  &|| unsafe { b = 4 },
  &|| unsafe { b = 2 },
  &|| unsafe { b = 3 },
  &|| unsafe { b = 1 },
];

pub fn main() {
  if n < 4 {
    a[n]();
  }
}

This obviously relies upon dynamic dispatch to a level that rust is unable to optimize away. Ideally it would be possible to use a table of fn()s instead of &'static Fn() and rust would be able to coerce the closures into function pointers because nothing needs to be captured.

Another, possibly more widely-applicable scenario is simply being able to pass a closure into a C function that takes a callback.

See previous discussion at rust-lang/rust#32449.

[archshift]

Created RFC at #1558.

[JoeyAcc]

What's the status on this? I ask because on the one hand this issue is closed, yet on the other the feature is still gated behind feature(closure_to_fn_coercion).

[eddyb]

@JoeyAcc You want to look at the tracking issue (rust-lang/rust#39817).