From dfc08ff2c6580bbeb3951b223e0332546ba3b0d9 Mon Sep 17 00:00:00 2001
From: Greg Brown <gmb60@cam.ac.uk>
Date: Thu, 6 May 2021 19:40:59 +0100
Subject: Introduce lambda expressions.

---
 src/nibble/mod.rs | 269 ++++++++++++++++++++++--------------------------------
 1 file changed, 111 insertions(+), 158 deletions(-)

(limited to 'src/nibble/mod.rs')

diff --git a/src/nibble/mod.rs b/src/nibble/mod.rs
index dbb05b0..f5417db 100644
--- a/src/nibble/mod.rs
+++ b/src/nibble/mod.rs
@@ -2,82 +2,33 @@ pub mod convert;
 
 use std::fmt;
 
-use proc_macro2::Span;
+use proc_macro2::TokenStream;
+use quote::{ToTokens, TokenStreamExt};
 use syn::{
-    bracketed,
     ext::IdentExt,
     parenthesized,
     parse::{Parse, ParseStream},
-    punctuated::{Pair, Punctuated},
-    token::{Bracket, Comma, Let, Match, Paren},
+    punctuated::Punctuated,
+    token::{Let, Match, Paren},
     LitStr, Token,
 };
 
-use crate::chomp::{Name, ast::{self, TopLevel}};
-
-use convert::{Context, Convert, ConvertError};
-
 pub type Epsilon = Token![_];
 
 pub type Ident = syn::Ident;
 
 pub type Literal = LitStr;
 
-#[derive(Clone)]
-pub struct ArgList<T> {
-    paren_token: Paren,
-    args: Punctuated<T, Comma>,
-}
-
-impl<T> ArgList<T> {
-    pub fn span(&self) -> Span {
-        self.paren_token.span
-    }
-
-    pub fn len(&self) -> usize {
-        self.args.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.args.is_empty()
-    }
-}
-
-impl<T> IntoIterator for ArgList<T> {
-    type Item = T;
-
-    type IntoIter = <Punctuated<T, Comma> as IntoIterator>::IntoIter;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.args.into_iter()
-    }
-}
-
-impl<T: Parse> Parse for ArgList<T> {
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let args;
-        let paren_token = parenthesized!(args in input);
-        let args = args.call(Punctuated::parse_terminated)?;
-        Ok(Self { paren_token, args })
-    }
-}
-
-impl<T: fmt::Debug> fmt::Debug for ArgList<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "ArgList")?;
-        f.debug_list().entries(self.args.iter()).finish()
-    }
-}
-
 #[derive(Clone)]
 pub struct Fix {
     bang_token: Token![!],
     pub expr: Box<Term>,
 }
 
-impl Fix {
-    pub fn span(&self) -> Option<Span> {
-        self.bang_token.span.join(self.expr.span()?)
+impl ToTokens for Fix {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.bang_token.to_tokens(tokens);
+        self.expr.to_tokens(tokens);
     }
 }
 
@@ -101,6 +52,12 @@ pub struct ParenExpression {
     pub expr: Expression,
 }
 
+impl ToTokens for ParenExpression {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.paren_token.surround(tokens, |tokens| self.expr.to_tokens(tokens))
+    }
+}
+
 impl Parse for ParenExpression {
     fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
         let expr;
@@ -127,14 +84,14 @@ pub enum Term {
     Parens(ParenExpression),
 }
 
-impl Term {
-    pub fn span(&self) -> Option<Span> {
+impl ToTokens for Term {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         match self {
-            Self::Epsilon(e) => Some(e.span),
-            Self::Ident(i) => Some(i.span()),
-            Self::Literal(l) => Some(l.span()),
-            Self::Fix(f) => f.span(),
-            Self::Parens(p) => Some(p.paren_token.span),
+            Self::Epsilon(e) => e.to_tokens(tokens),
+            Self::Ident(i) => i.to_tokens(tokens),
+            Self::Literal(l) => l.to_tokens(tokens),
+            Self::Fix(f) => f.to_tokens(tokens),
+            Self::Parens(p) => p.to_tokens(tokens),
         }
     }
 }
@@ -174,18 +131,15 @@ impl fmt::Debug for Term {
 #[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 ToTokens for Call {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        tokens.append_all(&self.0)
     }
 }
 
 impl Parse for Call {
     fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let mut out = Vec::new();
-        out.push(input.parse()?);
+        let mut out = vec![input.parse()?];
         loop {
             let lookahead = input.lookahead1();
             if lookahead.peek(Token![_])
@@ -207,34 +161,22 @@ impl Parse for Call {
 #[derive(Clone)]
 pub struct Cat(pub Punctuated<Call, Token![.]>);
 
-impl Parse for Cat {
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        input.call(Punctuated::parse_separated_nonempty).map(Self)
+impl ToTokens for Cat {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.0.to_tokens(tokens)
     }
 }
 
-impl Cat {
-    pub fn span(&self) -> Option<Span> {
-        let mut iter = self.0.pairs();
-        let span = match iter.next()? {
-            Pair::Punctuated(t, p) => t.span().and_then(|s| s.join(p.span)),
-            Pair::End(t) => t.span(),
-        }?;
-
-        iter.try_fold(span, |span, pair| match pair {
-            Pair::Punctuated(t, p) => t
-                .span()
-                .and_then(|s| span.join(s))
-                .and_then(|s| s.join(p.span)),
-            Pair::End(t) => t.span().and_then(|s| span.join(s)),
-        })
+impl Parse for Cat {
+    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
+        input.call(Punctuated::parse_separated_nonempty).map(Self)
     }
 }
 
 impl fmt::Debug for Cat {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Cat")?;
-        f.debug_list().entries(self.0.iter()).finish()
+        f.debug_list().entries(&self.0).finish()
     }
 }
 
@@ -244,9 +186,10 @@ pub struct Label {
     pub label: Ident,
 }
 
-impl Label {
-    pub fn span(&self) -> Option<Span> {
-        self.colon_tok.span.join(self.label.span())
+impl ToTokens for Label {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.colon_tok.to_tokens(tokens);
+        self.label.to_tokens(tokens);
     }
 }
 
@@ -270,13 +213,12 @@ pub struct Labelled {
     pub label: Option<Label>,
 }
 
-impl Labelled {
-    pub fn span(&self) -> Option<Span> {
-        self.cat.span().and_then(|s| {
-            self.label
-                .as_ref()
-                .and_then(|l| l.span().and_then(|t| s.join(t)))
-        })
+impl ToTokens for Labelled {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.cat.to_tokens(tokens);
+        if let Some(label) = &self.label {
+            label.to_tokens(tokens);
+        }
     }
 }
 
@@ -295,21 +237,9 @@ impl Parse for Labelled {
 #[derive(Clone)]
 pub struct Alt(pub Punctuated<Labelled, Token![|]>);
 
-impl Alt {
-    pub fn span(&self) -> Option<Span> {
-        let mut iter = self.0.pairs();
-        let span = match iter.next()? {
-            Pair::Punctuated(t, p) => t.span().and_then(|s| s.join(p.span)),
-            Pair::End(t) => t.span(),
-        }?;
-
-        iter.try_fold(span, |span, pair| match pair {
-            Pair::Punctuated(t, p) => t
-                .span()
-                .and_then(|s| span.join(s))
-                .and_then(|s| s.join(p.span)),
-            Pair::End(t) => t.span().and_then(|s| span.join(s)),
-        })
+impl ToTokens for Alt {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.0.to_tokens(tokens)
     }
 }
 
@@ -322,27 +252,40 @@ impl Parse for Alt {
 impl fmt::Debug for Alt {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Alt")?;
-        f.debug_list().entries(self.0.iter()).finish()
+        f.debug_list().entries(&self.0).finish()
     }
 }
 #[derive(Clone)]
 pub struct Lambda {
     slash_tok_left: Token![/],
-    pub args: ArgList<Ident>,
+    pub args: Vec<Ident>,
     slash_tok_right: Token![/],
     pub expr: Alt,
 }
 
-impl Lambda {
-    pub fn span(&self) -> Option<Span> {
-        self.slash_tok_left.span.join(self.expr.span()?)
+impl ToTokens for Lambda {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.slash_tok_left.to_tokens(tokens);
+        tokens.append_all(&self.args);
+        self.slash_tok_right.to_tokens(tokens);
+        self.expr.to_tokens(tokens);
     }
 }
 
 impl Parse for Lambda {
     fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
         let slash_tok_left = input.parse()?;
-        let args = input.parse()?;
+        let mut args = Vec::new();
+        loop {
+            args.push(input.parse()?);
+            let lookahead = input.lookahead1();
+
+            if lookahead.peek(Token![/]) {
+                break;
+            } else if !lookahead.peek(Ident::peek_any) {
+                return Err(lookahead.error());
+            }
+        }
         let slash_tok_right = input.parse()?;
         let expr = input.parse()?;
         Ok(Self {
@@ -369,6 +312,15 @@ pub enum Expression {
     Lambda(Lambda),
 }
 
+impl ToTokens for Expression {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        match self {
+            Self::Alt(a) => a.to_tokens(tokens),
+            Self::Lambda(l) => l.to_tokens(tokens),
+        }
+    }
+}
+
 impl Parse for Expression {
     fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
         if input.peek(Token![/]) {
@@ -386,6 +338,14 @@ pub struct GoalStatement {
     semi_token: Token![;],
 }
 
+impl ToTokens for GoalStatement {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.match_token.to_tokens(tokens);
+        self.expr.to_tokens(tokens);
+        self.semi_token.to_tokens(tokens);
+    }
+}
+
 impl Parse for GoalStatement {
     fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
         let match_token = input.parse()?;
@@ -412,22 +372,40 @@ impl fmt::Debug for GoalStatement {
 pub struct LetStatement {
     let_token: Token![let],
     name: Ident,
-    args: Option<ArgList<Ident>>,
+    args: Vec<Ident>,
     eq_token: Token![=],
     expr: Expression,
     semi_token: Token![;],
     next: Box<Statement>,
 }
 
+impl ToTokens for LetStatement {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.let_token.to_tokens(tokens);
+        self.name.to_tokens(tokens);
+        tokens.append_all(&self.args);
+        self.eq_token.to_tokens(tokens);
+        self.expr.to_tokens(tokens);
+        self.semi_token.to_tokens(tokens);
+        self.next.to_tokens(tokens);
+    }
+}
+
 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 mut args = Vec::new();
+        loop {
+            let lookahead = input.lookahead1();
+            if lookahead.peek(Token![=]) {
+                break;
+            } else if lookahead.peek(Ident::peek_any) {
+                args.push(input.parse()?);
+            } else {
+                return Err(lookahead.error());
+            }
+        }
         let eq_token = input.parse()?;
         let expr = input.parse()?;
         let semi_token = input.parse()?;
@@ -462,43 +440,18 @@ pub enum Statement {
     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;
+impl ToTokens for Statement {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        match self {
+            Self::Goal(g) => g.to_tokens(tokens),
+            Self::Let(l) => l.to_tokens(tokens),
         }
-
-        let goal = match stmt {
-            Statement::Goal(goal) => TopLevel::Goal(goal.expr.convert(&mut context)?),
-            Statement::Let(_) => unreachable!(),
-        };
-
-        Ok(name_val.into_iter().rfold(goal, |inner, (name, val)| {
-            TopLevel::Let(ast::Let {
-                name,
-                val,
-                inner: Box::new(inner),
-            })
-        }))
     }
 }
 
 impl Parse for Statement {
     fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let mut lookahead = input.lookahead1();
+        let lookahead = input.lookahead1();
 
         if lookahead.peek(Let) {
             input.parse().map(Self::Let)
-- 
cgit v1.2.3