Self-defined callback?

[Yandros]

@steffahn

impl<F: Fn()> Foo<F> {
    pub fn new() -> Foo<impl Fn()> {
        Foo { cb: || {} }
    }
}

This will cause type-inference issues, though. But it is indeed the starting point of the only non-dyn-based solution in stable Rust until we get min_type_alias_impl_trait.

I've discussed about this very pattern (impl Fn and returning such from an impl … { fn new() constructor) in this other post:

How to use Traits as Generic type parameters?

Although in this example it is just a matter of "style preference", the problem does indeed arrive when unnameable types are involved: let's image someone wants to have: struct Session<F : Fn()> { f: F, } impl Session<?> { fn new () -> Session<impl Fn()> { Session { f: || println!("Demo"), } } } your code example is similar to this situation, except that you could name the type but you don't want to, to ease refactoring. I already covered this use case in an old p…

I have also written a more general-purpose post (impl ArbitraryTrait from a function yielding an opaque type, such as -> impl Iterator…), listing all the current solutions to the problem (nightly feature, constructor with pseudo impl_Trait hidden type, dyn-erasure):

Embedding Trait inside of Struct

A simplified version of your problem is here: trait Foo { fn stuff (&self) ; } fn makes_foo () -> impl Foo { struct Struct; impl Foo for Struct { fn stuff (self: &'_ Self) { eprintln!("<impl Foo>::stuff()"); } } Struct } struct FooContainer<T : Foo> { field: T, } impl<T : Foo> FooContainer<T> { fn new () -> Self { Self { field: makes_foo(), } } fn other_stuff (self: &'_ Self) …