Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?

by

There is one thing that is easily overlooked: if you have a trait Bar and you want to have a boxed trait object Box<dyn Bar>, the compiler automatically adds a 'static lifetime bound (as specified in RFC 599). This means that Box<dyn Bar> and Box<dyn Bar + 'static> are equivalent!

In your case, the compiler automatically adds the static bound such that this …

fn into_iterator(myvec: &Vec<Foo>) -> Box<dyn Iterator<Item = &Foo>>

… is equivalent to that:

fn into_iterator(myvec: &Vec<Foo>) -> Box<dyn Iterator<Item = &Foo> + 'static>

Now lifetime elision rules kick in and “connect” the two lifetime-slots, such that the above code is equivalent to:

fn into_iterator<'a>(myvec: &'a Vec<Foo>) -> Box<dyn Iterator<Item = &'a Foo> + 'static>

But the type Iter<'a, Foo> (the specific iterator type for Vec<Foo>) obviously does not satisfy the bound 'static (because it is borrowing the Vec<Foo>)! So we have to tell the compiler that we don’t want the default 'static bound by specifying our own lifetime bound:

fn into_iterator<'a>(myvec: &'a Vec<Foo>) -> Box<dyn Iterator<Item = &Foo> + 'a>

Now the compiler knows that the trait object is only valid for the lifetime 'a. Note that we don’t explicitly need to annotate the lifetime of the associated Item type! Lifetime elision rules take care of that.

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. 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
  4. How can I create my own data structure with an iterator that returns mutable references?
  5. Lifetime error when creating a function that returns a value implementing serde::Deserialize
  6. Why does linking lifetimes matter only with mutable references?
  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. How does for syntax differ from a regular lifetime bound?
  27. How do I use static lifetimes with threads?
  28. How can I create a function with a variable number of arguments?
  29. How do I disambiguate traits in Rust?
  30. What is the difference between immutable and const variables in Rust?

Leave a Comment