You may want to re-read The Rust Programming Language, specifically the sections on: mutability mutable references vectors We can also iterate over mutable references to each element in a mutable vector in order to make changes to all the elements. The for loop in Listing 8-9 will add 50 to each element. let mut v … Read more
Normally, when you pass a mutable reference to a function, the compiler implicitly performs a reborrow. This produces a new borrow with a shorter lifetime. When the parameter is generic (and is not of the form &mut T), the compiler doesn’t do this reborrowing automatically1. However, you can do it manually by dereferencing your existing … Read more
hellow has shown how to get working code, but I want to dive a bit more into why your code does not compile. The code you have proposed cannot be statically verified to be memory safe. It’s entirely possible that your recursive calls attempt to access the same index. Check out this simplified code for … Read more
In short, &’a mut Chain<‘a> is extremely limiting and pervasive. For an immutable reference &T<‘a>, the compiler is allowed to shorten the lifetime of ‘a when necessary to match other lifetimes or as part of NLL (this is not always the case, it depends on what T is). However, it cannot do so for mutable … Read more
Essentially, you can’t assign the value to self.attrib if it’s still owned by self.next_atrrib. That means you need to remove the value from self.next_attrib and then give ownership to self.attrib. One way to do this would be to manually replace the value. For instance, you could use std::mem::replace to replace the value with None and … Read more
The simplest change you can make is to pass the reference to the closure: struct Tester { x: i8, } impl Tester { fn traverse<F>(&mut self, mut f: F) where F: FnMut(&mut Tester), { f(self); } } fn main() { let mut tester = Tester { x: 8 }; tester.traverse(|z| z.x += 1); println!(“{}”, tester.x); … Read more
It’s not going to work with plain references: let item = StructThatContainsString { id: “Some Key”.to_string(), other_data: 0, } ms.insert(&item.id, item); item is moved into the map, so there can’t be any pending borrows/references. Also, methods like get_mut() would become dangerous or impossible, as it would let you modify the item that has an outstanding … Read more
This one seems convoluted at first, but remember that String and &str are different beasts. String can live and be used on its own, but &str is just a reference to part of String. So, &str can live as long as referenced String lives. Lets see how it should work on return signatures. let title_text … Read more
The problem is rooted in the fact that there’s information that you know that the compiler doesn’t. As mentioned in the comments, you cannot mutate a value while there is a immutable reference to it — otherwise it wouldn’t be immutable! It happens that your function needs to access the data immutably once and then … Read more
Split your data and methods into smaller components, then you can take disjoint borrows to various components on self: fn fetch_access_token(_base_url: &str) -> String { String::new() } fn get_env_url() -> String { String::new() } #[derive(Default)] struct BaseUrl(Option<String>); impl BaseUrl { fn get(&mut self) -> &str { self.0.get_or_insert_with(|| get_env_url()) } } #[derive(Default)] struct App { base_url: … Read more