feat: simple functions

src/vm/env.rs

@@ -8,6 +8,11 @@ pub struct Env {
     map: HashTrieMapSync<Symbol, Value>,
 }
 
+#[derive(Debug, Clone)]
+pub struct LockedEnv {
+    map: HashTrieMapSync<Symbol, Value>
+}
+
 impl Env {
     pub fn empty() -> Env {
         Env {
@@ -16,20 +21,19 @@ impl Env {
         }
     }
 
-    pub fn lookup(&self, symbol: Symbol) -> Value {
-        if let Some(value) = self.map.get(&symbol) {
-            value.clone()
-        } else {
-            let last = self.last.as_ref().unwrap();
-            last.lookup(symbol)
-        }
+    pub fn lookup(&self, symbol: Symbol) -> Option<Value> {
+        self.map.get(&symbol).cloned()
     }
 
     pub fn insert(&mut self, symbol: Symbol, value: Value) {
         self.map.insert_mut(symbol, value);
     }
 
-    pub fn enter(&mut self, map: HashTrieMapSync<Symbol, Value>) {
+    pub fn enter(&mut self, new: HashTrieMapSync<Symbol, Value>) {
+        let mut map = self.map.clone();
+        for (k, v) in new.iter() {
+            map.insert_mut(k.clone(), v.clone());
+        }
         let last = std::mem::replace(self, Env { last: None, map });
         self.last = Some(Box::new(last));
     }
@@ -37,6 +41,23 @@ impl Env {
     pub fn leave(&mut self) {
         let last = std::mem::replace(&mut self.last, None).unwrap();
         let _ = std::mem::replace(&mut self.last, last.last);
-        self.map = last.map.clone();
+        self.map = last.map;
+    }
+
+    pub fn locked(&self) -> LockedEnv {
+        LockedEnv { map: self.map.clone() }
+    }
+}
+
+impl LockedEnv {
+    pub fn lookup(&self, symbol: Symbol) -> Option<Value> {
+        self.map.get(&symbol).cloned()
+    }
+
+    pub fn unlocked(self) -> Env {
+        Env {
+            map: self.map,
+            last: None
+        }
     }
 }

src/vm/mod.rs

@@ -6,5 +6,5 @@ mod vmthunk;
 #[cfg(test)]
 mod test;
 
-pub use env::Env;
+pub use env::{Env, LockedEnv};
 pub use vm::VM;

src/vm/test.rs

@@ -171,4 +171,6 @@ fn test_let() {
 #[test]
 fn test_func() {
     test_expr("(x: x) 1", int!(1));
+    test_expr("(x: x) (x: x) 1", int!(1));
+    test_expr("(x: y: x + y) 1 1", int!(2));
 }

src/vm/vm.rs

@@ -1,11 +1,9 @@
-use std::ops::Index;
-
-use anyhow::Result;
+use anyhow::{Result, anyhow};
 
 use crate::builtins::env;
-use crate::bytecode::{self, Program, OpCode, OpCodes, Thunks, UnOp, BinOp};
-use crate::ty::internal::*;
+use crate::bytecode::{self, BinOp, OpCode, OpCodes, Program, Thunks, UnOp};
 use crate::ty::common::Symbol;
+use crate::ty::internal::*;
 use crate::ty::public as p;
 
 use super::env::Env;
@@ -81,19 +79,31 @@ impl VM {
                     args.insert(0, stack.pop()?);
                 }
                 let func = stack.pop()?;
-                stack.push(func.call(args))?;
+                stack.push(func.call(self, args))?;
             }
             OpCode::Func { idx } => {
-                stack.push(Value::Func(Func::new(self.thunks[idx].unwrap_code())))?;
+                stack.push(Value::Func(Func::new(env.locked(), self.thunks[idx].unwrap_code())))?;
             }
             OpCode::PushIdentParam { sym } => {
-                stack.tos_mut()?.as_mut().unwrap_func().push_ident_param(sym);
+                stack
+                    .tos_mut()?
+                    .as_mut()
+                    .unwrap_func()
+                    .push_ident_param(sym);
             }
             OpCode::PushFormalParam { sym } => {
-                stack.tos_mut()?.as_mut().unwrap_func().push_formal_param(sym);
+                stack
+                    .tos_mut()?
+                    .as_mut()
+                    .unwrap_func()
+                    .push_formal_param(sym);
             }
             OpCode::PushDefaultParam { idx } => {
-                stack.tos_mut()?.as_mut().unwrap_func().push_default_param(idx);
+                stack
+                    .tos_mut()?
+                    .as_mut()
+                    .unwrap_func()
+                    .push_default_param(idx);
             }
             OpCode::SetEllipsis => {
                 stack.tos_mut()?.as_mut().unwrap_func().set_ellipsis();
@@ -184,7 +194,10 @@ impl VM {
                 stack.tos_mut()?.has_attr(sym);
             }
             OpCode::LookUp { sym } => {
-                stack.push(env.lookup(Symbol::new(sym)))?;
+                stack.push(
+                    env.lookup(Symbol::new(sym.clone()))
+                        .ok_or(anyhow!(r#""{sym}" not found"#))?,
+                )?;
             }
             OpCode::EnterEnv => {
                 env.enter(stack.pop()?.unwrap_attr_set().to_data());