CODEWITHSUNDEEP
rust
Adam
Adam

Reputation: 3288

Avoiding "cannot move out of borrowed content" without the use of "to_vec"?

I'm learning rust and have a simple program, shown below. Playground link.

#[derive(Debug)]
pub struct Foo {
    bar: String,
}

pub fn gather_foos<'a>(data: &'a Vec<Vec<&'a Foo>>) -> Vec<Vec<&'a Foo>> {
    let mut ret: Vec<Vec<&Foo>> = Vec::new();

    for i in 0..data.len() {
        if meets_requirements(&data[i]) {
            ret.push(data[i].to_vec());
        }
    }

    return ret
}

fn meets_requirements<'a>(_data: &'a Vec<&'a Foo>) -> bool {
    true
}

fn main() {
    let foo = Foo{
        bar: String::from("bar"),
    };
    let v1 = vec![&foo, &foo, &foo];
    let v2 = vec![&foo, &foo];
    let data = vec![v1, v2];

    println!("{:?}", gather_foos(&data));
}

The program simply loops through an array of arrays of a struct, checks if the array of structs meets some requirement and returns an array of arrays that meets said requirement.

I'm sure there's a more efficient way of doing this without the need to call to_vec(), which I had to implement in order to avoid the error cannot move out of borrowed content, but I'm not sure what that solution is.

I'm learning about Box<T> now and think it might provide a solution to my needs? Thanks for any help!!

Upvotes: 1

Views: 369

Answers (1)

apetranzilla
apetranzilla

Reputation: 5919

The error is showing up because you're trying to move ownership of one of the vectors in the input vector to the output vector, which is not allowed since you've borrowed the input vector immutably. to_vec() creates a copy, which is why it works when you use it.

The solution depends on what you're trying to do. If you don't need the original input (you only want the matched ones), you can simply pass the input by value rather than by reference, which will allow you to consume the vector and move items to the output. Here's an example of this.

If you do need the original input, but you don't want to copy the vectors with to_vec(), you may want to use references in the output, as demonstrated by this example. Note that the function now returns a vector of references to vectors, rather than a vector of owned vectors.

For other cases, there are other options. If you need the data to be owned by multiple items for some reason, you could try Rc<T> or Arc<T> for reference-counted smart pointers, which can be cloned to provide immutable access to the same data by multiple owners.

Upvotes: 1

Related Questions