How does the lifetime work on constant strings / string literals?

by

Lifetime elision infers that the full type of

fn get_str(s: &str) -> &str

is

fn get_str<'a>(s: &'a str) -> &'a str

which basically means that the return value of get_str has to be valid as long as s is valid. The actual type of the string literal "Hello world" is &'static str, which means that it is valid for the entire run of the program. Since this satisfies the lifetime constraints in the function signature (because 'static always includes 'a for any 'a), this works.

However, a more sensible way to get your original code to work would be to add an explicit lifetime to the function type:

fn get_str() -> &'static str {
    "Hello World"
}

How does “Hello World” borrow from the parameter s, even it has nothing to do with s?

There are only two options that would make sense for the return value’s lifetime in a function with a single reference argument:

  1. It can be 'static, as it should be in your example, or
  2. The return value’s lifetime has to be tied to the lifetime of the argument, which is what lifetime elision defaults to.

There is some rationale for choosing the latter in the link at the top of this post, but it basically comes down to the fact that the latter is the far more common case. Note that lifetime elision does not look at the function body at all, it just goes by the function signature. That’s why it won’t take the fact that you’re just returning a string constant into account.

More Related Contents:

  1. How do I make format! return a &str from a conditional expression?
  2. How to create a formatted String out of a literal in Rust?
  3. I want to run a loop in println [duplicate]
  4. Why is it discouraged to accept a reference to a String (&String), Vec (&Vec), or Box (&Box) as a function argument?
  5. Why does my string not match when reading user input from stdin?
  6. What are the differences between Rust’s `String` and `str`?
  7. How to match a String against string literals?
  8. How do I concatenate strings?
  9. What does “`str` does not have a constant size known at compile-time” mean, and what’s the simplest way to fix it?
  10. How do I convert a Vec to Vec?
  11. Why is capitalizing the first letter of a string so convoluted in Rust?
  12. Convert Vec into a slice of &str in Rust?
  13. How do I convert between String, &str, Vec and &[u8]?
  14. Is there an owned version of String::chars?
  15. How can I use a dynamic format string with the format! macro?
  16. What is the equivalent of the join operator over a vector of Strings?
  17. How to index a String in Rust
  18. Can I convert a string to enum without macros in Rust?
  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. Convert Int to String in Swift
  21. How do I remove the file suffix and path portion from a path string in Bash?
  22. In Perl, how can I read an entire file into a string?
  23. Lifetime of a string literal returned by a function
  24. When returning the outcome of consuming a StdinLock, why was the borrow to stdin retained?
  25. When using the MOV mnemonic to load/copy a string to a memory register in MASM, are the characters stored in reverse order?
  26. Why does Rust disallow mutable aliasing?
  27. Excel VBA like operator [closed]
  28. How to get the number of characters in a string
  29. Flutter/Dart: Convert HEX color string to Color?
  30. Does conversion between alias types in Go create copies?

Leave a Comment