borrow-checker

I want to collect changes to a struct and apply them all at once. The basic outline looks like this: enum SomeEnum { Foo, Bar, } struct SomeStruct { attrib: SomeEnum, next_attrib: Option<SomeEnum>, } impl SomeStruct { pub fn apply_changes(&mut self) { if let Some(se) = self.next_attrib { self.attrib = se; } self.next_attrib = None; } } which yields the following compiler error: error[E0507]: cannot move out of borrowed content --> src/lib.rs:13:27 | 13 | if let Some(se) = self.next_attrib { | -- ^^^^ cannot move out of borrowed content | | | hint: to prevent move, use `ref se` or `ref mut se`

Suppose I have several structures like in the following example, and in the next() method I need to pull the next event using a user-provided buffer, but if this event is a comment, and ignore comments flag is set to true, I need to pull the next event again: struct Parser { ignore_comments: bool, } enum XmlEvent<'buf> { Comment(&'buf str), Other(&'buf str), } impl Parser { fn next<'buf>(&mut self, buffer: &'buf mut String) -> XmlEvent<'buf> { let result = loop { buffer.clear(); let temp_event = self.parse_outside_tag(buffer); match temp_event { XmlEvent::Comment(_) if self.ignore_comments =>

I'd like to use a HashMap to cache an expensive computation that's dependent on other entries in the map. The entry pattern only provides a mutable reference to the matched value, but not to the rest of the HashMap . I'd really appreciate feedback on a better way to solve this (incorrect) toy example: use std::collections::HashMap; use std::collections::hash_map::Entry::{Occupied, Vacant}; fn compute(cache: &mut HashMap<u32, u32>, input: u32) -> u32 { match cache.entry(input) { Vacant(entry) => if input > 2 { // Trivial placeholder for an expensive computation. *entry.insert(compute(&mut cache

I have the following code: pub struct Canvas<'a> { width: isize, height: isize, color: Color, surface: Surface, texture: Texture, renderer: &'a Renderer, } impl<'a> Canvas<'a> { pub fn new(width: isize, height: isize, renderer: &'a Renderer) -> Canvas<'a> { let color = Color::RGB(0, 30, 0); let mut surface = core::create_surface(width, height); let texture = Canvas::gen_texture(&mut surface, width, height, color, renderer); Canvas { width: width, height: height, color: color, surface: surface, texture: texture, renderer: renderer, } } pub fn color(&mut self, color: Color) -> &mut Canvas<'a> {

I'm writing a data structure in Rust. It contains a Vec of key-value pairs. When inserting into the structure, I need to find a matching key and update both the key and the value (which is actually a child pointer). The code looks a bit like this, where pivots is a ref mut to Vec<Pivot> and Pivot is just a struct with two fields: match pivots.iter_mut().find(|ref p| key <= p.min_key) { // first mutable borrow Some(ref mut pivot) => { // If there is one, insert into it and update the pivot key pivot.min_key = key; pivot.child.insert(key, value) // recursive call }, // o/w, insert a new leaf at

I'm tring to replace a value in a mutable borrow; moving part of it into the new value: enum Foo<T> { Bar(T), Baz(T), } impl<T> Foo<T> { fn switch(&mut self) { *self = match self { &mut Foo::Bar(val) => Foo::Baz(val), &mut Foo::Baz(val) => Foo::Bar(val), } } } The code above doesn't work, and understandibly so, moving the value out of self breaks the integrity of it. But since that value is dropped immediately afterwards, I (if not the compiler) could guarantee it's safety. Is there some way to achieve this? I feel like this is a job for unsafe code, but I'm not sure how that would work.