Unexpected slice borrowing guide when using `Rc` in Rust with nested structs
I'm trying to configure I'm reviewing some code and I'm running into a borrowing scenario while trying to work with nested structs and `Rc` in Rust. I have a struct `Node` that holds a reference to its children nodes, and I want to be able to get a slice of these children nodes to perform some operations on them. However, I'm working with an behavior that says "want to borrow `self.children` as mutable because `self` is also borrowed as immutable". Here's a simplified version of my code: ```rust use std::rc::{Rc, Weak}; struct Node { value: i32, children: Vec<Rc<Node>>, } impl Node { fn new(value: i32) -> Rc<Self> { Rc::new(Node { value, children: vec![] }) } fn add_child(&mut self, child: Rc<Node>) { self.children.push(child); } fn get_children_slice(&self) -> &[Rc<Node>] { &self.children } } fn main() { let parent = Node::new(1); let child1 = Node::new(2); let child2 = Node::new(3); // This part is causing the borrowing scenario parent.add_child(child1.clone()); parent.add_child(child2.clone()); // behavior occurs here let children_slice = parent.get_children_slice(); println!("Children: {:?}", children_slice); } ``` What I tried was to make `add_child` take `&mut self`, but I still face issues due to how `Rc` manages ownership. I thought that since I'm using `Rc`, I wouldn't have to deal with borrowing issues in this way. Could it be that the mutable borrow of `self` conflicts with immutable borrows from `Rc`? How should I structure my code to avoid this scenario? I'm using Rust 1.65.0. My team is using Rust for this mobile app. Has anyone else encountered this? For reference, this is a production CLI tool. Any feedback is welcome!