astmaker

Build Abstract Syntax Trees and tree-walking models quickly in Rust.

Example

This example creates an AST for simple math expressions, and an interpreter to evaluate the result:

```rust use astmaker::{ast, model};

[derive(Debug, Clone, PartialEq)]

pub enum BinOp { Add, Sub, Mul, Div, }

[derive(Debug, Clone, PartialEq)]

pub enum UnOp { Add, Sub, }

ast!{ location = ();

pub node Expression = | BinOp -> Node | UnOp -> Node | Num -> Node ;

pub node BinaryOperation = { lhs: Node, op: BinOp, rhs: Node, }

pub node UnaryOperation = { op: UnOp, expr: Node, }

pub node Number = { value: f64, } }

pub struct Interpreter;

model!{ for Interpreter -> f64 { where Expression => { match node.data.asmut() { Expression::BinOp(childnode) => context.visit(childnode), Expression::UnOp(childnode) => context.visit(childnode), Expression::Num(childnode) => context.visit(child_node), } }, where BinaryOperation => { let lhs = context.visit(&mut node.data.lhs); let rhs = context.visit(&mut node.data.rhs);

  match node.data.op {
    BinOp::Add => lhs + rhs,
    BinOp::Sub => lhs - rhs,
    BinOp::Mul => lhs * rhs,
    BinOp::Div => lhs / rhs,
  }
},
where UnaryOperation => {
  let val = context.visit(&mut node.data.expr);

  match node.data.op {
    UnOp::Add => val,
    UnOp::Sub => -val,
  }
},
where Number => node.data.value,

} }

[test]

fn eval() { let mut tree = Node::new((), Expression::BinOp( Node::new((), BinaryOperation { lhs: Node::new((), Expression::Num( Node::new((), Number { value: 1.0 }) )), op: BinOp::Add, rhs: Node::new((), Expression::Num( Node::new((), Number { value: 2.0 }) )) }) ));

let mut interpreter = Interpreter;

assert_eq!(interpreter.visit(&mut tree), 3.0); } ```

Roadmap

• [ ] :memo: Documentation
• [ ] :sparkles: Generics support
• [ ] :sparkles: Lifetimes support
• [ ] :construction_worker: Github workflows to build, test & publish crate

License

This project is released under the terms of the MIT License.