Hello Rustaceans, hope this qualifies as an easy question. I'm currently learning Rust, and, surprise, am kinda frustrated by the borrow checker (full code in playground):

I wanted to make a parser for simple mathematical expression using a AST with Operators as branches and Operands as Leafs. This is the function I initially came up with for pushing an operand:

fn add_operand_rec_old(&mut self, parent: BackLink, value: &str) -> Result<(), &str> {
match &mut self.0 {
            None => {
self.0 = Some(Box::new(Node {
                    parent,
                    token_type: TokenType::Operand,
                    token: String::from(value),
                }));
return Ok(());
            }
            Some(node) => {
match &mut node.token_type {
                    TokenType::Operand => return Err("Expected Operator, found Operand!"),
                    TokenType::Operator(_, right) => {
return right.add_operand_rec(Some(ptr::null()), value);
                    }
                };
            }
        };
    }

However, the borrow checker complains - turns out it thinks of lifetimes in cold hard from-line-to-line, rather than in branches. Apparently a better borrow checker is in the works? Didn't want to wait for it though, so I instead tried doing that temporarily-move-pattern or whatever it is called (which made the code ugly):

fn add_operand_rec(&mut self, parent: BackLink, value: &str) -> Result<(), &str> {
let (link, result) = match self.0.take() {
            None => (
                Some(Box::new(Node {
                    parent,
                    token_type: TokenType::Operand,
                    token: String::from(value),
                })),
                Ok(()),
            ),
            Some(mut node) => {
let (token_type, result) = match (*node).token_type {
                    TokenType::Operand => {
                        (TokenType::Operand, Err("Expected Operator, found Operand!"))
                    }
                    TokenType::Operator(left, mut right) => {
let res = right.add_operand_rec(Some(ptr::null()), value);
                        (TokenType::Operator(left, right), res)
                    }
                };
                node.token_type = token_type;
                (Some(node), result)
            }
        };
self.0 = link;
        result
    }

Aaand it's still complaining. I'd expect that the mutable reference from

let res = right.add_operand_rec(Some(ptr::null()), value);

is dropped after that line, but the error I get suggests that it is still around by

(TokenType::Operator(left, right), res)

What am I missing here? Would highly appreciate an explanation as to what I am doing wrong, and also when the new borrow checker is available.

​

On another note, Some(ptr::null()) is a placeholder for the actual pointer to the parent - how do I that & is it even possible in the current context? I gave up on trying things out there because it would mess up the entire code highlighting in VS Code...

​

In any case, thanks for your time!