feat: add Num & Str, implement type synthesize

Author: tonyfettes

src/stlc.rs

@@ -1,26 +1,28 @@
 use std::collections::HashMap;
 
 #[derive(Clone)]
-pub enum Term {
+pub enum Term<E> {
+    Num(u64),
+    Str(String),
     Var(String),
-    Fun(Environment, String, Box<Term>),
-    App(Box<Term>, Box<Term>),
+    Fun(E, String, Type, Box<Term<E>>),
+    App(Box<Term<E>>, Box<Term<E>>),
 }
 
 #[derive(Clone)]
-pub struct Environment(HashMap<String, Term>);
+pub struct Environment(HashMap<String, Term<Environment>>);
 
 impl Environment {
     pub fn init() -> Self {
         Self(HashMap::new())
     }
-    pub fn find(&self, name: &String) -> Option<Term> {
+    pub fn find(&self, name: &String) -> Option<Term<Environment>> {
         match self.0.get(name) {
             Some(term) => Some(term.clone()),
             None => None
         }
     }
-    pub fn push(&self, name: String, term: Term) -> Self {
+    pub fn push(&self, name: String, term: Term<Environment>) -> Self {
         let mut next_envt = self.0.clone();
         next_envt.insert(name, term);
         Self(next_envt)
@@ -29,8 +31,22 @@ impl Environment {
 
 #[derive(Clone)]
 pub enum Type {
-    Atom,
-    Func(Box<Type>, Box<Type>)
+    Num,
+    Str,
+    Fun(Box<Type>, Box<Type>)
+}
+
+impl PartialEq for Type {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Type::Num, Type::Num) => true,
+            (Type::Str, Type::Str) => true,
+            (Type::Fun(self_para, self_body),
+             Type::Fun(other_para, other_body)) =>
+                self_para.eq(other_para) && self_body.eq(self_body),
+            _ => false
+        }
+    }
 }
 
 pub struct Context(HashMap<String, Type>);
@@ -42,4 +58,36 @@ impl Context {
             None => None
         }
     }
+    pub fn push(&self, name: String, ty: Type) -> Self {
+        let mut new_ctx = self.0.clone();
+        new_ctx.insert(name, ty.clone());
+        Self(new_ctx)
+    }
+}
+
+fn synthesize(ctx: &Context, term: &Term<Context>) -> Option<Type> {
+    match term {
+        Term::Num(_) => Some(Type::Num),
+        Term::Str(_) => Some(Type::Str),
+        Term::Var(name) => ctx.find(name),
+        Term::Fun(_, name, para_type, body) => {
+            let new_ctx = ctx.push(name.clone(), para_type.clone());
+            let body_type = synthesize(&new_ctx, &body)?;
+            Some(Type::Fun(Box::new(para_type.clone()), Box::new(body_type)))
+        },
+        Term::App(lier, cant) => {
+            let lier = synthesize(&ctx, &lier)?;
+            let cant = synthesize(&ctx, &cant)?;
+            match lier {
+                Type::Fun(para_type, body_type) => {
+                    if *para_type == cant {
+                        Some(*body_type)
+                    } else {
+                        None
+                    }
+                },
+                _ => None
+            }
+        }
+    }
 }

src/utlc.rs

@@ -2,26 +2,30 @@ use std::collections::HashMap;
 
 #[derive(Clone)]
 pub enum Term {
+    Num(u64),
+    Str(String),
     Var(String),
     Fun(Environment, String, Box<Term>),
     App(Box<Term>, Box<Term>),
 }
 
 impl Term {
-    pub fn eval(envt: Environment, expr: Term) -> Term {
+    pub fn eval(env: Environment, expr: Term) -> Term {
         match expr {
+            Term::Num(num) => Term::Num(num),
+            Term::Str(str) => Term::Str(str),
             Term::Var(name) =>
-                match envt.find(&name) {
-                    Some(term) => Self::eval(envt, term),
+                match env.find(&name) {
+                    Some(term) => Self::eval(env, term),
                     None => Term::Var(name)
                 }
-            Term::Fun(_, patt, expr) => Term::Fun(envt, patt, expr),
+            Term::Fun(_, patt, expr) => Term::Fun(env, patt, expr),
             Term::App(lier, cant) => {
-                let lier_result = Self::eval(envt, *lier);
+                let lier_result = Self::eval(env, *lier);
                 match lier_result {
-                    Term::Fun(next_envt, patt, body) => {
-                        let envt = next_envt.push(patt, *body.clone());
-                        Self::eval(envt, *body)
+                    Term::Fun(new_env, patt, body) => {
+                        let env = new_env.push(patt, *body.clone());
+                        Self::eval(env, *body)
                     },
                     _ => Term::App(Box::new(lier_result), cant),
                 }