在返回的结构中捕获迭代器

Question

Newbie here, still struggling with ownership.

I would like to know how I can, in a function, returns a borrow from a struct wrapped in another struct. Here is an example:

struct Data {
    data: [String; 10]
}

struct DataIterator<'a> {
    value: &'a std::slice::IterMut<'a, String>
}

impl Data {
    fn get_string(&mut self) -> DataIterator {
        let result = DataIterator {
            value: &self.data.iter_mut()
        };
        return result;
    }
}

Here is a link to the playground .

The idea would be to get a usable iterator, where the data from the Data struct is borrowed, and can be modified, and then, when the return value of the get_string function is dropped, the borrow stops.

However, I'm getting an error where the data cannot be returned as it is owned by the function.

I've tried my best to simplify the issue, as in my case it gets more complicated and I didn't want to give lots of useless information, but I'm trying to return several iterator from the original struct and borrow the fields of the struct doing so.

Is there a way to "capture" the iterator and borrow it using such a function?

Answer 1

The get_string() function creates the iterator; it as a temporary value, and returning a reference to it is forbidden (it would be dangling).

I don't think you need to store a reference to the iterator. You could simply store the iterator as a value.

It however refers to the original container. The 'a in IterMut is implicitly the lifetime of &mut self in get_string() . Then, when this DataIterator will be dropped, the exclusive borrow of the Data will stop.

struct Data {
    data: [String; 10],
}

struct DataIterator<'a> {
    value: std::slice::IterMut<'a, String>,
}

impl Data {
    fn get_string(&mut self) -> DataIterator {
        DataIterator {
            value: self.data.iter_mut(),
        }
    }
}

fn main() {
    let mut d = Data {
        data: Default::default(),
    };
    //
    // a first exclusive-borrow of d starts here...
    d.get_string().value.enumerate().for_each(|(i, e)| {
        *e = format!("elem {}", i);
    });
    // ... the first exclusive-borrow of d stops here
    //
    // a second exclusive-borrow of d starts here...
    let it = d.get_string();
    // println!("CANNOT borrow data: {:?}", d.data);
    it.value.for_each(|e| {
        println!("{:?}", e);
    });
    // ... it is not used anymore below this line,
    // ... the second exclusive-borrow of d stops here
    //
    println!("can borrow data: {:?}", d.data);
}
/*
"elem 0"
"elem 1"
"elem 2"
"elem 3"
"elem 4"
"elem 5"
"elem 6"
"elem 7"
"elem 8"
"elem 9"
can borrow data: ["elem 0", "elem 1", "elem 2", "elem 3", "elem 4", "elem 5", "elem 6", "elem 7", "elem 8", "elem 9"]
*/