Return local String as a slice (&str)

by

No, you cannot do it. There are at least two explanations why it is so.

First, remember that references are borrowed, i.e. they point to some data but do not own it, it is owned by someone else. In this particular case the string, a slice to which you want to return, is owned by the function because it is stored in a local variable.

When the function exits, all its local variables are destroyed; this involves calling destructors, and the destructor of String frees the memory used by the string. However, you want to return a borrowed reference pointing to the data allocated for that string. It means that the returned reference immediately becomes dangling – it points to invalid memory!

Rust was created, among everything else, to prevent such problems. Therefore, in Rust it is impossible to return a reference pointing into local variables of the function, which is possible in languages like C.

There is also another explanation, slightly more formal. Let’s look at your function signature:

fn return_str<'a>() -> &'a str

Remember that lifetime and generic parameters are, well, parameters: they are set by the caller of the function. For example, some other function may call it like this:

let s: &'static str = return_str();

This requires 'a to be 'static, but it is of course impossible – your function does not return a reference to a static memory, it returns a reference with a strictly lesser lifetime. Thus such function definition is unsound and is prohibited by the compiler.

Anyway, in such situations you need to return a value of an owned type, in this particular case it will be an owned String:

fn return_str() -> String {
    let mut string = String::new();

    for _ in 0..10 {
        string.push_str("ACTG");
    }

    string
}

More Related Contents:

  1. Why is it legal to borrow a temporary?
  2. How can I create my own data structure with an iterator that returns mutable references?
  3. What are the options to end a mutable borrow in Rust?
  4. How do I match enum values with an integer?
  5. How does Rust provide move semantics?
  6. How do I convert a Rust closure to a C-style callback?
  7. How to transform fields during serialization using Serde?
  8. Why is the mutable reference not moved here?
  9. “borrowed value does not live long enough” when using the builder pattern
  10. How do I use static lifetimes with threads?
  11. Is it possible to conditionally enable an attribute like `derive`?
  12. How can I create a function with a variable number of arguments?
  13. cannot borrow `self.x` as immutable because `*self` is also borrowed as mutable
  14. Using the same iterator multiple times in Rust
  15. How do I fix “cannot find derive macro in this scope”?
  16. Thread ” has overflowed its stack when allocating a large array using Box
  17. Why is the bound `T: ‘a` required in order to store a reference `&’a T`?
  18. Type mismatches resolving a closure that takes arguments by reference
  19. How do you enable a Rust “crate feature”?
  20. How to implement Iterator yielding mutable references [duplicate]
  21. How do I disambiguate traits in Rust?
  22. How to swap two variables?
  23. How do I change a function’s qualifiers via conditional compilation?
  24. Why is Rust’s assert_eq! implemented using a match?
  25. Is there a list of all cfg features?
  26. How to repeat a static string at compile time
  27. Is there a good way to convert a Vec to an array?
  28. How to concatenate static strings in Rust
  29. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?
  30. How can I build multiple binaries with Cargo?

Leave a Comment