How can I create a trait method that has a trait as a return argument?

Question

I have a trait B that defines a function which returns a reference to an object that implements the trait A.

enum Error { }

trait A { }

trait B {
    fn create_a<'a>() -> Result<&'a impl A, Error>;
}

However, when I try to compile I get the following error

error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
  --> src/lib.rs:10:37
   |
10 |     fn create_a<'a>() -> Result<&'a impl A, Error>;
   |                                     ^^^^^^

As compiler say, you can't use impl in this context, please describe what you try to do because currently the best to solve your issue is to just propose to not write anycode. Explain what you try to do instead of the solution you try to implement. — Stargateur
Your create_a function should propably accept an argument of self, either self, &self or &mut self. — hellow

Jan Hudec Jan Hudec · Accepted Answer · 2018-11-06T07:53:48

fn create_a<'a>() -> Result<&'a impl A, Error>;

There is no way to create a reference that will live as long as arbitrary lifetime without having an object that already has that lifetime and can act as its owner—and you have no object here at all, so this signature makes no sense.

For further argument I will assume you do have a self argument with that lifetime (it probably needs to be mutable too): fn create_a<'a>(&'a mut self) -> Result<&'a impl A, Error>;

(note that since there is only one life-time that all mentioned references have, you can elide it: fn create_a(&mut self) -> Result<&impl A, Error>;)

Now there are two options:

You can define the concrete type as member of that trait like
```
trait B {
    type ImplA: A;
    fn create_a(&mut self) -> Result<&ImplA, Error>;
}
```
This is not object-safe, but it will be statically dispatched.

You should be able to use the impl type alias when implementing the trait to name the type if desired.
If you do want B to be object-safe, use object reference, i.e.
```
trait B {
    fn create_a(&mut self) -> Result<&dyn A, Error>;
}
```
this way dispatch to the return value is always dynamic, but you do that to allow dynamic dispatch to B::create_a in the first place anyway.

How can I create a trait method that has a trait as a return argument?

2 Answers