包含多态结构的动态特征 Vec 中的模棱两可的错误

Question

I'm a bit confused by the error messaging of rust. Consider the following code (it doesn't make much sense in this context; the return type of foo could easily be changed to Vec<Box<dyn MyTrait + 'a>> which makes much more sense, but in the context if the complete code base this return type does make sense).

trait MyTrait {
    fn foo<'a>(&self) -> Vec<Box<dyn MyTrait + 'a>>;
}

#[derive(Clone)]
struct MyStruct<T> {
    type_parameter: T,
}

impl <T: Clone> MyTrait for MyStruct<T> {
    fn foo<'a>(&self) -> Vec<Box<dyn MyTrait + 'a>> {
        let foos: Vec<Box<dyn MyTrait + 'a>> = Vec::new();
        
        for i in 0..10 {
            let foo = Box::new(self.clone());
            foos.push(foo);
        }
        
        foos
    }
}

The problem with this code is that the type parameter T in MyStruct<T> can be outlived by 'a . When compiling this code the error message I receive is

error[E0309]: the parameter type `T` may not live long enough
  --> src/main.rs:20:23
   |
14 | impl <T: Clone> MyTrait for MyStruct<T> {
   |       -- help: consider adding an explicit lifetime bound...: `T: 'a +`
...
20 |             foos.push(foo);
   |                       ^^^ ...so that the type `MyStruct<T>` will meet its required lifetime bounds

It states that the type parameter T can be supplemented with the 'a lifetime bound. However if i try to do this the compiler states that 'a is an undefined lifetime bound, and if I declare 'a it says that 'a is shadowed and I receive the same error as above. Is there any way I can fix this code or have I reached a limitation of rust?

If you'd like to play around with the code, here is a playground https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=9e490e98f94e98cde3b9db1ac28ee4a5

Answer 1

The declaration of foo doesn't really make sense:

fn foo<'a>(&self) -> Vec<Box<dyn MyTrait + 'a>>;

means that whoever calls the function can choose any lifetime 'a they want and get a vector of objects with this lifetime. How would that work? Either the returned objects are owned by the struct and their lifetime must be linked to that of the struct, or ownership will be passed to the caller and there is no need for an explicit lifetime.

It is much more likely that the lifetime should be linked to the struct, either with:

fn foo<'a>(&'a self) -> Vec<Box<dyn MyTrait + 'a>>;
         // ^^ add this

Playground

Or by making the whole trait generic over the lifetime:

trait MyTrait<'a> {
    fn foo(&self) -> Vec<Box<dyn MyTrait + 'a>>;
}

#[derive(Clone)]
struct MyStruct<T> {
    type_parameter: T,
}

impl <'a, T: Clone + 'a> MyTrait<'a> for MyStruct<T> {
    fn foo(&self) -> Vec<Box<dyn MyTrait + 'a>> {
        let mut foos: Vec<Box<dyn MyTrait + 'a>> = Vec::new();
        
        for i in 0..10 {
            let foo = Box::new(self.clone());
            foos.push(foo);
        }
        
        foos
    }
}

Playground

Answer 2

Simple solution with minimal lifetime syntax

One fix for this could be to use the 'static bound on T as below. What this indicates is the impl for MyStruct accepts any type T whose fields (if any) hold either only owned data, or references with a static lifetime.

Judging from your use of the Clone bound on T , I sense that you intend for MyStruct to own T and where T needs to be used by other objects, it will be cloned and subsequently owned by them.

For a good discussion very helpful in understanding the nuances of lifetimes, click here . An applicable excerpt from this article that talks about the differences between &'static T vs. T: 'static :

... a type with a 'static lifetime is different from a type bounded by a 'static lifetime. The latter can be dynamically allocated at run-time, can be safely and freely mutated, can be dropped, and can live for arbitrary durations.

Another applicable reference on 'static as a trait bound is from this section in Rust By Example :

As a trait bound, it means the type does not contain any non-static references. Eg. the receiver can hold on to the type for as long as they want and it will never become invalid until they drop it.

pub trait MyTrait {
    fn get_vec(&self) -> Vec<Box<dyn MyTrait>>;
}

#[derive(Clone)]
pub struct MyStruct<T> {
    type_parameter: T,
}

impl<T: 'static + Clone> MyTrait for MyStruct<T> {

    fn get_vec(&self) -> Vec<Box<dyn MyTrait>> 
    {
        let mut foos: Vec<Box<dyn MyTrait>> = Vec::new();
        
        for i in 0..10 {
            foos.push(Box::new(self.clone()));
        }
        foos
    }
}