Regression: cannot convert to a trait object because trait `core::ops::FnOnce` is not object-safe

[tomaka]

The following code used to work:

#![feature(unboxed_closures)]

fn convert<F: FnOnce() + Send>(f: F) -> Box<FnOnce() + Send> {
    box f
}

But now it fails to compile with 126db549b 2014-12-15 00:07:35 +0000:

D:\Projets\test\src\lib.rs:4:5: 4:10 error: cannot convert to a trait object because trait `core::ops::FnOnce` is not object-safe [E0038]
D:\Projets\test\src\lib.rs:4     box f
                                 ^~~~~
note: cannot call a method (`call_once`) with a by-value receiver through a trait object

[alexcrichton]

Currently this is what Thunk is meant for (as a stopgap for now).

[tomaka]

As far as I know, Thunk can't be used to replace Box<for<'a> FnOnce(Foo<'a>)>.

I'm also having issues using the raw Invoke trait, but this is off-topic.

[japaric]

@tomaka You may be able to use the FnBox trait:

#![feature(default_type_params, unboxed_closures)]

trait FnBox<A, R = ()> {
    fn call_box(self: Box<Self>, arg: A) -> R;
}

impl<A, R, F> FnBox<A, R> for F
    where F : FnOnce(A) -> R
{
    fn call_box(self: Box<F>, arg: A) -> R {
        (*self)(arg)
    }
}

struct Foo<'a>;

fn put_in_box<F>(f: F) -> Box<for<'a> FnBox<Foo<'a>, ()> + 'static> where
    F: FnOnce(Foo) + 'static
{
    box f
}

fn main() {
    put_in_box(|_| {}).call_box(Foo);
}

I don't know the details, but that trait may end replacing the Thunk struct. @nikomatsakis knows more.

[mzabaluev]

One issue I've found with the design of Thunk/Invoke is the need for () in the no-arguments case:

use std::thunk::Invoke;

fn consume_closure_boxed(b: Box<Invoke>) {
    b.invoke(());
}

fn consume_closure<F: FnOnce(())>(f: F) {
    consume_closure_boxed(box f);
}

fn main() {
    let x = 42i;
    consume_closure(|()| {
        println!("{}", x);
    });
}

[mzabaluev]

There is also a usability issue: Thunk does not accept multiple-argument closures due to some limitation in the type system.

One important use case with closures is transforming them into a raw pointer for passing into callbacks from C.
Unfortunately, a boxed object type cannot be transmuted to a raw pointer; a struct box around it seems to be necessary at present.

[mzabaluev]

Both std::thunk and the example above use non-generic syntax for closures and their invocation, making it impossible to use multi-argument closures. See #20110.

[edef1c]

I was looking to solve the same problem, and ended up reinventing FnBox on my own.
I've published it to Cargo, so we don't all have to repeat that: https://crates.io/crates/fn_box
@japaric Seems great minds think alike!

[japaric]

@japaric Seems great minds think alike!

Then, the other great mind here is @nikomatsakis! FnBox is his idea, I merely posted his gist here.

I've published it to Cargo, ...

I think Niko's idea was to put FnBox in the stdlib (and bless it with parenthetical notation FnBox(&int) -> bool?), but having it in cargo sounds like a good interim solution until that happens.

[edef1c]

Parenthetical notation seems to work just fine for now, that's what the README uses.
It currently seems to be plagued by coherency issues, any generic implementation of FnOnce is considered to be conflicting with libcore. When that's fixed, Box<FnBox<A, R>> should implement FnOnce<A, R>.

[bombless]

This doesn't reproduce now.

[tomaka]

Seems to be fixed.