Rust - 不能作为可变借用

Question

I would to understand how to insert value in a node in a binary tree:

use std::rc::Rc;
use std::cell::RefCell;

// Definition for a binary tree node.
#[derive(Debug, PartialEq, Eq)]
pub struct TreeNode {
  pub val: i32,
  pub left: Option<Rc<RefCell<TreeNode>>>,
  pub right: Option<Rc<RefCell<TreeNode>>>,
}

impl TreeNode {
  #[inline]
  pub fn new(val: i32) -> Self {
    TreeNode {
      val,
      left: None,
      right: None
    }
  }
}

/*
            1
          /  \
         2   3
       / 
      4 
*/

fn main() {
    let mut t = TreeNode::new(1);
    t.left = Some(Rc::new(RefCell::new (TreeNode::new(2))));
    t.right = Some(Rc::new(RefCell::new(TreeNode::new(3))));
    t.left.unwrap().get_mut().left = Some(Rc::new(RefCell::new(TreeNode::new(4)))); // throws error
}

Playground

The tree should look like the one as in the comment. On compiling it throws the error:

error[E0596]: cannot borrow data in an `Rc` as mutable
  --> src/main.rs:35:5
   |
35 |     t.left.unwrap().get_mut().left = Some(Rc::new(RefCell::new(TreeNode::new(4))));
   |     ^^^^^^^^^^^^^^^ cannot borrow as mutable
   |
   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Rc<RefCell<TreeNode>>`

How can I assign a new TreeNode to the left of value 2 ?

Update: I can't change the type of left and right from Option<Rc<RefCell<TreeNode>>> to anything else. Thanks!

Answer 1

Maybe you meant borrow_mut() instead of get_mut()

fn main() {
    let mut t = TreeNode::new(1);
    t.left = Some(Rc::new(RefCell::new(TreeNode::new(2))));
    t.right = Some(Rc::new(RefCell::new(TreeNode::new(3))));
    t.left.as_ref().unwrap().borrow_mut().left = Some(Rc::new(RefCell::new(TreeNode::new(4))));
}

Answer 2

With the updated question in mind, the incantation you're looking for is

t.left.unwrap().borrow_mut().left = Some(Rc::new(RefCell::new(TreeNode::new(4))));

get_mut is for when you already have a mutable reference to the RefCell , and you never have a mutable reference to a thing in an Rc for safety reasons. borrow_mut , on the other hand, is for circumventing the usual rules and getting a mutable reference to an immutable thing regardless. Note that, in either case, the Rc is transparent, since the Deref trait takes care of it for us.

It's wordy and clunky, and frankly I blame Leetcode for that. I suspect they told someone to go translate everything into Rust, and that person did not know Rust and just threw everything in a RefCell because they didn't know better. So please don't take this as a good representation of idiomatic Rust. That sample code is ugly, plain and simple. Rust is a much prettier language than that, I promise.