Why “explicit lifetime bound required” for Box in struct?

by

(Slightly pedantic point: that A is a trait, so S is not owning an instance of A, it is owning an boxed instance of some type that implements A.)

A trait object represents data with some unknown type, that is, the only thing known about the data is that it implements the trait A. Because the type is not known, the compiler cannot directly reason about the lifetime of the contained data, and so requires that this information is explicitly stated in the trait object type.

This is done via Trait+'lifetime. The easiest route is to just use 'static, that is, completely disallow storing data that can become invalid due to scopes:

a: Box<A + 'static>

Previously, (before the possibility of lifetime-bounded trait objects and this explicit lifetime bound required error message was introduced) all boxed trait objects were implicitly 'static, that is, this restricted form was the only choice.

The most flexible form is exposing the lifetime externally:

struct S<'x> {
    a: Box<A + 'x>
}

This allows S to store a trait object of any type that implements A, possibly with some restrictions on the scopes in which the S is valid (i.e. for types for which 'x is less than 'static the S object will be trapped within some stack frame).

More Related Contents:

  1. Use of undeclared type or module `std` when used in a separate module
  2. What are non-lexical lifetimes?
  3. How can I include a module from another file from the same project?
  4. What does “Sized is not implemented” mean?
  5. Deriving a trait results in unexpected compiler error, but the manual implementation works
  6. How do I implement Copy and Clone for a type that contains a String (or any type that doesn’t implement Copy)?
  7. Mutably borrow one struct field while borrowing another in a closure
  8. How do I convert a Vector of bytes (u8) to a string?
  9. When is it useful to define multiple lifetimes in a struct?
  10. Can I write an Iterator that mutates itself and then yields a reference into itself?
  11. How to update-or-insert on a Vec?
  12. Lifetime troubles sharing references between threads
  13. How do I include the end value in a range?
  14. How do I specify lifetime parameters in an associated type?
  15. How do I invoke a system command and capture its output?
  16. How to return a string (or similar) from Rust in WebAssembly?
  17. Can I destructure a tuple without binding the result to a new variable in a let/match/for statement?
  18. What is the difference between Copy and Clone?
  19. How to format output to a byte array with no_std and no allocator?
  20. What is the right way to allocate data to pass to an FFI call?
  21. Efficiently insert or replace multiple elements in the middle or at the beginning of a Vec?
  22. Read large files line by line in Rust [duplicate]
  23. Why is it discouraged to accept a reference &String, &Vec, or &Box as a function argument?
  24. What makes `impl Trait` as an argument “universal” and as a return value “existential”?
  25. How to represent shared mutable state?
  26. Mutable reference to container object within iterator loop
  27. Why can Serde not derive Deserialize for a struct containing only a &Path?
  28. How to quiet a warning for a single statement in Rust?
  29. Is there an elegant solution to modifying a structure while iterating?
  30. How do I cope with lazy iterators?

Leave a Comment