Cannot obtain a mutable reference when iterating a recursive structure: cannot borrow as mutable more than once at a time

by

It is possible… but I wish I had a more elegant solution.

The trick is NOT to borrow from anchor, and therefore to juggle between two accumulators:

  • one holding the reference to the current node
  • the other being assigned the reference to the next node

This leads me to:

impl Recursive {
    fn back(&mut self) -> &mut Link {
        let mut anchor = &mut self.root;

        loop {
            let tmp = anchor;
            if let Some(ref mut node) = *tmp {
                anchor = &mut node.next;
            } else {
                anchor = tmp;
                break;
            }
        }

        anchor
    }
}

Not exactly pretty, but this is something the borrow checker can get behind so ¯\_(ツ)_/¯.

@ker has improved on this by creating an unnamed temporary:

impl Recursive {
    fn back(&mut self) -> &mut Link {
        let mut anchor = &mut self.root;

        loop {
            match {anchor} {
                &mut Some(ref mut node) => anchor = &mut node.next,
                other => return other,
            }
        }
    }
}

The trick here is that using {anchor} moves the content of anchor into an unnamed temporary on which the match executes. Therefore, in the match block we are not borrowing from anchor but from the temporary, leaving us free to modify anchor. See the related blog post Stuff the Identity Function Does (in Rust).

More Related Contents:

  1. Cannot move out of value which is behind a shared reference when unwrapping
  2. Why does refactoring by extracting a method trigger a borrow checker error?
  3. What is this question mark operator about?
  4. When does a closure implement Fn, FnMut and FnOnce?
  5. How to test for equality between trait objects?
  6. How do I borrow a reference to what is inside an Option?
  7. error [E0716]: temporary value dropped while borrowed (rust)
  8. Can I get a trait object of a multi-trait instance without using a generic type?
  9. Trait implementation for both a trait object and for direct implementors of the trait
  10. Can’t borrow mutably within two different closures in the same scope
  11. Why does my variable not live long enough?
  12. How to iterate over and filter an array?
  13. If BufReader takes ownership of a stream, how can I read and write lines on it?
  14. How to fix lifetime error when function returns a serde Deserialize type?
  15. Is there another option to share an Arc in multiple closures besides cloning it before each closure?
  16. Why are recursive struct types illegal in Rust?
  17. Understanding Traits and Object Safety
  18. How can I mutate other elements of a HashMap when using the entry pattern?
  19. How do I pass a closure through raw pointers as an argument to a C function?
  20. Is there a way to use existing structs as enum variants?
  21. How can I create enums with constant values in Rust?
  22. Sized is not implemented for the type Fn
  23. Extend lifetime of variable
  24. Can’t implement a trait I don’t own for all types that implement a trait I do own
  25. Creating a vector of zeros for a specific size
  26. What is the purpose of the unit type in Rust?
  27. Why does the Rust compiler request I constrain a generic type parameter’s lifetime (error E0309)?
  28. Cannot pass self as callback parameter due to double borrowing
  29. How to print structs and arrays?
  30. Can Rust optimise away the bit-wise copy during move of an object someday?

Leave a Comment