Build tree from formatted input - rust

Question

I have been having a problem trying to come up with a solution to read a binary tree from a formatted input and build said tree in Rust. The borrow checker has been driving crazy and thus decided to take to the community.
Basically, the input looks like this:
1 2 3 4 5 6 N N 7 8
and it represents a tree that looks like this:
1
/ \
2 3
/ \ / \
4 5 6 N
/ \ /
N 7 8
with N meaning NULL.
To read this, in CPP I would usually read this tree by level doing kind of a Breadth first building of the tree using a queue to do so.
I was attempting the same approach in Rust but that is where hell broke lose on me. I am a beginner in Rust and of course I am being scolded by the borrow checker.
I am using the following TreeNode structure:
#[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
}
}
}
And here is the piece of code that is doing the reading of the tree from STDIN:
fn read_b_tree<T: io::BufRead>(scan: &mut Scanner<T>, size: usize)
-> Result<Option<Rc<RefCell<TreeNode>>>, Box<dyn Error>> {
if size == 0 {
Ok(None)
} else {
let r = scan.token::<String>();
if r == "N" {
Ok(None)
} else {
let mut q = VecDeque::new();
let root = Rc::new(RefCell::new(TreeNode::new(r.parse::<i32>()?)));
q.push_back(&root);
let mut cnt: usize = 1;
while cnt < size && !q.is_empty() {
let node = match q.pop_front() {
Some(node) => Ok(node),
_ => Err("Queue should not be empty"),
}?;
let v = Rc::clone(node);
let left = scan.token::<String>();
let right = scan.token::<String>();
if left != "N" {
let left_n = Rc::new(RefCell::new(TreeNode::new(left.parse::<i32>()?)));
v.borrow_mut().left = Some(Rc::clone(&left_n));
q.push_back(&left_n);
}
cnt += 1;
if right != "N" {
let right_n = Rc::new(RefCell::new(TreeNode::new(right.parse::<i32>()?)));
v.borrow_mut().right = Some(Rc::clone(&right_n));
q.push_back(&right_n);
}
cnt += 1;
}
Ok(Some(root))
}
}
}
As you can imagine, I ran into lifetime issues with this approach, such as:
error[E0597]: `right_n` does not live long enough
--> src/main.rs:146:33
|
125 | while cnt < size && !q.is_empty() {
| - borrow later used here
...
146 | q.push_back(&right_n);
| ^^^^^^^^ borrowed value does not live long enough
147 | }
| - `right_n` dropped here while still borrowed
I would be highly thankful to anyone who could give some pointers as to how I work out of this situation.
Sincerely,

Answer 1

The following code is shorter and demonstrates your problem:
fn read_b_tree() -> Result<Option<Rc<RefCell<TreeNode>>>, Box<dyn Error>> {
let r = String::new();
let mut q = VecDeque::new();
let root = Rc::new(RefCell::new(TreeNode::new(r.parse::<i32>()?)));
q.push_back(&root);
while !q.is_empty() {
if r != "N" {
let left_n = Rc::new(RefCell::new(TreeNode::new(r.parse::<i32>()?)));
q.push_back(&left_n);
}
}
Ok(Some(root))
}
The inferred type of q is VecDeque<&Rc<RefCell<TreeNode>>>, yet there is no reason why you choose this instead of VecDeque<Rc<RefCell<TreeNode>>> (Rc instead of &Rc) - Rc is already a reference so there is no need to do it a second time.
I think you inserted the & because without & there was an error use of moved value .... This error is correct: You use root after moving it to q. But that is not a problem, because you wanted to move a Rc to q and you can easily get one new by just cloning it root.clone() or Rc::clone(&root).
The fixed example is:
fn read_b_tree() -> Result<Option<Rc<RefCell<TreeNode>>>, Box<dyn Error>> {
let r = String::new();
let mut q = VecDeque::new();
let root = Rc::new(RefCell::new(TreeNode::new(r.parse::<i32>()?)));
q.push_back(root.clone());
while !q.is_empty() {
if r != "N" {
let left_n = Rc::new(RefCell::new(TreeNode::new(r.parse::<i32>()?)));
q.push_back(left_n); //this works in the example, but you will have to clone here too
}
}
Ok(Some(root))
}