CODEWITHSUNDEEP
rust
周汉成
周汉成

Reputation: 1445

Why does passing a closure to function which accepts a function pointer not work?

In the second edition of The Rust Programming Language (emphasis mine):

Function pointers implement all three of the closure traits (Fn, FnMut, and FnOnce), so you can always pass a function pointer as an argument for a function that expects a closure. It’s best to write functions using a generic type and one of the closure traits so your functions can accept either functions or closures.

Passing a closure to a function which accepts a function pointer as an argument doesn't compile:

fn main() {
    let a = String::from("abc");

    let x = || println!("{}", a);

    fn wrap(c: fn() -> ()) -> () {
        c()
    }

    wrap(x);
}

error[E0308]: mismatched types
  --> src/main.rs:10:10
   |
10 |     wrap(x);
   |          ^ expected fn pointer, found closure
   |
   = note: expected type `fn()`
              found type `[closure@src/main.rs:4:13: 4:33 a:_]`

Why does this not work?

Upvotes: 53

Views: 27474

Answers (2)

Shepmaster
Shepmaster

Reputation: 430634

There are certain cases where you can pass a closure as a function pointer. This works:

fn main() {
    let x = || {
        let a = String::from("abc");
        println!("{}", a);
    };

    fn wrap(c: fn()) {
        c()
    }

    wrap(x);
}

The important difference is that the closure is not allowed to capture anything from its environment. That means that we had to prevent the String from crossing the closure boundary.

Any closure that doesn't capture environment can be trivially rewritten as a anonymous standalone function and then converted into a function pointer.

Once you add an environment, it is no longer convertible and everything from the existing answer applies.

Note that stating -> () is non-idiomatic as that's the default if nothing is specified.

Warning: as of Rust 1.73.0, the error messages related to converting closures to function pointers are buggy! Namely, if you try to convert a convertable closure of the wrong type, the compiler doesn't complain about the type mismatch, but rather says that you have a closure where you need a function pointer! For example, the following code produces the error "expected fn pointer, found closure":

let f = || 0usize;
let g: fn() -> u32 = f;

But actually f is convertable to a function pointer, it just has the wrong type, since the following code where g has the same return type as f compiles:

let f = || 0usize;
let g: fn() -> usize = f;

See also:

Upvotes: 34

Denys Séguret
Denys Séguret

Reputation: 382122

A closure isn't a function.

You can pass a function to a function expecting a closure, but there's no reason for the reverse to be true.

If you want to be able to pass both closures and functions as argument, just prepare it for closures.

For example:

let a = String::from("abc");

let x = || println!("x {}", a);

fn y() {
    println!("y")
}

fn wrap(c: impl Fn()) {
    c()
}

wrap(x); // pass a closure
wrap(y); // pass a function

Upvotes: 43

Related Questions