Update AST and parser for lambda expressions.

1 files changed, 193 insertions, 129 deletions

diff --git a/src/nibble/cst.rs b/src/nibble/cst.rs
index d8b71b7..6137640 100644
--- a/src/nibble/cst.rs
+++ b/src/nibble/cst.rs
@@ -2,16 +2,18 @@ use std::fmt;
 
 use proc_macro2::Span;
 use syn::{
-    bracketed,
     ext::IdentExt,
     parenthesized,
     parse::{Parse, ParseStream},
     punctuated::{Pair, Punctuated},
-    token::{Bracket, Comma, Let, Match, Paren},
+    token::{Comma, Let, Match, Paren},
     LitStr, Token,
 };
 
-use crate::chomp::{ast, Name};
+use crate::chomp::{
+    ast::{self, TopLevel},
+    Name,
+};
 
 use super::convert::{Context, Convert, ConvertError};
 
@@ -67,63 +69,29 @@ impl<T: fmt::Debug> fmt::Debug for ArgList<T> {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct Call {
-    pub name: Ident,
-    pub args: ArgList<Expression>,
-}
-
-impl Call {
-    pub fn span(&self) -> Option<Span> {
-        self.name.span().join(self.args.span())
-    }
-}
-
-impl Parse for Call {
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let name = input.call(Ident::parse_any)?;
-        let args = input.parse()?;
-        Ok(Self { name, args })
-    }
-}
-
 #[derive(Clone)]
 pub struct Fix {
-    bracket_token: Bracket,
-    pub arg: Ident,
-    paren_token: Paren,
-    pub expr: Expression,
+    bang_token: Token![!],
+    pub expr: Box<Term>,
 }
 
 impl Fix {
     pub fn span(&self) -> Option<Span> {
-        self.bracket_token.span.join(self.paren_token.span)
+        self.bang_token.span.join(self.expr.span()?)
     }
 }
 
 impl Parse for Fix {
     fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let arg;
-        let bracket_token = bracketed!(arg in input);
-        let arg = arg.call(Ident::parse_any)?;
-        let expr;
-        let paren_token = parenthesized!(expr in input);
-        let expr = expr.parse()?;
-        Ok(Self {
-            bracket_token,
-            arg,
-            paren_token,
-            expr,
-        })
+        let bang_token = input.parse()?;
+        let expr = input.parse()?;
+        Ok(Self { bang_token, expr })
     }
 }
 
 impl fmt::Debug for Fix {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Fix")
-            .field("arg", &self.arg)
-            .field("expr", &self.expr)
-            .finish()
+        f.debug_struct("Fix").field("expr", &self.expr).finish()
     }
 }
 
@@ -155,7 +123,6 @@ pub enum Term {
     Epsilon(Epsilon),
     Ident(Ident),
     Literal(Literal),
-    Call(Call),
     Fix(Fix),
     Parens(ParenExpression),
 }
@@ -166,7 +133,6 @@ impl Term {
             Self::Epsilon(e) => Some(e.span),
             Self::Ident(i) => Some(i.span()),
             Self::Literal(l) => Some(l.span()),
-            Self::Call(c) => c.span(),
             Self::Fix(f) => f.span(),
             Self::Parens(p) => Some(p.paren_token.span),
         }
@@ -181,18 +147,12 @@ impl Parse for Term {
             input.parse().map(Self::Epsilon)
         } else if lookahead.peek(LitStr) {
             input.parse().map(Self::Literal)
-        } else if lookahead.peek(Bracket) {
+        } else if lookahead.peek(Token![!]) {
             input.parse().map(Self::Fix)
         } else if lookahead.peek(Paren) {
             input.parse().map(Self::Parens)
         } else if lookahead.peek(Ident::peek_any) {
-            let name = input.call(Ident::parse_any)?;
-
-            if input.peek(Paren) {
-                input.parse().map(|args| Self::Call(Call { name, args }))
-            } else {
-                Ok(Self::Ident(name))
-            }
+            input.call(Ident::parse_any).map(Self::Ident)
         } else {
             Err(lookahead.error())
         }
@@ -205,15 +165,47 @@ impl fmt::Debug for Term {
             Term::Epsilon(_) => write!(f, "Term::Epsilon"),
             Term::Ident(i) => write!(f, "Term::Ident({:?})", i),
             Term::Literal(l) => write!(f, "Term::Literal({:?})", l.value()),
-            Term::Call(c) => write!(f, "Term::Call({:?})", c),
             Term::Fix(x) => write!(f, "Term::Fix({:?})", x),
             Term::Parens(p) => write!(f, "Term::Parens({:?})", p),
         }
     }
 }
 
+#[derive(Clone, Debug)]
+pub struct Call(pub Vec<Term>);
+
+impl Call {
+    pub fn span(&self) -> Option<Span> {
+        let mut iter = self.0.iter();
+        let first = iter.next()?.span()?;
+        iter.try_fold(first, |span, t| t.span().and_then(|s| span.join(s)))
+    }
+}
+
+impl Parse for Call {
+    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
+        let mut out = Vec::new();
+        out.push(input.parse()?);
+        loop {
+            let lookahead = input.lookahead1();
+            if lookahead.peek(Token![_])
+                || lookahead.peek(LitStr)
+                || lookahead.peek(Token![!])
+                || lookahead.peek(Paren)
+                || lookahead.peek(Ident::peek_any)
+            {
+                out.push(input.parse()?);
+            } else {
+                break;
+            }
+        }
+
+        Ok(Self(out))
+    }
+}
+
 #[derive(Clone)]
-pub struct Cat(pub Punctuated<Term, Token![.]>);
+pub struct Cat(pub Punctuated<Call, Token![.]>);
 
 impl Parse for Cat {
     fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
@@ -334,58 +326,60 @@ impl fmt::Debug for Alt {
     }
 }
 
-pub type Expression = Alt;
-
 #[derive(Clone)]
-pub struct LetStatement {
-    let_token: Token![let],
-    name: Ident,
-    args: Option<ArgList<Ident>>,
-    eq_token: Token![=],
-    expr: Expression,
-    semi_token: Token![;],
+pub struct Lambda {
+    slash_tok_left: Token![/],
+    pub args: ArgList<Ident>,
+    slash_tok_right: Token![/],
+    pub expr: Alt,
 }
 
-impl LetStatement {
+impl Lambda {
     pub fn span(&self) -> Option<Span> {
-        self.let_token.span.join(self.semi_token.span)
+        self.slash_tok_left.span.join(self.expr.span()?)
     }
 }
 
-impl Parse for LetStatement {
+impl Parse for Lambda {
     fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let let_token = input.parse()?;
-        let name = input.call(Ident::parse_any)?;
-        let args = if input.peek(Paren) {
-            Some(input.parse()?)
-        } else {
-            None
-        };
-        let eq_token = input.parse()?;
+        let slash_tok_left = input.parse()?;
+        let args = input.parse()?;
+        let slash_tok_right = input.parse()?;
         let expr = input.parse()?;
-        let semi_token = input.parse()?;
-
         Ok(Self {
-            let_token,
-            name,
+            slash_tok_left,
             args,
-            eq_token,
+            slash_tok_right,
             expr,
-            semi_token,
         })
     }
 }
 
-impl fmt::Debug for LetStatement {
+impl fmt::Debug for Lambda {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("LetStatement")
-            .field("name", &self.name)
+        f.debug_struct("Lambda")
             .field("args", &self.args)
             .field("expr", &self.expr)
             .finish()
     }
 }
 
+#[derive(Clone, Debug)]
+pub enum Expression {
+    Alt(Alt),
+    Lambda(Lambda),
+}
+
+impl Parse for Expression {
+    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
+        if input.peek(Token![/]) {
+            input.parse().map(Self::Lambda)
+        } else {
+            input.parse().map(Self::Alt)
+        }
+    }
+}
+
 #[derive(Clone)]
 pub struct GoalStatement {
     match_token: Token![match],
@@ -415,58 +409,128 @@ impl fmt::Debug for GoalStatement {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct File {
-    lets: Vec<LetStatement>,
-    goal: GoalStatement,
-}
-
-impl File {
-    pub fn convert(self) -> Result<(Vec<ast::Function>, ast::NamedExpression), ConvertError> {
-        let mut names = Vec::new();
-        let mut map = Vec::new();
-        for stmt in self.lets {
-            let span = stmt.span();
-            let name: Name = stmt.name.into();
-            let params = stmt
-                .args
-                .into_iter()
-                .flat_map(ArgList::into_iter)
-                .map(Name::from);
-            let mut context = Context::new(&names, params.clone());
-            let mut expr = stmt.expr.convert(&mut context)?;
-            names.push(name.clone());
-            expr.name = Some(name.clone());
-            map.push(ast::Function {
-                name,
-                params: params.map(Some).collect(),
-                expr,
-                span,
-            });
-        }
+#[derive(Clone)]
+pub struct LetStatement {
+    let_token: Token![let],
+    name: Ident,
+    args: Option<ArgList<Ident>>,
+    eq_token: Token![=],
+    expr: Expression,
+    semi_token: Token![;],
+    next: Box<Statement>,
+}
 
-        let mut context = Context::new(&names, Vec::new());
-        let goal = self.goal.expr.convert(&mut context)?;
-        Ok((map, goal))
+impl Parse for LetStatement {
+    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
+        let let_token = input.parse()?;
+        let name = input.call(Ident::parse_any)?;
+        let args = if input.peek(Paren) {
+            Some(input.parse()?)
+        } else {
+            None
+        };
+        let eq_token = input.parse()?;
+        let expr = input.parse()?;
+        let semi_token = input.parse()?;
+        let next = Box::new(input.parse()?);
+
+        Ok(Self {
+            let_token,
+            name,
+            args,
+            eq_token,
+            expr,
+            semi_token,
+            next,
+        })
     }
 }
 
-impl Parse for File {
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let mut lets = Vec::new();
-        let mut lookahead = input.lookahead1();
+impl fmt::Debug for LetStatement {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("LetStatement")
+            .field("name", &self.name)
+            .field("args", &self.args)
+            .field("expr", &self.expr)
+            .field("next", &self.next)
+            .finish()
+    }
+}
 
-        while lookahead.peek(Let) {
-            lets.push(input.parse()?);
-            lookahead = input.lookahead1();
+#[derive(Clone, Debug)]
+pub enum Statement {
+    Goal(GoalStatement),
+    Let(LetStatement),
+}
+
+impl Statement {
+    pub fn convert(self) -> Result<TopLevel, ConvertError> {
+        let mut stmt = self;
+        let mut context = Context::new();
+        let mut name_val = Vec::new();
+        while let Self::Let(let_stmt) = stmt {
+            let mut val = match let_stmt.args {
+                Some(args) => {
+                    todo!()
+                }
+                None => let_stmt.expr.convert(&mut context),
+            }?;
+            let name: Name = let_stmt.name.into();
+            val.name = val.name.or_else(|| Some(name.clone()));
+            context.push_variable(name.clone());
+            name_val.push((name, val));
+            stmt = *let_stmt.next;
         }
 
-        let goal = if lookahead.peek(Match) {
-            input.parse()?
-        } else {
-            return Err(lookahead.error());
+        let goal = match stmt {
+            Statement::Goal(goal) => TopLevel::Goal(goal.expr.convert(&mut context)?),
+            Statement::Let(_) => unreachable!(),
         };
 
-        Ok(Self { lets, goal })
+        Ok(name_val.into_iter().rfold(goal, |inner, (name, val)| {
+            TopLevel::Let(ast::Let {
+                name,
+                val,
+                inner: Box::new(inner),
+            })
+        }))
+        // let mut map = Vec::new();
+        // for stmt in self.lets {
+        //     let span = stmt.span();
+        //     let name: Name = stmt.name.into();
+        //     let params = stmt
+        //         .args
+        //         .into_iter()
+        //         .flat_map(ArgList::into_iter)
+        //         .map(Name::from);
+        //     let mut context = Context::new(&names, params.clone());
+        //     let mut expr = stmt.expr.convert(&mut context)?;
+        //     names.push(name.clone());
+        //     expr.name = Some(name.clone());
+        //     map.push(ast::Function {
+        //         name,
+        //         params: params.map(Some).collect(),
+        //         expr,
+        //         span,
+        //     });
+        // }
+
+        // let mut context = Context::new(&names, Vec::new());
+        // let goal = self.goal.expr.convert(&mut context)?;
+        // Ok((map, goal))
+    }
+}
+
+impl Parse for Statement {
+    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
+        let mut lookahead = input.lookahead1();
+
+        if lookahead.peek(Let) {
+            input.parse().map(Self::Let)
+        } else if lookahead.peek(Match) {
+            input.parse().map(Self::Goal)
+        } else {
+            Err(lookahead.error())
+        }
     }
 }