Proper way to return a new string in Rust

by

You cannot return a &str if you’ve allocated the String in the function. There’s further discussion about why, as well as the fact that it’s not limited to strings. That makes your choice much easier: return the String.

Strings are heap-allocated and built to be mutable.

Strings are heap-allocated because they have an unknown length. Since that allocation is solely owned by the String, that’s what grants the ability to mutate the string.

My function just returns a filepath for reference purposes, and I’d rather leave it up to the caller to decide if they need a heap-stored mutable string.

This isn’t possible. Your function has performed an allocation. If you don’t return the allocation to the caller, then the value must be deallocated to prevent memory leaks. If it was returned after deallocation, that would be an invalid reference, leading to memory safety violations.

But I can also seemingly do this:

fn hello_string(x: &str) -> &str {
    return "hello world";
}

to get a &str out of my function. Can someone explain to me why this
is bad and why I should never do it? Or maybe it’s not bad and okay in
certain situations?

It’s not bad, it just doesn’t really allow you to do what you want in your original case. That "hello world" is a &'static str, a string slice that’s been stored inside the code of the program itself. It has a fixed length and is known to live longer than main.

The signature fn hello_string(x: &str) -> &str can be expanded to fn hello_string<'a>(x: &'a str) -> &'a str. This indicates that the resulting string slice must have the same lifetime as the input string. A static string will outlive any lifetime, so that’s valid to substitute.

This would be useful for a function where the result is based on the input string only:

fn long_string(x: &str) -> &str {
    if x.len() > 10 {
        "too long"
    } else {
        x
    }
}

However, in your case, the function owns the String. If you attempted to return a reference to a String, completely unrelated to the input string:

fn hello_string(x: &str) -> &str {
    &String::from("hello world")
}

You’ll run into the common error message “borrowed value does not live long enough”. That’s because the borrowed value only lives until the end of method, not as long as the input string slice. You can’t “trick” the compiler (or if you can, that’s a major bug).

More Related Contents:

  1. What is the difference between iter and into_iter?
  2. How does for syntax differ from a regular lifetime bound?
  3. How to get a reference to a concrete type from a trait object?
  4. How do I return a reference to something inside a RefCell without breaking encapsulation?
  5. Conditionally iterate over one of several possible iterators
  6. Why is this match pattern unreachable when using non-literal patterns?
  7. Is there any way to create a type alias for multiple traits?
  8. What’s an idiomatic way to print an iterator separated by spaces in Rust?
  9. What are the options to end a mutable borrow in Rust?
  10. How does Rust provide move semantics?
  11. How do I convert a Rust closure to a C-style callback?
  12. Why is the mutable reference not moved here?
  13. How do I use static lifetimes with threads?
  14. How can I create a function with a variable number of arguments?
  15. cannot borrow `self.x` as immutable because `*self` is also borrowed as mutable
  16. Using the same iterator multiple times in Rust
  17. How do I fix “cannot find derive macro in this scope”?
  18. Why is the bound `T: ‘a` required in order to store a reference `&’a T`?
  19. Type mismatches resolving a closure that takes arguments by reference
  20. How can a Rust program access metadata from its Cargo package?
  21. How can the ref keyword be avoided when pattern matching in a function taking &self or &mut self?
  22. How do I disambiguate traits in Rust?
  23. Expected bound lifetime parameter, found concrete lifetime [E0271]
  24. How do I change a function’s qualifiers via conditional compilation?
  25. Creating a vector of zeros for a specific size
  26. What is the difference between immutable and const variables in Rust?
  27. What is the purpose of the unit type in Rust?
  28. Cannot pass self as callback parameter due to double borrowing
  29. How to print structs and arrays?
  30. Can Rust optimise away the bit-wise copy during move of an object someday?

Leave a Comment