Why does the Rust compiler request I constrain a generic type parameter’s lifetime (error E0309)?

by

What T: 'a is saying is that any references in T must outlive 'a.

What this means is that you can’t do something like:

let mut o: Option<&str> = Some("foo");
let mut nt = NewType { x: &o };  // o has a reference to &'static str, ok.

{
    let s = "bar".to_string();
    let o2: Option<&str> = Some(&s);
    nt.x = &o2;
}

This would be dangerous because nt would have a dangling reference to s after the block. In this case it would also complain that o2 didn’t live long enough either.

I can’t think of a way you can have a &'a reference to something which contains shorter-lifetime references, and clearly the compiler knows this in some way (because it’s telling you to add the constraint). However I think it’s helpful in some ways to spell out the restriction, since it makes the borrow checker less magic: you can reason about it just from just type declarations and function signatures, without having to look at how the fields are defined (often implementation details which aren’t in documentation) or how the implementation of a function.

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. Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?
  8. Cannot infer an appropriate lifetime for autoref due to conflicting requirements
  9. When is it useful to define multiple lifetimes in a struct?
  10. Lifetime troubles sharing references between threads
  11. Moved variable still borrowing after calling `drop`?
  12. What is lifetime elision in very simple terms?
  13. “borrowed value does not live long enough” when using the builder pattern
  14. How can this instance seemingly outlive its own parameter lifetime?
  15. How do I specify lifetime parameters in an associated type?
  16. How to operate on 2 mutable slices of a Rust array?
  17. When returning the outcome of consuming a StdinLock, why was the borrow to stdin retained?
  18. Why does my variable not live long enough?
  19. Why is the bound `T: ‘a` required in order to store a reference `&’a T`?
  20. Sharing a struct with trait objects as properties across threads
  21. Why can’t I return an &str value generated from a String?
  22. Type mismatches resolving a closure that takes arguments by reference
  23. How to fix lifetime error when function returns a serde Deserialize type?
  24. Why does Rust disallow mutable aliasing?
  25. Extend lifetime of variable
  26. Does println! borrow or own the variable?
  27. Why is it possible to implement Read on an immutable reference to File?
  28. Mutating one field while iterating over another immutable field
  29. How to end a borrow in a match or if let expression?
  30. Why does creating a mutable reference to a dereferenced mutable reference work?

Leave a Comment