Replace substitution with translation.

2 files changed, 29 insertions, 33 deletions

diff --git a/src/chomp/typed/infer.rs b/src/chomp/typed/infer.rs
index 44ea654..e2c2198 100644
--- a/src/chomp/typed/infer.rs
+++ b/src/chomp/typed/infer.rs
@@ -1,16 +1,8 @@
 use proc_macro2::Span;
 
-use crate::chomp::{
-    ast::{Alt, Call, Cat, Epsilon, Fix, Literal, Parameter, Variable},
-    visit::{Folder, Visitable},
-    Name,
-};
+use crate::chomp::{Name, ast::{Alt, Call, Cat, Epsilon, Fix, Lambda, Literal, NamedExpression, Variable, substitute::Translate}, visit::{Folder, Visitable}};
 
-use super::{
-    context::Context,
-    error::{TypeError, VariableError},
-    Type, Typed, TypedExpression,
-};
+use super::{Type, Typed, TypedExpression, context::Context, error::{TypeError, VariableError}};
 
 #[derive(Debug)]
 pub struct TypeInfer<'a> {
@@ -38,13 +30,10 @@ impl Folder for TypeInfer<'_> {
 
     fn fold_cat(&mut self, name: Option<Name>, span: Option<Span>, cat: Cat) -> Self::Out {
         let first = cat.first.fold(self)?;
-        let second = cat.second;
         let rest = cat.rest;
-        let punct = cat.punct;
         self.context
             .with_unguard(|context| -> Result<TypedExpression, TypeError> {
                 let mut infer = TypeInfer { context };
-                let second = second.fold(&mut infer)?;
                 let rest = rest
                     .into_iter()
                     .map(|(punct, term)| -> Result<_, TypeError> {
@@ -52,7 +41,7 @@ impl Folder for TypeInfer<'_> {
                     })
                     .collect::<Result<Vec<_>, _>>()?;
                 Ok(TypedExpression {
-                    inner: super::Cat::new(first, punct, second, rest)?.into(),
+                    inner: super::Cat::new(first, rest)?.into(),
                     name,
                     span,
                 })
@@ -61,15 +50,13 @@ impl Folder for TypeInfer<'_> {
 
     fn fold_alt(&mut self, name: Option<Name>, span: Option<Span>, alt: Alt) -> Self::Out {
         let first = alt.first.fold(self)?;
-        let second = alt.second.fold(self)?;
         let rest = alt
             .rest
             .into_iter()
             .map(|(punct, term)| -> Result<_, TypeError> { Ok((punct, term.fold(self)?)) })
             .collect::<Result<Vec<_>, _>>()?;
-        let punct = alt.punct;
         Ok(TypedExpression {
-            inner: super::Alt::new(first, punct, second, rest)?.into(),
+            inner: super::Alt::new(first, rest)?.into(),
             name,
             span,
         })
@@ -123,16 +110,18 @@ impl Folder for TypeInfer<'_> {
         })
     }
 
-    fn fold_parameter(
+    fn fold_call(&mut self, name: Option<Name>, span: Option<Span>, call: Call) -> Self::Out {
+        let translated = NamedExpression { name, expr: call.into(), span}.fold(&mut Translate::new())?;
+        let inner = translated.fold(self)?;
+        todo!()
+    }
+
+    fn fold_lambda(
         &mut self,
         _name: Option<Name>,
         _span: Option<Span>,
-        _param: Parameter,
+        _lambda: Lambda,
     ) -> Self::Out {
         unimplemented!()
     }
-
-    fn fold_call(&mut self, _name: Option<Name>, _span: Option<Span>, _call: Call) -> Self::Out {
-        unimplemented!()
-    }
 }
diff --git a/src/chomp/typed/mod.rs b/src/chomp/typed/mod.rs
index 2a9e365..cddb05a 100644
--- a/src/chomp/typed/mod.rs
+++ b/src/chomp/typed/mod.rs
@@ -1,4 +1,4 @@
-use std::{hash, iter};
+use std::hash;
 
 use proc_macro2::Span;
 
@@ -125,16 +125,16 @@ pub struct Cat {
 impl Cat {
     fn new<I: IntoIterator<Item = (Option<Span>, TypedExpression)>>(
         first: TypedExpression,
-        punct: Option<Span>,
-        second: TypedExpression,
         rest: I,
     ) -> Result<Self, CatError> {
         if first.get_type().nullable() {
-            return Err(CatError::FirstNullable { expr: first, punct });
+            return Err(CatError::FirstNullable {
+                expr: first,
+                punct: todo!(),
+            });
         }
 
-        iter::once((punct, second))
-            .chain(rest)
+        rest.into_iter()
             .try_fold(
                 (first.get_type().clone(), vec![first]),
                 |(ty, mut terms), (punct, right)| {
@@ -178,12 +178,9 @@ pub struct Alt {
 impl Alt {
     pub fn new<I: IntoIterator<Item = (Option<Span>, TypedExpression)>>(
         first: TypedExpression,
-        punct: Option<Span>,
-        second: TypedExpression,
         rest: I,
     ) -> Result<Self, AltError> {
-        iter::once((punct, second))
-            .chain(rest)
+        rest.into_iter()
             .try_fold(
                 (first.get_type().clone(), vec![first]),
                 |(ty, mut terms), (punct, right)| {
@@ -248,6 +245,14 @@ impl Variable {
 }
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct Call {
+    ty: Type,
+}
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct Lambda {}
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
 enum RawTypedExpression {
     Epsilon(Epsilon),
     Literal(Literal),
@@ -255,6 +260,8 @@ enum RawTypedExpression {
     Alt(Alt),
     Fix(Fix),
     Variable(Variable),
+    Call(Call),
+    Lambda(Lambda),
 }
 
 impl From<Epsilon> for RawTypedExpression {