UnBCIC-TP2
diff --git a/‎src/environment/environment.rs
Lines changed: 45 additions & 45 deletions b/‎src/environment/environment.rs
Lines changed: 45 additions & 45 deletions
diff --git a/‎src/main.rs
Lines changed: 1 addition & 1 deletion b/‎src/main.rs
Lines changed: 1 addition & 1 deletion
@@ -1,4 +1,3 @@
-
 use crate::ir::ast::Function;
 use crate::ir::ast::Name;
 
@@ -7,96 +6,97 @@ use std::collections::LinkedList;
 
 pub struct Scope<A> {
     pub variables: HashMap<Name, A>,
-    pub functions: HashMap<Name, Function>
+    pub functions: HashMap<Name, Function>,
 }
 
 impl<A> Scope<A> {
     fn new() -> Scope<A> {
-	Scope { variables: HashMap::new(), functions: HashMap::new() }
+        Scope {
+            variables: HashMap::new(),
+            functions: HashMap::new(),
+        }
     }
 
     fn map_variable(&mut self, var: Name, value: A) -> () {
-	self.variables.insert(var, value);
-	return ()
+        self.variables.insert(var, value);
+        return ();
     }
 
     fn lookup(&mut self, var: Name) -> Option<&A> {
-	self.variables.get(&var)
+        self.variables.get(&var)
     }
 }
 
 pub struct Environment<A> {
     pub globals: Scope<A>,
-    pub stack: LinkedList<Scope<A>>
+    pub stack: LinkedList<Scope<A>>,
 }
 
 impl<A> Environment<A> {
-
     pub fn new() -> Environment<A> {
-	Environment { globals: Scope::new(), stack: LinkedList::new() }
+        Environment {
+            globals: Scope::new(),
+            stack: LinkedList::new(),
+        }
     }
-    
+
     pub fn map_variable(&mut self, var: Name, value: A) -> () {
-	match self.stack.front_mut() {
-	    None => self.globals.map_variable(var, value),
-	    Some(top) => top.map_variable(var, value)
-		
-	};
-	return ()
+        match self.stack.front_mut() {
+            None => self.globals.map_variable(var, value),
+            Some(top) => top.map_variable(var, value),
+        };
+        return ();
     }
 
     pub fn lookup(&mut self, var: Name) -> Option<&A> {
-	match self.stack.front_mut() {
-	    None => self.globals.lookup(var),
-	    Some(top) => top.lookup(var)
-	}
+        match self.stack.front_mut() {
+            None => self.globals.lookup(var),
+            Some(top) => top.lookup(var),
+        }
     }
 
     pub fn push(&mut self) -> () {
-	self.stack.push_front(Scope::new());
+        self.stack.push_front(Scope::new());
     }
 
     pub fn pop(&mut self) -> () {
-	self.stack.pop_front();
+        self.stack.pop_front();
     }
 }
 
-
 #[cfg(test)]
 mod tests {
-    use crate::environment::environment::{Scope, Environment};
-    
+    use crate::environment::environment::{Environment, Scope};
+
     #[test]
     fn eval_map_and_lookup_var() {
-	let mut s: Scope<i32> = Scope::new();
+        let mut s: Scope<i32> = Scope::new();
+
+        s.map_variable("x".to_string(), 32);
+        s.map_variable("y".to_string(), 23);
 
-	s.map_variable("x".to_string(), 32);
-	s.map_variable("y".to_string(), 23);
-	
-	assert_eq!(Some(32), s.lookup("x".to_string()).copied());
-	assert_eq!(Some(23), s.lookup("y".to_string()).copied());
+        assert_eq!(Some(32), s.lookup("x".to_string()).copied());
+        assert_eq!(Some(23), s.lookup("y".to_string()).copied());
     }
 
     #[test]
     fn eval_environment() {
-	let mut env: Environment<i32> = Environment::new();
+        let mut env: Environment<i32> = Environment::new();
 
-	env.map_variable("x".to_string(), 32);
+        env.map_variable("x".to_string(), 32);
 
-	env.push();
+        env.push();
 
-	env.map_variable("x".to_string(), 55);
-	env.map_variable("y".to_string(), 23);
-	
-	assert_eq!(Some(55), env.lookup("x".to_string()).copied());
-	assert_eq!(Some(23), env.lookup("y".to_string()).copied());
-	assert_eq!(None, env.lookup("a".to_string()).copied());
+        env.map_variable("x".to_string(), 55);
+        env.map_variable("y".to_string(), 23);
 
-	env.pop();
+        assert_eq!(Some(55), env.lookup("x".to_string()).copied());
+        assert_eq!(Some(23), env.lookup("y".to_string()).copied());
+        assert_eq!(None, env.lookup("a".to_string()).copied());
 
-	assert_eq!(Some(32), env.lookup("x".to_string()).copied());
-	assert_eq!(None, env.lookup("y".to_string()).copied());
-    }
-    
+        env.pop();
 
+        assert_eq!(Some(32), env.lookup("x".to_string()).copied());
+        assert_eq!(None, env.lookup("y".to_string()).copied());
+    }
 }
@@ -10,11 +10,11 @@ use std::collections::HashMap;
 use std::fs::File;
 use std::io::Write;*/
 
+pub mod environment;
 pub mod interpreter;
 pub mod ir;
 pub mod parser;
 pub mod tc;
-pub mod environment;
 
 fn main() {
     println!("Hello, world!");