Adicionado Interpretador de Assert e Hashmap de Testes no Scope

Asserts executam no interpretador e retornam um Computation Continue caso passem ou Erro caso falhem. Environments podem armazenar declaração de testes (ainda a ser implementado pelo TestDef)

Author: The3rdMega

src/environment/environment.rs

@@ -9,6 +9,7 @@ pub struct Scope<A> {
     pub variables: HashMap<Name, (bool, A)>,
     pub functions: HashMap<Name, Function>,
     pub adts: HashMap<Name, Vec<ValueConstructor>>,
+    pub tests: HashMap<Name, Function>,
 }
 
 impl<A: Clone> Scope<A> {
@@ -17,6 +18,7 @@ impl<A: Clone> Scope<A> {
             variables: HashMap::new(),
             functions: HashMap::new(),
             adts: HashMap::new(),
+            tests: HashMap::new(),
         }
     }
 
@@ -30,6 +32,11 @@ impl<A: Clone> Scope<A> {
         return ();
     }
 
+    fn map_test(&mut self, test: Function) -> () {
+        self.tests.insert(test.name.clone(), test);
+        return ();
+    }
+
     fn map_adt(&mut self, name: Name, adt: Vec<ValueConstructor>) -> () {
         self.adts.insert(name.clone(), adt);
         return ();
@@ -45,6 +52,10 @@ impl<A: Clone> Scope<A> {
         self.functions.get(name)
     }
 
+    fn lookup_test(&self, name: &Name) -> Option<&Function> {
+        self.tests.get(name)
+    }
+
     fn lookup_adt(&self, name: &Name) -> Option<&Vec<ValueConstructor>> {
         self.adts.get(name)
     }
@@ -78,6 +89,13 @@ impl<A: Clone> Environment<A> {
         }
     }
 
+    pub fn map_test(&mut self, test: Function) -> () {
+        match self.stack.front_mut() {
+            None => self.globals.map_test(test),
+            Some(top) => top.map_test(test),
+        }
+    }
+
     pub fn map_adt(&mut self, name: Name, cons: Vec<ValueConstructor>) -> () {
         match self.stack.front_mut() {
             None => self.globals.map_adt(name, cons),
@@ -103,6 +121,15 @@ impl<A: Clone> Environment<A> {
         self.globals.lookup_function(name)
     }
 
+    pub fn lookup_test(&self, name: &Name) -> Option<&Function> {
+        for scope in self.stack.iter() {
+            if let Some(test) = scope.lookup_test(name) {
+                return Some(test);
+            }
+        }
+        self.globals.lookup_test(name)
+    }
+
     pub fn lookup_adt(&self, name: &Name) -> Option<&Vec<ValueConstructor>> {
         for scope in self.stack.iter() {
             if let Some(cons) = scope.lookup_adt(name) {