Why can’t I return an &str value generated from a String?

by

First, let’s take a look at what lifetime is actually expected. There is an implicit lifetime in the signature of description:

fn description(&self) -> &str
// Can be rewritten as
fn description<'a>(&'a self) -> &'a str

The returned pointer must be valid for at least as long as self. Now consider s. It will hold a String, an owned string, and it goes out of scope at the end of the function. It would be invalid to return &s, because s is gone when the function returns. trim returns a string slice that borrows s, but the slice is again only valid for as long as s is.

You need to return a string slice that outlives the method call, so this rules out anything on the stack. If you were free to choose the return type, a solution would be to move the string out of the function. For that an owned string would be required, and then the return type would be String, not &str. Unfortunately, you are not free to choose the return type here.

To return a string slice that outlives the method call, I see two options:

  1. Use a &'static string slice. This will certainly outlive the call, but it requires that the string be known at compile time. String literals have type &'static str. This is a suitable option if the description does not contain any dynamic data.

  2. Store an owned string in LexicalError itself. This ensures that you can return a pointer to it that is valid for the entire lifetime of self. You can add a field desc: String to LexicalError and do the formatting when the error is constructed. Then the method would be implemented as

    fn description(&self) -> &str {
    &self.desc
}

    For re-use, you can make Display write the same string.

According to the documentation of Error, Display may be used to provide additional detail. If you wish to include dynamic data in the error, then Display is a great place to format it, but you can omit it for description. This would allow the first approach to be used.

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. 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. What is the difference between iter and into_iter?
  27. How to use struct self in member method closure
  28. How do you pass a Rust function as a parameter?
  29. How do I use conditional compilation with `cfg` and Cargo?
  30. How do I change a function’s qualifiers via conditional compilation?

Leave a Comment