borrow-checker

问题 I am studying Rust by Example and running code from the "Alias" page: struct Point { x: i32, y: i32, z: i32, } fn main() { let mut point = Point { x: 0, y: 0, z: 0 }; { let borrowed_point = &point; let another_borrow = &point; // Data can be accessed via the references and the original owner println!( "Point has coordinates: ({}, {}, {})", borrowed_point.x, another_borrow.y, point.z ); // Error! Can't borrow point as mutable because it's currently // borrowed as immutable. let mutable_borrow

问题 I am studying Rust by Example and running code from the "Alias" page: struct Point { x: i32, y: i32, z: i32, } fn main() { let mut point = Point { x: 0, y: 0, z: 0 }; { let borrowed_point = &point; let another_borrow = &point; // Data can be accessed via the references and the original owner println!( "Point has coordinates: ({}, {}, {})", borrowed_point.x, another_borrow.y, point.z ); // Error! Can't borrow point as mutable because it's currently // borrowed as immutable. let mutable_borrow

问题 I am trying to implement Debug for my custom List<T> using a while loop. use std::cell::RefCell; use std::rc::Rc; type Link<T> = Option<Rc<RefCell<Node<T>>>>; struct Node<T> { val: T, next: Link<T>, } struct List<T> { head: Link<T>, tail: Link<T>, len: usize, } use std::fmt; impl<T: fmt::Debug> fmt::Debug for List<T> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut temp = &self.head; while let Some(r) = temp { write!(f, "{:?} -> ", r.borrow().val); temp = &r.borrow().next;

问题 I wrote this code that borrows a mutable variable more than once and compiles without any error, but according to The Rust Programming Language this should not compile: fn main() { let mut s = String::from("hello"); println!("{}", s); test_three(&mut s); println!("{}", s); test_three(&mut s); println!("{}", s); } fn test_three(st: &mut String) { st.push('f'); } (playground) Is this a bug or there is new feature in Rust? 回答1: Nothing weird happens here; the mutable borrow becomes void every

问题 I wrote this code that borrows a mutable variable more than once and compiles without any error, but according to The Rust Programming Language this should not compile: fn main() { let mut s = String::from("hello"); println!("{}", s); test_three(&mut s); println!("{}", s); test_three(&mut s); println!("{}", s); } fn test_three(st: &mut String) { st.push('f'); } (playground) Is this a bug or there is new feature in Rust? 回答1: Nothing weird happens here; the mutable borrow becomes void every

问题 I wrote this code that borrows a mutable variable more than once and compiles without any error, but according to The Rust Programming Language this should not compile: fn main() { let mut s = String::from("hello"); println!("{}", s); test_three(&mut s); println!("{}", s); test_three(&mut s); println!("{}", s); } fn test_three(st: &mut String) { st.push('f'); } (playground) Is this a bug or there is new feature in Rust? 回答1: Nothing weird happens here; the mutable borrow becomes void every

问题 The following code involves a very subtle bit of borrow checker dodging. The code itself describes the reasoning. The questions: Is this actually safe? Is this the recommended way to express the unsafe operations performed? Should I use pointers instead? Will the new Polonius borrow checker be able to reason about patterns like this? /// Insert a new data element at a given key. pub fn insert<'a, K: Eq, V>(this: &'a mut Vec<(K, V)>, key: K, val: V) -> &'a mut V { // Safety: As indicated below

问题 The following code involves a very subtle bit of borrow checker dodging. The code itself describes the reasoning. The questions: Is this actually safe? Is this the recommended way to express the unsafe operations performed? Should I use pointers instead? Will the new Polonius borrow checker be able to reason about patterns like this? /// Insert a new data element at a given key. pub fn insert<'a, K: Eq, V>(this: &'a mut Vec<(K, V)>, key: K, val: V) -> &'a mut V { // Safety: As indicated below

问题 The following code involves a very subtle bit of borrow checker dodging. The code itself describes the reasoning. The questions: Is this actually safe? Is this the recommended way to express the unsafe operations performed? Should I use pointers instead? Will the new Polonius borrow checker be able to reason about patterns like this? /// Insert a new data element at a given key. pub fn insert<'a, K: Eq, V>(this: &'a mut Vec<(K, V)>, key: K, val: V) -> &'a mut V { // Safety: As indicated below

问题 The following code involves a very subtle bit of borrow checker dodging. The code itself describes the reasoning. The questions: Is this actually safe? Is this the recommended way to express the unsafe operations performed? Should I use pointers instead? Will the new Polonius borrow checker be able to reason about patterns like this? /// Insert a new data element at a given key. pub fn insert<'a, K: Eq, V>(this: &'a mut Vec<(K, V)>, key: K, val: V) -> &'a mut V { // Safety: As indicated below