The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want

by

Check out the entire error:

error[E0310]: the parameter type `U` may not live long enough
 --> src/main.rs:9:24
  |
8 |     fn add<U: Bar<T>>(&mut self, x: U) {
  |            -- help: consider adding an explicit lifetime bound `U: 'static`...
9 |         self.data.push(Box::new(x));
  |                        ^^^^^^^^^^^
  |
note: ...so that the type `U` will meet its required lifetime bounds
 --> src/main.rs:9:24
  |
9 |         self.data.push(Box::new(x));
  |                        ^^^^^^^^^^^

Specifically, the compiler is letting you know that it’s possible that some arbitrary type U might contain a reference, and that reference could then become invalid:

impl<'a, T> Bar<T> for &'a str {}

fn main() {
    let mut foo = Foo { data: vec![] };

    {
        let s = "oh no".to_string();
        foo.add(s.as_ref());
    }
}

That would be Bad News.

Whether you want a 'static lifetime or a parameterized lifetime is up to your needs. The 'static lifetime is easier to use, but has more restrictions. Because of this, it’s the default when you declare a trait object in a struct or a type alias:

struct Foo<T> {
    data: Vec<Box<dyn Bar<T>>>,
    // same as
    // data: Vec<Box<dyn Bar<T> + 'static>>,
}

However, when used as an argument, a trait object uses lifetime elision and gets a unique lifetime:

fn foo(&self, x: Box<dyn Bar<T>>)
// same as
// fn foo<'a, 'b>(&'a self, x: Box<dyn Bar<T> + 'b>)

These two things need to match up.

struct Foo<'a, T> {
    data: Vec<Box<dyn Bar<T> + 'a>>,
}

impl<'a, T> Foo<'a, T> {
    fn add<U>(&mut self, x: U)
    where
        U: Bar<T> + 'a,
    {
        self.data.push(Box::new(x));
    }
}

or

struct Foo<T> {
    data: Vec<Box<dyn Bar<T>>>,
}

impl<T> Foo<T> {
    fn add<U>(&mut self, x: U)
    where
        U: Bar<T> + 'static,
    {
        self.data.push(Box::new(x));
    }
}

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. What are non-lexical lifetimes?
  3. How can I create my own data structure with an iterator that returns mutable references?
  4. Lifetime error when creating a function that returns a value implementing serde::Deserialize
  5. Why does linking lifetimes matter only with mutable references?
  6. Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?
  7. Cannot infer an appropriate lifetime for autoref due to conflicting requirements
  8. When is it useful to define multiple lifetimes in a struct?
  9. Lifetime troubles sharing references between threads
  10. Moved variable still borrowing after calling `drop`?
  11. What is lifetime elision in very simple terms?
  12. “borrowed value does not live long enough” when using the builder pattern
  13. How can this instance seemingly outlive its own parameter lifetime?
  14. How do I specify lifetime parameters in an associated type?
  15. How to operate on 2 mutable slices of a Rust array?
  16. When returning the outcome of consuming a StdinLock, why was the borrow to stdin retained?
  17. Why does my variable not live long enough?
  18. Why is the bound `T: ‘a` required in order to store a reference `&’a T`?
  19. Sharing a struct with trait objects as properties across threads
  20. Why can’t I return an &str value generated from a String?
  21. Type mismatches resolving a closure that takes arguments by reference
  22. How to fix lifetime error when function returns a serde Deserialize type?
  23. Why does Rust disallow mutable aliasing?
  24. Extend lifetime of variable
  25. Why does the Rust compiler request I constrain a generic type parameter’s lifetime (error E0309)?
  26. Cannot create a generic function that uses a literal zero
  27. Why does a mutable borrow of a closure through DerefMut not work?
  28. Why can Serde not derive Deserialize for a struct containing only a &Path?
  29. How to print a Vec?
  30. How to get an Option’s value or set it if it’s empty?

Leave a Comment