borrow-checker

Like in the topic, why Rust prevents from multiple mutable references? I have read chapter in rust-book, and I understand that when we have multi-threaded code we are secured from data races but let's look at this code: fn main() { let mut x1 = String::from("hello"); let r1 = &mut x1; let r2 = &mut x1; r1.insert(0, 'w'); } This code is not running simultaneously so there is no possibility for data races. What is more when I am creating new thread and I want to use variable from parent thread in a new thread I have to move it so only new thread is an owner of the parent variable. The only

I'm trying to implement a commonly used pattern - using the result of a previous loop iteration in the next loop iteration. For example, to implement pagination where you need to give the id of the last value on the previous page. struct Result { str: String, } fn main() { let times = 10; let mut last: Option<&str> = None; for i in 0..times { let current = do_something(last); last = match current { Some(r) => Some(&r.str.to_owned()), None => None, }; } } fn do_something(o: Option<&str>) -> Option<Result> { Some(Result { str: "whatever string".to_string(), }) } However, I'm not sure how to

I have an array of Element s and I want to iterate over it to do some stuff, then iterate over all Element s inside the loop to do something. There is a relation between elements so I want to iterate to all other elements to check something. The elements are mutable references for reasons. It's a bit broad, but I'm trying to be general (maybe I should not). struct Element; impl Element { fn do_something(&self, _e: &Element) {} } fn main() { let mut elements = [Element, Element, Element, Element]; for e in &mut elements { // Do stuff... for f in &mut elements { e.do_something(f); } } } As

I am trying to implement a system that would use borrow checking/lifetimes in order to provide safe custom indices on a collection. Consider the following code: struct Graph(i32); struct Edge<'a>(&'a Graph, i32); impl Graph { pub fn get_edge(&self) -> Edge { Edge(&self, 0) } pub fn split(&mut self, Edge(_, edge_id): Edge) { self.0 = self.0 + edge_id; } pub fn join(&mut self, Edge(_, edge0_id): Edge, Edge(_, edge1_id): Edge) { self.0 = self.0 + edge0_id + edge1_id; } } fn main() { let mut graph = Graph(0); let edge = graph.get_edge(); graph.split(edge) } References to the graph borrowed by the

Editor's note: This question was asked before Rust 1.0. Since then, many functions and types have changed, as have certain language semantics. The code in the question is no longer valid, but the ideas expressed in the answers may be. I'm trying to list the files in a directory and copy the filename to my own Vec . I've tried several solutions, but it always ends up with a problem of not being able to create long enough living variables. I don't understand my mistake. fn getList(action_dir_path : &str) -> Vec<&str> { let v = fs::readdir(&Path::new(action_dir_path)) .unwrap() .iter() .map(|&x|

I am getting an error inside a nested lambda. let rows = vec![ vec![3, 6, 2, 8, 9, 0], vec![0, 0, 1, 4, 5, 1], ]; let pair_sums = rows.iter() .flat_map(|row| { (0 ..= row.len()).map(|i| row[i] + row[i + 1]) }) .collect::<Vec<_>>(); println!("{:?}", pair_sums); error[E0597]: `row` does not live long enough --> src/main.rs:9:40 | 9 | (0..row.len() - 1).map(|i| row[i] + row[i + 1]) | --- ^^^ does not live long enough | | | capture occurs here 10 | }) | - borrowed value only lives until here 11 | .collect::<Vec<_>>(); | - borrowed value needs to live until here I can sort of see why this is