Assume schema rust definition

tree_inputs/src/lib.rs

@@ -0,0 +1,23 @@
+use schema::Program;
+
+pub mod schema;
+
+pub type Result = std::result::Result<(), egglog::Error>;
+
+pub fn run_test(build: &str, check: &str, progs: Vec<Program>) -> Result {
+    let program = format!(
+        "{}\n{build}\n{}\n{check}\n",
+        [include_str!("schema.egg"),].join("\n"),
+        include_str!("schedule.egg"),
+    );
+
+    println!("{}", program);
+
+    egglog::EGraph::default()
+        .parse_and_run_program(&program)
+        .map(|lines| {
+            for line in lines {
+                println!("{}", line);
+            }
+        })
+}

tree_inputs/src/schedule.egg

@@ -0,0 +1,5 @@
+(run-schedule
+  (repeat 6
+    (saturate always-run)
+    (saturate error-checking)
+    ))

tree_inputs/src/schema.rs

@@ -0,0 +1,71 @@
+//! This module mirrors `schema.egg`.
+//! No implementation or conversion should
+//! be implemented in this file.
+
+use std::rc::Rc;
+
+pub enum Type {
+    IntT,
+    BoolT,
+    UnitT,
+    /// Nested tuple types are not allowed.
+    TupleT(Vec<Rc<Type>>),
+}
+
+pub enum BinaryOp {
+    Add,
+    Sub,
+    Mul,
+    LessThan,
+    And,
+    Or,
+    Write,
+}
+
+pub enum UnaryOp {
+    Not,
+    Print,
+}
+
+pub enum Constant {
+    Int(i64),
+    Bool(bool),
+    Unit,
+}
+
+pub enum Order {
+    Parallel,
+    Sequential,
+}
+
+pub type RcExpr = Rc<Expr>;
+
+pub enum Assumption {
+    InLet(RcExpr),
+    InLoop(RcExpr, RcExpr),
+}
+
+pub enum Expr {
+    Const(Constant),
+    Bop(BinaryOp, RcExpr, RcExpr),
+    Uop(UnaryOp, RcExpr),
+    Get(RcExpr, i64),
+    Read(RcExpr, Type),
+    Call(String, RcExpr),
+    Empty(),
+    Push(Order, RcExpr, RcExpr),
+    Switch(RcExpr, Vec<RcExpr>),
+    If(RcExpr, RcExpr, RcExpr),
+    Let(RcExpr, RcExpr),
+    DoWhile(RcExpr, RcExpr),
+    Arg(Type),
+    Assume(Assumption, RcExpr),
+    Function(String, Type, Type, RcExpr),
+}
+
+pub struct Program {
+    /// must be a function
+    pub entry: Expr,
+    /// a list of other functions
+    pub functions: Vec<Expr>,
+}