lifetime

I'm applying a closure on the iterator and I want to use stable, so I want to return a boxed Iterator . The obvious way to do so is the following: struct Foo; fn into_iterator(myvec: &Vec<Foo>) -> Box<Iterator<Item = &Foo>> { Box::new(myvec.iter()) } This fails because the borrow checker cannot infer the appropriate lifetimes. After some research, I've found Correct way to return an Iterator? , which brought me to adding + 'a : fn into_iterator<'a>(myvec: &'a Vec<Foo>) -> Box<Iterator<Item = &'a Foo> + 'a> { Box::new(myvec.iter()) } But I don't understand What this does And why it is needed

I was reading the lifetimes chapter of the Rust book, and I came across this example for a named/explicit lifetime: struct Foo<'a> { x: &'a i32, } fn main() { let x; // -+ x goes into scope // | { // | let y = &5; // ---+ y goes into scope let f = Foo { x: y }; // ---+ f goes into scope x = &f.x; // | | error here } // ---+ f and y go out of scope // | println!("{}", x); // | } // -+ x goes out of scope It's quite clear to me that the error being prevented by the compiler is the use-after-free of the reference assigned to x : after the inner scope is done, f and therefore &f.x become invalid,

I'm trying to implement something that looks like this minimal example: trait Bar<T> {} struct Foo<T> { data: Vec<Box<Bar<T>>>, } impl<T> Foo<T> { fn add<U: Bar<T>>(&mut self, x: U) { self.data.push(Box::new(x)); } } Since Rust defaults to (as far as I can tell) pass-by-ownership, my mental model thinks this should work. The add method takes ownership of object x and is able to move this object into a Box because it knows the full type U (and not just trait Bar<T> ). Once moved into a Box , the lifetime of the item inside the box should be tied to the actual lifetime of the box (e.g., when pop