如何在泛型返回值中引用闭包的类型？

Question

I have a struct that contains a function, let's say of type F: Fn() -> String . And I want to initialize it in its constructor to a particular default function, which can later be overridden by the caller if they like.

struct Builder<F> {
    func: F,
}

fn new_builder() -> ??? {
    let hello = "hello".to_owned();
    Builder { func: move || hello }
}

impl<F: Fn() -> String> Builder<F> {
    fn build(self) -> String {
        (self.func)()
    }
}

But how do I write the return type of new_builder() , since || {} || {} has an anonymous type? I tried with -> Builder<_> but that fails ( playground ), and suggests a solution that's not even syntactically valid:

error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
 --> src/lib.rs:5:29
  |
5 | fn new_builder() -> Builder<_> {
  |                     --------^-
  |                     |       |
  |                     |       not allowed in type signatures
  |                     help: replace with the correct return type: `Builder<[closure@src/lib.rs:6:21: 6:26]>`

For more information about this error, try `rustc --explain E0121`.

I know I can solve it by making Builder non-generic with some boxing:

struct Builder {
    func: Box<dyn Fn() -> ()>,
}

But that incurs additional runtime overhead in the form of allocations and indirections, and might make it harder for the compiler to optimize, eg inline calls to func . This workaround is plenty fast in my practical situation, but I'm still wondering if Rust lets me stick to a purely static solution here.

Is there a way to make this work without resorting to references or boxing?

Answer 1

The main problem here is that the type of a closure cannot be written out in code .

Luckily, for exactly that reason, the impl keyword exists for return types:

struct Builder<F> {
    func: F,
}

fn new_builder() -> Builder<impl FnOnce() -> String> {
    let hello = "hello".to_owned();
    Builder {
        func: move || hello,
    }
}

impl<F: FnOnce() -> String> Builder<F> {
    fn build(self) -> String {
        (self.func)()
    }
}

fn main() {
    let builder = new_builder();
    println!("{}", builder.build());
}

Which means: "This is some unspecified type that the compiler will figure out. It's just important that this type implements FnOnce() -> String ".

Other functions that use new_builder will then be able to access func as an FnOnce() -> String object.

Also note that I had to change the type to FnOnce because func in your case consumes the hello and is therefore only callable once.

Don't worry, though. impl<F: FnOnce() -> String> also includes Fn and FnMut , as they are also FnOnce implicitely.