borrowing

Something told me how to implement a linked list: enum List { Cons(u32, Box<List>), Nil, } impl List { fn prepend(self, elem: u32) -> List { Cons(elem, Box::new(self)) } } When I want to use prepend , I need to do the following: list = list.prepend(1); However, I want to create a function that does not need to create a new variable every time prepend returns. I just want to change the list variable itself using prepend : list.prepend(1); Here is one implementation that I come up with, but it's not right: fn my_prepend(&mut self, elem: u32) { *self = Cons(elem, Box::new(*self)); } The error is:

I'm trying to recurse down a structure of nodes, modifying them, and then returning the last Node that I get to. I solved the problems with mutable references in the loop using an example in the non-lexical lifetimes RFC . If I try to return the mutable reference to the last Node , I get a use of moved value error: #[derive(Debug)] struct Node { children: Vec<Node>, } impl Node { fn new(children: Vec<Self>) -> Self { Self { children } } fn get_last(&mut self) -> Option<&mut Node> { self.children.last_mut() } } fn main() { let mut root = Node::new(vec![Node::new(vec![])]); let current = &mut

Rust has the concepts of ownership and borrowing. If a function doesn't borrow its parameter as a reference, the arguments to that function are moved and will be deallocated once they go out of scope. Take this function: fn build_user(email: String, username: String) -> User { User { email: email, username: username, } } This function can be called as: let email = String::from("foo@example.com"); let username = String::from("username"); let user = build_user(email, username); Since email and username have been moved, they can no longer be used after build_user was called. This can be fixed by

I have a struct Foo : struct Foo { v: String, // Other data not important for the question } I want to handle a data stream and save the result into Vec<Foo> and also create an index for this Vec<Foo> on the field Foo::v . I want to use a HashMap<&str, usize> for the index, where the keys will be &Foo::v and the value is the position in the Vec<Foo> , but I'm open to other suggestions. I want to do the data stream handling as fast as possible, which requires not doing obvious things twice. For example, I want to: allocate a String only once per one data stream reading not search the index

Considering the following code: fn foo<'a, T: 'a>(t: T) -> Box<Fn() -> &'a T + 'a> { Box::new(move || &t) } What I expect: The type T has lifetime 'a . The value t live as long as T . t moves to the closure, so the closure live as long as t The closure returns a reference to t which was moved to the closure. So the reference is valid as long as the closure exists. There is no lifetime problem, the code compiles. What actually happens: The code does not compile: error[E0495]: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements --> src/lib.rs:2:22 | 2 | Box