Add chumsky while exploring parser fixes

Author: Cypher1

Cargo.lock

@@ -1,7 +1,7 @@
 #!/usr/bin/env tako
 // test: all
 
-fib_helper(n: T, a: T, b: T, with T: Nat): T=if(n==0, a, fib_helper(n-1, b, a+b))
+fib_helper(n: T, a: T, b: T, forall T: Nat): T=if(n==0, a, fib_helper(n-1, b, a+b))
 
 fib(n: T, forall T: Nat): T=fib_helper(n, 0, 1)
 

examples/fib_acc.tk

@@ -54,6 +54,7 @@ llamada = { path = "../llamada", features = [ ] }
 better-std = { path = "../better-std", features = [ ] }
 entity-component-slab = { path = "../entity-component-slab", features = [ ] }
 test-each = "0.2.1"
+chumsky = { version = "0.10.1", features = ["pratt"] }
 
 [dev-dependencies]
 strum = "0.26.2"

takolib/Cargo.toml

@@ -26,7 +26,13 @@ impl std::fmt::Display for TError {
                 f,
                 "Clang failed with code {return_code} and error message: {error}"
             ),
-            ParseError(e) => write!(f, "{e}"),
+            ParseError(e) => {
+                write!(f, "{e}")?;
+                if let Some(location) = e.location() {
+                    write!(f, "at {location:?}")?;
+                }
+                Ok(())
+            }
             InternalError { message, location } => {
                 write!(f, "Internal error: {message}")?;
                 if let Some(location) = location {

takolib/src/error.rs

@@ -120,6 +120,7 @@ impl Ctx<'_> {
         let (_node_id, lit) = id.get(&self.ast.literals);
         let s = self.literals.get_str_by_loc(node.location.start);
         Ok(match lit {
+            Literal::Unit => todo!("{lit:?} {s:?}"),
             Literal::Bool => todo!("{lit:?} {s:?}"),
             Literal::Numeric => {
                 Prim::I32(s.expect("Should have string for literal").parse::<i32>()?)

takolib/src/interpreter.rs

@@ -0,0 +1,60 @@
+use chumsky::prelude::*;
+use chumsky::pratt::*;
+use chumsky::extra;
+
+enum Expr {
+    Add(Box<Self>, Box<Self>),
+    Sub(Box<Self>, Box<Self>),
+    Pow(Box<Self>, Box<Self>),
+    Neg(Box<Self>),
+    Factorial(Box<Self>),
+    Deref(Box<Self>),
+    Literal(i32),
+}
+
+impl std::fmt::Display for Expr {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Literal(literal) => write!(f, "{literal}"),
+            Self::Factorial(left) => write!(f, "({left}!)"),
+            Self::Deref(left) => write!(f, "(*{left})"),
+            Self::Neg(right) => write!(f, "(-{right})"),
+            Self::Add(left, right) => write!(f, "({left} + {right})"),
+            Self::Sub(left, right) => write!(f, "({left} - {right})"),
+            Self::Pow(left, right) => write!(f, "({left} ^ {right})"),
+        }
+    }
+}
+
+#[test]
+fn chumsky_simple_parser() {
+    let atom = text::int::<_, extra::Err<Simple<char>>>(10)
+        .from_str()
+        .unwrapped()
+        .map(Expr::Literal)
+        .padded();
+
+    let op = |c| just(c).padded();
+
+    let expr = atom.pratt((
+        // We want factorial to happen before any negation, so we need its precedence to be higher than `Expr::Neg`.
+        postfix(4, op('!'), |lhs, _, _| Expr::Factorial(Box::new(lhs))),
+        // Just like in math, we want that if we write -x^2, our parser parses that as -(x^2), so we need it to have
+        // exponents bind tighter than our prefix operators.
+        infix(right(3), op('^'), |l, _, r, _| Expr::Pow(Box::new(l), Box::new(r))),
+        // Notice the conflict with our `Expr::Sub`. This will still parse correctly. We want negation to happen before
+        // `+` and `-`, so we set its precedence higher.
+        prefix(2, op('-'), |_, rhs, _| Expr::Neg(Box::new(rhs))),
+        prefix(2, op('*'), |_, rhs, _| Expr::Deref(Box::new(rhs))),
+        // Our `-` and `+` bind the weakest, meaning that even if they occur first in an expression, they will be the
+        // last executed.
+        infix(left(1), op('+'), |l, _, r, _| Expr::Add(Box::new(l), Box::new(r))),
+        infix(left(1), op('-'), |l, _, r, _| Expr::Sub(Box::new(l), Box::new(r))),
+    ))
+        .map(|x| x.to_string());
+
+    assert_eq!(
+        expr.parse("*1 + -2! - -3^2").into_result(),
+        Ok("(((*1) + (-(2!))) - (-(3 ^ 2)))".to_string()),
+    );
+}