refactor execute to not panic and write tests

3 files changed, 21 insertions, 15 deletions

diff --git a/src/ast.rs b/src/ast.rs
index 4bbc7ed..68522ce 100644
--- a/src/ast.rs
+++ b/src/ast.rs
@@ -25,7 +25,7 @@ pub type Value = u64;
 pub enum Type {
     Empty,
     Unit,
-    Bool,
+    Boolean,
     Natural,
     Integer,
     // Float,
diff --git a/src/parser.rs b/src/parser.rs
index 2f918a8..719ee3f 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -34,7 +34,7 @@ pub fn parse_str(input: &str) -> Result<Expression, peg::error::ParseError<peg::
                 match k.as_str() {
                     "empty" => Type::Empty,
                     "unit" => Type::Unit,
-                    "bool" => Type::Bool,
+                    "bool" => Type::Boolean,
                     "nat" => Type::Natural,
                     "int" => Type::Integer,
                     _ => panic!("invalid type"), // fixme: raise an error
diff --git a/src/simple.rs b/src/simple.rs
index 9393c00..b7ef94a 100644
--- a/src/simple.rs
+++ b/src/simple.rs
@@ -12,27 +12,33 @@ pub fn check(context: Context, expression: Expression) {
 
 /// Evaluates an expression given a context (of variables) to a term.
 /// Panics on non-evaluatable code.
-pub fn execute(context: Context, expression: Expression) -> Term {
+pub fn execute(context: Context, expression: Expression) -> Result<Term, &'static str> {
     match expression {
-        Expression::Annotation { expr, .. } => return execute(context, *expr),
-        Expression::Constant { term } => return term,
-        Expression::Variable { id } => return context[&id],
-        Expression::Abstraction { .. } => panic!("attempting to execute an abstraction"),
+        Expression::Annotation { expr, .. } => execute(context, *expr),
+        Expression::Constant { term } => Ok(term),
+        Expression::Variable { id } => context.get(&id).ok_or("no such variable in context").map(|x| *x),
+        Expression::Abstraction { .. } => Err("attempting to execute an abstraction"),
         Expression::Application { func, arg } => {
             match *func {
                 Expression::Abstraction { param, func } => {
-                    let mut context = context;
-                    context.insert(param, execute(context.clone(), *arg));
-                    return execute(context, *func);
+                    let result = execute(context.clone(), *arg);
+                    match result {
+                        Ok(value) => {
+                            let mut context = context;
+                            context.insert(param, value);
+                            return execute(context, *func);
+                        },
+                        Err(e) => Err(e)
+                    }
                 },
-                _ => panic!("attempting to execute an application to nothing")
+                _ => Err("attempting to execute an application to nothing")
             }
         },
         Expression::Conditional { if_cond, if_then, if_else } => {
-            match execute(context.clone(), *if_cond).val {
-                1 => execute(context, *if_then),
-                0 => execute(context, *if_else),
-                _ => panic!("invalid type for a conditional")
+            match execute(context.clone(), *if_cond) {
+                Ok(Term { val: 1, .. }) => execute(context, *if_then),
+                Ok(Term { val: 0, .. }) => execute(context, *if_else),
+                _ => Err("invalid type for a conditional")
             }
         },
     }