Strings don’t have any methods on them that allow a change to the value of the string. In other words: strings are immutable. When you call str.replace a new string is built and returned. >>> s1 = ‘Rohit’ >>> s2 = s1.replace(‘R’, ‘M’) >>> >>> s1 ‘Rohit’ >>> s2 ‘Mohit’ As you can see s1 … Read more
The reason the code with Cell compiles (ignoring the u2) and mutates is Cell‘s whole API takes & pointers: impl<T> Cell<T> where T: Copy { fn new(value: T) -> Cell<T> { … } fn get(&self) -> T { … } fn set(&self, value: T) { … } } It is carefully written to allow mutation … Read more
There are at least two reasons why this is disallowed: You would need to have two concurrent mutable references to map — one held by the iterator used in the for loop and one in the variable map to call map.remove. You have references to the key and the value within the map when trying … Read more
Yes, it is a bad idea. The reason is that if in-place and non-in-place operations have apparently identical output, then programmers will frequently mix up in-place operations and non-in-place operations (List.sort() vs. sorted()) and that results in hard-to-detect errors. In-place operations returning themselves can allow you to perform “method chaining”, however, this is bad practice … 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
In Rust, the compiler stops at the function call boundary when evaluating generic parameters, which includes generic lifetime parameters. In your case 1, you are calling a method: fn get_qux(&mut self) -> &mut Qux { &mut self.qux } This function indicates that all of self will be borrowed mutably, and that the returned reference will … 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
I believe the confusion is because you’re conflating names with storage. fn main() { let x = 5; // x_0 println!(“The value of x is {}”, x); let x = 6; // x_1 println!(“The value of x is {}”, x); } In this example, there is one name (x), and two storage locations (x_0 and … Read more
Usually the borrow checker can distinguish between the different fields of a structure, but this doesn’t work within closures (lambdas). Instead, borrow the second field outside the closure: let field2 = &strct.field2; strct.field1.retain(|v| !field2.contains(v));
First a pointed to the string “Dog”. Then you changed the variable a to point at a new string “Dog eats treats”. You didn’t actually mutate the string “Dog”. Strings are immutable, variables can point at whatever they want.