flattener

src/expr.rs

 #[derive(Debug)]
 pub enum Expr {
-    Lambda(Box<Expr>),
     Abs(Box<Expr>),
     App(Box<Expr>, Box<Expr>),
     Var(usize),
     DefinitionName(String),
 }
+
+#[derive(Debug)]
+pub enum FlattenedExpr {
+    Abs(Box<FlattenedExpr>),
+    App(Box<FlattenedExpr>, Box<FlattenedExpr>),
+    Var(usize),
+}

src/flatten.rs

+use std::collections::{HashMap, HashSet};
+
+use crate::expr::{Expr, FlattenedExpr};
+
+pub struct Flattener {
+    funcs: HashMap<String, Expr>,
+}
+
+impl Flattener {
+    pub fn new(funcs: HashMap<String, Expr>) -> Self {
+        Self { funcs }
+    }
+
+    pub fn flatten(&mut self, main: &Expr) -> Option<FlattenedExpr> {
+        self.flatten_expr(&main, HashSet::new())
+    }
+
+    fn flatten_expr<'a>(
+        &self,
+        expr: &'a Expr,
+        mut names: HashSet<&'a str>,
+    ) -> Option<FlattenedExpr> {
+        let ret = match expr {
+            Expr::Abs(expr) => FlattenedExpr::Abs(Box::new(self.flatten_expr(expr, names)?)),
+            Expr::App(left, right) => FlattenedExpr::App(
+                Box::new(self.flatten_expr(left, names.clone())?),
+                Box::new(self.flatten_expr(right, names)?),
+            ),
+            Expr::Var(x) => FlattenedExpr::Var(*x),
+            Expr::DefinitionName(name) => {
+                if names.contains(name.as_str()) {
+                    self.print_error(&format!("Recursive definition for ${}", name));
+                    return None;
+                }
+
+                let expr = match self.funcs.get(name) {
+                    Some(x) => x,
+                    None => {
+                        self.print_error(&format!("Unknown definition ${}", name));
+
+                        return None;
+                    }
+                };
+
+                names.insert(name);
+
+                self.flatten_expr(expr, names)?
+            }
+        };
+
+        Some(ret)
+    }
+
+    fn print_error(&self, err: &str) {
+        eprintln!("Error: {err}");
+    }
+}

src/main.rs

+use flatten::Flattener;
 use parser::Parser;
 use scanner::Scanner;
 
 mod expr;
+mod flatten;
 mod parser;
 mod scanner;
 mod token;
@@ -10,7 +12,6 @@ fn main() {
     let scanner = Scanner::new(
         "
 $false = λtf.f
-# mrow!
 $true = λtf.t
 
 λa.(a $true)
@@ -19,13 +20,11 @@ $true = λtf.t
 
     let tokens = scanner.scan_tokens().unwrap();
 
-    for t in &tokens {
-        println!("{} {:?}", t.line, t.token_type);
-    }
-
     let mut parser = Parser::new(tokens);
     let (funcs, main) = parser.parse().unwrap();
 
-    dbg!(funcs);
-    dbg!(main);
+    let mut flattener = Flattener::new(funcs);
+    let flat = flattener.flatten(&main);
+
+    dbg!(flat);
 }

src/parser.rs

@@ -122,7 +122,7 @@ impl Parser {
 
         for _ in 0..abs_count {
             self.env.pop().unwrap();
-            expr = Expr::Lambda(Box::new(expr));
+            expr = Expr::Abs(Box::new(expr));
         }
 
         Some(expr)