parsing works???

src/expr.rs

+use std::fmt::Display;
+
 use bitvec::{order::Msb0, vec::BitVec};
 
 #[derive(Debug)]
@@ -16,7 +18,7 @@ pub enum FlattenedExpr {
 }
 
 impl FlattenedExpr {
-    pub fn to_blc(self, bv: &mut BitVec<u8, Msb0>) {
+    pub fn to_blc(&self, bv: &mut BitVec<u8, Msb0>) {
         match self {
             FlattenedExpr::Abs(expr) => {
                 bv.push(false);
@@ -32,7 +34,7 @@ impl FlattenedExpr {
                 right.to_blc(bv);
             }
             FlattenedExpr::Var(x) => {
-                for _ in 0..=x {
+                for _ in 0..=*x {
                     bv.push(true);
                 }
 
@@ -41,3 +43,17 @@ impl FlattenedExpr {
         }
     }
 }
+
+impl Display for FlattenedExpr {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FlattenedExpr::Abs(expr) => {
+                write!(f, "λ{}", expr)?;
+            }
+            FlattenedExpr::App(left, right) => write!(f, "[{} {}]", left, right)?,
+            FlattenedExpr::Var(var) => write!(f, "{var}")?,
+        }
+
+        Ok(())
+    }
+}

src/flatten.rs

@@ -12,7 +12,7 @@ impl Flattener {
     }
 
     pub fn flatten(&mut self, main: &Expr) -> Option<FlattenedExpr> {
-        self.flatten_expr(&main, HashSet::new())
+        self.flatten_expr(main, HashSet::new())
     }
 
     fn flatten_expr<'a>(

src/main.rs

@@ -7,17 +7,21 @@ mod expr;
 mod flatten;
 mod parser;
 mod scanner;
+mod stmt;
 mod token;
 
 fn main() {
     let scanner = Scanner::new(
         "
-$false=λtf.f
-$omega=λa. (a a)
+        $false=λtf.f;
+        $omega=λa. (a a);
 
 
-λa.a($omega(λbcde.d(bb)(λf.fce)))$false
-",
+        (λa.a($omega(λbcde.d(bb)(λf.fce)))$false);
+        #(λabc.cb(ab));
+        #(λabc.cba);
+                ",
+        // "((λab.ba)(λa.a))",
     );
 
     let tokens = scanner.scan_tokens().unwrap();
@@ -28,12 +32,12 @@ $omega=λa. (a a)
     let mut flattener = Flattener::new(funcs);
     let flat = flattener.flatten(&main).unwrap();
 
-    dbg!(&flat);
+    println!("{flat}");
 
-    let mut bv = BitVec::new();
+    /*let mut bv = BitVec::new();
     flat.to_blc(&mut bv);
 
     for x in bv.as_raw_slice() {
         print!("{}", *x as char);
-    }
+    }*/
 }

src/parser.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use crate::{
     expr::Expr,
+    stmt::Stmt,
     token::{Token, TokenType},
 };
 
@@ -24,36 +25,14 @@ impl Parser {
         let mut definitions = HashMap::new();
         let mut main_expr = None;
         while !self.is_at_end() {
-            let t = self.peek().token_type.clone();
+            let stmt = self.stmt()?;
 
-            match t {
-                TokenType::DefinitionName(name) => {
-                    self.advance(); // consume definition name
-
-                    // function expr
-
-                    if self.peek().token_type != TokenType::Equals {
-                        self.print_error("Expected '=' after definition name");
-
-                        return None;
-                    }
-
-                    self.advance(); // consume equals
-
-                    let definition = self.expr()?;
-
-                    if definitions.contains_key(&name) {
-                        self.print_error(&format!("Duplicate definition for ${}", name));
-                        return None;
-                    }
-
-                    definitions.insert(name, definition);
+            match stmt {
+                Stmt::Definition(name, expr) => {
+                    definitions.insert(name, expr);
                 }
 
-                // main expr
-                _ => {
-                    let expr = self.expr()?;
-
+                Stmt::Main(expr) => {
                     if main_expr.is_some() {
                         self.print_error("Duplicate primary expression");
                         return None;
@@ -74,7 +53,51 @@ impl Parser {
         }
     }
 
+    fn stmt(&mut self) -> Option<Stmt> {
+        let stmt = if *self.peek_next() == TokenType::Equals {
+            // definition
+            let TokenType::DefinitionName(name) = &self.advance().token_type else {
+                self.print_error("Expected definition name before '='");
+                return None;
+            };
+
+            let name = name.clone();
+
+            // consume =
+            self.advance();
+
+            let expr = self.expr()?;
+
+            Stmt::Definition(name, expr)
+        } else {
+            Stmt::Main(self.expr()?)
+        };
+
+        // consume semicolon
+        if self.peek().token_type != TokenType::Semicolon {
+            self.print_error("Expected ';' after statement");
+            return None;
+        }
+
+        self.advance();
+
+        Some(stmt)
+    }
+
     fn expr(&mut self) -> Option<Expr> {
+        let mut expr = self.expr_once()?;
+
+        dbg!(&expr);
+
+        while !self.is_at_end_of_expr() {
+            let right = self.expr_once()?;
+            expr = Expr::App(Box::new(expr), Box::new(right));
+        }
+
+        Some(expr)
+    }
+
+    fn expr_once(&mut self) -> Option<Expr> {
         match &self.peek().token_type {
             TokenType::Lambda => self.abstraction(),
 
@@ -85,7 +108,22 @@ impl Parser {
                 Some(Expr::DefinitionName(name))
             }
 
-            TokenType::LeftParen => self.application(),
+            TokenType::LeftParen => {
+                self.advance(); // consume (
+
+                let expr = self.expr()?;
+
+                dbg!(&self.peek().token_type);
+
+                if self.peek().token_type != TokenType::RightParen {
+                    self.print_error("Expected ')'");
+                    return None;
+                }
+
+                self.advance(); // consume )
+
+                Some(expr)
+            }
 
             TokenType::Variable(c) => {
                 let c = *c;
@@ -95,6 +133,8 @@ impl Parser {
             }
 
             _ => {
+                dbg!(&self.peek().token_type);
+
                 self.print_error(
                     "Unexpected token. Expected one of 'λ', '/', '\\', '$', '(', or a variable",
                 );
@@ -128,23 +168,9 @@ impl Parser {
         Some(expr)
     }
 
-    fn application(&mut self) -> Option<Expr> {
-        self.advance(); // consume left paren
-
-        let left = self.expr()?;
-        let right = self.expr()?;
-
-        if self.peek().token_type != TokenType::RightParen {
-            self.print_error("Expected ')' after application");
-            return None;
-        }
-
-        self.advance(); // consume right paren
-
-        Some(Expr::App(Box::new(left), Box::new(right)))
-    }
-
     fn find_variable(&self, name: char) -> Option<usize> {
+        dbg!(name, &self.env);
+
         let ret = self
             .env
             .iter()
@@ -153,7 +179,7 @@ impl Parser {
             .map(|(i, _)| i);
 
         match ret {
-            Some(x) => Some(x),
+            Some(x) => Some(self.env.len() - x - 1),
             None => {
                 self.print_error(&format!("Unknown variable '{}'.", name));
 
@@ -182,7 +208,14 @@ impl Parser {
     }
 
     fn is_at_end(&self) -> bool {
-        self.tokens.len() == self.current
+        self.peek().token_type == TokenType::Eof
+    }
+
+    fn is_at_end_of_expr(&self) -> bool {
+        let tt = &self.peek().token_type;
+
+        // end of expr can be ), $, or end of file
+        matches!(tt, TokenType::RightParen | TokenType::Semicolon)
     }
 
     fn print_error(&self, err: &str) {

src/scanner.rs

@@ -26,6 +26,8 @@ impl Scanner {
             self.scan_token()?;
         }
 
+        self.add_token(TokenType::Eof);
+
         Ok(self.tokens)
     }
 
@@ -38,6 +40,7 @@ impl Scanner {
             ')' => RightParen,
             '.' => Period,
             '=' => Equals,
+            ';' => Semicolon,
             ' ' | '\r' | '\n' | '\t' => NoToken,
             '\\' | '/' | 'λ' => Lambda,
             _ if c.is_alphabetic() => Variable(c),

src/stmt.rs

+use crate::expr::Expr;
+
+pub enum Stmt {
+    Main(Expr),
+    Definition(String, Expr),
+}

src/token.rs

@@ -6,10 +6,12 @@ pub enum TokenType {
 
     Period,
     Equals,
+    Semicolon,
 
     LeftParen,
     RightParen,
 
+    Eof,
     NoToken,
 }