Why can I return a reference to a local literal but not a variable?

by

In your example, [1, 2, 3] is not treated as local variable, but as static one!

Let’s take a look at this code:

fn foo() -> &'static [i32] {
    &[1, 2, 3]
}

This works!

Some time ago, RFC 1414: Rvalue Static Promotion was merged: “Promote constexpr rvalues to values in static memory instead of stack slots”. This means that basically all literals you write can live forever. Thus, things like let _: &'static i32 = &42; also work!

If we avoid using a literal array, we can see the expected error:

fn bar() -> impl Iterator<Item = i32> {
    vec![1, 2, 3].iter().map(|&i| i)
}

Here we get the “v does not live long enough” error.

This isn’t limited to integers or arrays; it applies broadly to any literal that is composed solely of literals:

fn promote_integer() -> &'static i32 {
    &42
}

fn promote_float() -> &'static f64 {
    &42.42
}

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

struct Foo(char);

fn promote_struct() -> &'static Foo {
    &Foo('x')
}

Beyond literals, this also works for a tiny number of functions in the standard library, but these were likely a mistake. Deciding on if the result of arbitrary const functions can be automatically promoted to static is still an open topic.

More Related Contents:

  1. Cannot move out of borrowed content / cannot move out of behind a shared reference
  2. Cannot move out of borrowed content when trying to transfer ownership
  3. Why can’t I store a value and a reference to that value in the same struct?
  4. Is there any way to return a reference to a variable created in a function?
  5. Why are explicit lifetimes needed in Rust?
  6. Cannot borrow as mutable because it is also borrowed as immutable
  7. How do I implement the Add trait for a reference to a struct?
  8. How to avoid writing duplicate accessor functions for mutable and immutable references in Rust?
  9. Iterator returning items by reference, lifetime issue
  10. Why does pattern matching on &Option yield something of type Some(&T)?
  11. What is the purpose of `&` before the loop variable?
  12. Why is “&&” being used in closure arguments?
  13. When should I not implement a trait for references to implementors of that trait?
  14. What is an idiomatic way to collect an iterator of &T into a collection of Ts?
  15. How to abstract over a reference to a value or a value itself?
  16. Rust lifetime error expected concrete lifetime but found bound lifetime
  17. How can I pass a reference to a stack variable to a thread?
  18. Cannot move out of value which is behind a shared reference when unwrapping
  19. Why does refactoring by extracting a method trigger a borrow checker error?
  20. Returning a reference from a HashMap or Vec causes a borrow to last beyond the scope it’s in?
  21. Why does linking lifetimes matter only with mutable references?
  22. Do mutable references have move semantics?
  23. What are the options to end a mutable borrow in Rust?
  24. “borrowed value does not live long enough” when using the builder pattern
  25. Convert Vec into a slice of &str in Rust?
  26. Can’t borrow mutably within two different closures in the same scope
  27. How to use a struct’s member as its own key when inserting the struct into a map without duplicating it?
  28. How can I mutate other elements of a HashMap when using the entry pattern?
  29. How can I do a mutable borrow in a for loop?
  30. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?

Leave a Comment