borrowing

I'm trying to grok Rust's ownership model. I'm trying to pass a reference to a containing object when calling a function on a struct. Here's my struct: pub struct Player {} impl Player { pub fn receive(self, app: &App) { } } As you can see, receive expects a reference to an App object. pub struct App { pub player: Player, } impl App { pub fn sender(self) { // how to call player.test() and pass self as a reference? self.player.receive(&self); } } The above code gives me "use of partially moved value: self ". Which makes sense, because App has move semantics so the value was moved into the

I don't have a particularly solid understanding of Rust's aliasing rules (and from what I've heard they're not solidly defined), but I'm having trouble understanding what makes this code example in the std::slice documentation okay. I'll repeat it here: let x = &mut [1, 2, 4]; let x_ptr = x.as_mut_ptr(); unsafe { for i in 0..x.len() { *x_ptr.offset(i as isize) += 2; } } assert_eq!(x, &[3, 4, 6]); The problem I see here is that x , being an &mut reference, can be assumed to be unique by the compiler. The contents of x get modified through x_ptr , and then read back via x , and I see no reason

This question already has an answer here: Cannot obtain a mutable reference when iterating a recursive structure: cannot borrow as mutable more than once at a time 4 answers I want to find some node in the tree and I need a pointer to the container of nodes: &mut Vec<Node> struct Node { c: Vec<Node>, v: i32, } impl Node { pub fn new(u: i32, n: Node) -> Node { let mut no = Node { c: Vec::new(), v: u, }; no.c.push(n); no } } fn main() { let mut a = Node::new(1, Node::new(2, Node::new(3, Node::new(4, Node::new(5, Node { c: Vec::new(), v: 6, }))))); let mut p: &mut Vec<Node> = &mut a.c; while p

This question already has an answer here: Why is it legal to borrow a temporary? 3 answers Why isn't this rvalue promoted to an lvalue as specified in the reference? 1 answer I found that this is able to compile: let x = &mut 10; *x = 20; This is very confusing. What are the semantics of mutably borrowing an literal? I come from C++, where the compiler will definitely not allow me to refer to a rvalue like this: int *x = &10; int &y = 10; Like C++, Rust has the concept of rvalues and lvalue. The reference calls them value expressions (rvalue) and place expressions (lvalue). Additionally, there

I am working with a LinkedList and I want to remove all elements which do not pass a test. However, I am running into the error cannot move out of borrowed content . From what I understand, this is because I am working with &mut self , so I do not have the right to invalidate (i.e. move) one of the contained values even for a moment to construct a new list of its values. In C++/Java, I would simply iterate the list and remove any elements which match a criteria. As there is no remove that I have yet found, I have interpreted it as an iterate, filter, and collect. The goal is to avoid creating

I built a GTK application with gtk-rs. When I build the main window, I want to use some dynamic parameters such as window height. I created a struct which contains all such settings and want to use this as an input parameter for the function building the UI: fn main() { let application = gtk::Application::new(Some("id"), Default::default()) .expect("Initialization failed..."); let config = Config {width: 100., height: 100.}; application.connect_activate(|app| { build_ui(app, config.clone()); }); // Use config further application.run(&args().collect::<Vec<_>>()); } #[derive(Debug, Clone)] pub