I'm new to Rust and I've always wanted to make my own language, so I decided to try and make an interpreter, I'd say 80% of it is my own code with a few snippets here and there. It's uses a recursive decent parser but this raised the problem of stuff like 1-1-1 being read as (1-(1-1)) which is 0 not -1. I tried to implement a function to fix this but I'm struggling with how to not use moved values, since it's handling subtrees cloning would be an extremely bad idea. Here's the code:

**executor.rs:**

```
use syntaxtree::*;
pub fn evaluate(expr: Expression) -> Types {
match expr {
Expression::Atom(val) => return val,
Expression::Binary(val) => {
let fixed = fix(val.lhs, val.rhs, val.op);
let op = fixed.op;
let left = evaluate(fixed.lhs);
let right = evaluate(fixed.rhs);
match (left, right) {
(Types::Number(lval), Types::Number(rval)) => {
match op {
Operators::Plus => Types::Number(lval + rval),
Operators::Minus => Types::Number(lval - rval),
Operators::Asterisk => Types::Number(lval * rval),
Operators::Slash => Types::Number(lval / rval),
Operators::Caret => Types::Number(lval.powf(rval)),
_ => panic!("Not implemented yet."),
}
}
_ => panic!("End me")
}
},
Expression::Invalid => panic!()
}
}
fn fix(lhs: Expression, rhs : Expression, op : Operators) -> BinaryExpression {
match rhs {
Expression::Binary(binary_rhs) => {
let replacement = BinaryExpression::new(
lhs,
binary_rhs.lhs,
op.clone()
);
fix(Expression::Binary(Box::new(replacement)), binary_rhs.rhs, op)
}
_ => {
BinaryExpression::new(
lhs,
rhs,
op
)
}
}
}
```

And syntaxtree.rs for reference:

```
#[derive(Debug, PartialEq)]
pub enum Types {
String(String),
Ident(String),
Number(f64),
Bool(bool),
}
#[derive(PartialEq)]
pub enum Expression {
Invalid,
Atom(Types),
Binary(Box<BinaryExpression>),
}
#[derive(PartialEq, Clone)]
pub enum Operators {
Assign,
Plus,
Minus,
Bang,
Asterisk,
Slash,
Caret,
Percent,
LessThan,
GreaterThan,
Equal,
NotEqual,
LessEqual,
GreatEqual,
}
#[derive(PartialEq)]
pub struct BinaryExpression {
pub op: Operators,
pub lhs: Expression, pub rhs: Expression
}
impl BinaryExpression {
pub fn new(left: Expression, right: Expression, oper: Operators) -> BinaryExpression {
return BinaryExpression {lhs: left, rhs: right, op: oper}
}
}
```

And the output:

Any help would be appreciated!