Conditionally borrowing in Rust, while keeping the value in scope

user_2148718 0
Viewed 244

I have a Rust function that can take a slice, but also has a default value. Then, if the user passes None, I want to generate a default value. However, because the data type I expect is a slice, I have to borrow that default value, but it immediately goes out of scope. How can I conditionally create an owned value and then borrow it, considering that adding a condition always introduces a new scope that will then drop that value once it ends?

fn with_default(foo: usize, bar: Option<&[usize]>) {
    let bar: &[usize] = match bar {
        Some(s) => s,
        None => { 
            let v: Vec<usize> = (0..foo).collect();
            &v
        }
    };
}

            &v
            ^^ borrowed value does not live long enough
        }
        ^ `v` dropped here while still borrowed
    let bar: &[usize] = match bar {
        ^^^ borrow later stored here
rust
3 Answers
user_21487180

In Rust on your case I would always advice a little factorisation:

pub fn with_default(foo: usize, bar: Option<&[usize]>) {
    fn aux(foo: usize, bar: &[usize]) {
        println!("{:?} {:?}", foo, bar);
    }

    match bar {
        Some(bar) => aux(foo, bar),
        None => aux(foo, &(0..foo).collect::<Vec<_>>()),
    }
}

fn main() {
    with_default(5, Some(&[1, 2, 3]));
    with_default(5, None);
}

This have no problem:

  • clear use structural pattern
  • avoid Silvio solution that have an overhead
  • avoid your solution that have an overhead

you can declare aux() everywhere but that a pattern I often use and so I put it inside the function itself, on "auxiliary" helper that do the logic.

Detail about the overhead you use:

Rustc is not smart enough (at least for now) to generate at compile time a perfect code so a "possibly init" variable will need a boolean runtime to know if rust need to call the drop implementation, on the case of Silvio solution that almost the same cause that need a branch to check state value of the option.

Plus: I hate the pattern of not initialize a variable I think Silvio solution way more clean on this matter.

user_70761530

If you need the vector to last only as long as the function with_default is running (i.e. it doesn't need to be returned from the function or otherwise outlive it), then you just need to make some stack space in the function for the vector. Since it won't always be populated, we'll use Option<Vec<usize>>.

fn with_default(foo: usize, bar: Option<&[usize]>) {

  // Somewhere to store the temporary vector. This variable
  // is owned by the function and will be freed when it goes
  // out of scope.
  let mut my_vec: Option<Vec<usize>> = None;

  let bar: &[usize] = match bar {
    Some(s) => s,
    None => {
      my_vec = Some((0..foo).collect());
      // We know my_vec is a Some now, so unwrap() is safe. But
      // unwrap() would move the value out of the Option, which
      // defeats the point. Option::as_ref() turns &Option<T> into
      // Option<&T>, allowing us to borrow the inside of the Option.
      my_vec.as_ref().unwrap()
    }
  };
}
user_22886590
Related