Is there any way to return a reference to a variable created in a function?

by

The question you asked

TL;DR: No, you cannot return a reference to a variable that is owned by a function. This applies if you created the variable or if you took ownership of the variable as a function argument.

Solutions

Instead of trying to return a reference, return an owned object. String instead of &str, Vec<T> instead of &[T], T instead of &T, etc.

If you took ownership of the variable via an argument, try taking a (mutable) reference instead and then returning a reference of the same lifetime.

In rare cases, you can use unsafe code to return the owned value and a reference to it. This has a number of delicate requirements you must uphold to ensure you don’t cause undefined behavior or memory unsafety.

See also:

Deeper answer

fjh is absolutely correct, but I want to comment a bit more deeply and touch on some of the other errors with your code.

Let’s start with a smaller example of returning a reference and look at the errors:

fn try_create<'a>() -> &'a String {
    &String::new()
}

Rust 2015

error[E0597]: borrowed value does not live long enough
 --> src/lib.rs:2:6
  |
2 |     &String::new()
  |      ^^^^^^^^^^^^^ temporary value does not live long enough
3 | }
  | - temporary value only lives until here
  |
note: borrowed value must be valid for the lifetime 'a as defined on the function body at 1:15...
 --> src/lib.rs:1:15
  |
1 | fn try_create<'a>() -> &'a String {
  |               ^^

Rust 2018

error[E0515]: cannot return reference to temporary value
 --> src/lib.rs:2:5
  |
2 |     &String::new()
  |     ^-------------
  |     ||
  |     |temporary value created here
  |     returns a reference to data owned by the current function

Is there any way to return a reference from a function without arguments?

Technically “yes”, but for what you want, “no”.

A reference points to an existing piece of memory. In a function with no arguments, the only things that could be referenced are global constants (which have the lifetime &'static) and local variables. I’ll ignore globals for now.

In a language like C or C++, you could actually take a reference to a local variable and return it. However, as soon as the function returns, there’s no guarantee that the memory that you are referencing continues to be what you thought it was. It might stay what you expect for a while, but eventually the memory will get reused for something else. As soon as your code looks at the memory and tries to interpret a username as the amount of money left in the user’s bank account, problems will arise!

This is what Rust’s lifetimes prevent – you aren’t allowed to use a reference beyond how long the referred-to value is valid at its current memory location.

See also:

Your actual problem

Look at the documentation for OpenOptions::open:

fn open<P: AsRef<Path>>(&self, path: P) -> Result<File>

It returns a Result<File>, so I don’t know how you’d expect to return an OpenOptions or a reference to one. Your function would work if you rewrote it as:

fn trycreate() -> File {
    OpenOptions::new()
        .write(true)
        .open("foo.txt")
        .expect("Couldn't open")
}

This uses Result::expect to panic with a useful error message. Of course, panicking in the guts of your program isn’t super useful, so it’s recommended to propagate your errors back out:

fn trycreate() -> io::Result<File> {
    OpenOptions::new().write(true).open("foo.txt")
}

Option and Result have lots of nice methods to deal with chained error logic. Here, you can use or_else:

let f = OpenOptions::new().write(true).open("foo.txt");
let mut f = f.or_else(|_| trycreate()).expect("failed at creating");

I’d also return the Result from main. All together, including fjh’s suggestions:

use std::{
    fs::OpenOptions,
    io::{self, Write},
};

fn main() -> io::Result<()> {
    let mut f = OpenOptions::new()
        .create(true)
        .write(true)
        .append(true)
        .open("foo.txt")?;

    f.write_all(b"test1\n")?;
    f.write_all(b"test2\n")?;

    Ok(())
}

More Related Contents:

  1. Why are explicit lifetimes needed in Rust?
  2. How do I implement the Add trait for a reference to a struct?
  3. Iterator returning items by reference, lifetime issue
  4. Rust lifetime error expected concrete lifetime but found bound lifetime
  5. Why can’t I store a value and a reference to that value in the same struct?
  6. How can I pass a reference to a stack variable to a thread?
  7. Why can I return a reference to a local literal but not a variable?
  8. Cannot move out of borrowed content / cannot move out of behind a shared reference
  9. Why does linking lifetimes matter only with mutable references?
  10. Cannot borrow as mutable because it is also borrowed as immutable
  11. Cannot move out of borrowed content when trying to transfer ownership
  12. How to avoid writing duplicate accessor functions for mutable and immutable references in Rust?
  13. Why does pattern matching on &Option yield something of type Some(&T)?
  14. What is the purpose of `&` before the loop variable?
  15. Why is “&&” being used in closure arguments?
  16. When should I not implement a trait for references to implementors of that trait?
  17. What is an idiomatic way to collect an iterator of &T into a collection of Ts?
  18. How to abstract over a reference to a value or a value itself?
  19. How do I write an iterator that returns references to itself?
  20. How can I create my own data structure with an iterator that returns mutable references?
  21. Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?
  22. How to declare a higher-ranked lifetime for a closure argument?
  23. “borrowed value does not live long enough” when using the builder pattern
  24. Why does my variable not live long enough?
  25. Why is the bound `T: ‘a` required in order to store a reference `&’a T`?
  26. How do I make format! return a &str from a conditional expression?
  27. Type mismatches resolving a closure that takes arguments by reference
  28. How to fix lifetime error when function returns a serde Deserialize type?
  29. Returning iterator of a Vec in a RefCell
  30. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?

Leave a Comment