Rust lifetime error expected concrete lifetime but found bound lifetime

by

Let’s compare the two definitions. First, the trait method:

fn to_c<'a>(&self, r: &'a Ref) -> Container<'a>;

And the implementation:

fn to_c(&self, r: &'a Ref) -> Container<'a>;

See the difference? The latter doesn’t have <'a>. <'a> has been specified elsewhere; the fact that it has the same name does not matter: it is a different thing entirely.

Functionally, your trait definition says that the returned container will have a reference inside it to something from r, but nothing from self. It may use self inside the method, but it may not store any references to it in the returned value.

Your method definition, however, is using a 'a that ties the lifetimes of r and the returned Container to self (that is, to the object itself, not the reference—the ρ₂ in &'ρ₁ T<'ρ₂>—it’s a subtle but sometimes significant difference), whereas the trait definition had no such connection.

The two can be made to match by inserting the <'a> in the method definition in the implementation. But bear in mind that that is shadowing the 'a from ContainerB<'a>; it is not the same 'a! We’re better to give it another name; for convenience, I’ll make the change the other way round, changing it on the impl instead of the method (either would do):

impl<'b> ToC for ContainerB<'b> {
    fn to_c<'a>(&self, r: &'a Ref) -> Container<'a> {
        self.c
    }
}

But now of course you have a problem: the return value is of type Container<'b> (because that’s what the field c in a ContainerB<'b> is), but your signature demands Container<'a> (something using a reference from r, not from self).

One way which would fix it is specifying the lifetime of &self as 'a in both the trait definition and the implementation; in the implementation, this would then demand that 'b was greater than or equal to 'a (by virtue of the fact that you have successfully taken a reference with lifetime 'a to an object with lifetime 'b, and the object must outlive the reference) and so due to the subtyping ('a is a subtype of 'b) Container<'b> would be safely coerced to Container<'a>.

These sorts of lifetime matters are difficult to think about when you’re not familiar with them; but in time they become quite natural.

More Related Contents:

  1. Is there any way to return a reference to a variable created in a function?
  2. Why are explicit lifetimes needed in Rust?
  3. How do I implement the Add trait for a reference to a struct?
  4. Iterator returning items by reference, lifetime issue
  5. Why can’t I store a value and a reference to that value in the same struct?
  6. How can I pass a reference to a stack variable to a thread?
  7. Why can I return a reference to a local literal but not a variable?
  8. Cannot move out of borrowed content / cannot move out of behind a shared reference
  9. Why does linking lifetimes matter only with mutable references?
  10. Cannot borrow as mutable because it is also borrowed as immutable
  11. Cannot move out of borrowed content when trying to transfer ownership
  12. How to avoid writing duplicate accessor functions for mutable and immutable references in Rust?
  13. Why does pattern matching on &Option yield something of type Some(&T)?
  14. What is the purpose of `&` before the loop variable?
  15. Why is “&&” being used in closure arguments?
  16. When should I not implement a trait for references to implementors of that trait?
  17. What is an idiomatic way to collect an iterator of &T into a collection of Ts?
  18. How to abstract over a reference to a value or a value itself?
  19. 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
  20. Why is the return type of Deref::deref itself a reference?
  21. C++ constant reference lifetime (container adaptor)
  22. What is the difference between ‘&self’ and ‘&’a self’?
  23. What lifetimes do I use to create Rust structs that reference each other cyclically?
  24. Why can’t I use a key function that returns a reference when sorting a vector with sort_by_key?
  25. How to operate on 2 mutable slices of a Rust array?
  26. When returning the outcome of consuming a StdinLock, why was the borrow to stdin retained?
  27. Why does Rust disallow mutable aliasing?
  28. How to query mongodb with DBRef
  29. Finding all references of a variable or a method in Xcode4
  30. Why does the Rust compiler request I constrain a generic type parameter’s lifetime (error E0309)?

Leave a Comment