feat: function (WIP)

src/vm/vm.rs

@@ -1,3 +1,5 @@
+use std::ops::Index;
+
 use anyhow::Result;
 
 use crate::builtins::env;
@@ -81,8 +83,23 @@ impl VM {
                 let func = stack.pop()?;
                 stack.push(func.call(args))?;
             }
-            OpCode::Func { param, length } => {
-                todo!()
+            OpCode::Func { idx } => {
+                stack.push(Value::Func(Func::new(self.thunks[idx].unwrap_code())))?;
+            }
+            OpCode::PushIdentParam { 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);
+            }
+            OpCode::PushDefaultParam { idx } => {
+                stack.tos_mut()?.as_mut().unwrap_func().push_default_param(idx);
+            }
+            OpCode::SetEllipsis => {
+                stack.tos_mut()?.as_mut().unwrap_func().set_ellipsis();
+            }
+            OpCode::SetAlias { sym } => {
+                stack.tos_mut()?.as_mut().unwrap_func().set_alias(sym);
             }
             OpCode::Ret => {
                 todo!()

src/vm/vmthunk.rs

@@ -15,7 +15,7 @@ pub struct VmThunk {
     lock: RwLock<()>,
 }
 
-#[derive(IsVariant, Unwrap)]
+#[derive(IsVariant, Unwrap, Clone)]
 enum _VmThunk {
     Code(OpCodes),
     SuspendedFrom(*const VmThunk),
@@ -30,6 +30,11 @@ impl VmThunk {
         }
     }
 
+    pub fn unwrap_code(&self) -> OpCodes {
+        let _guard = self.lock.read().unwrap();
+        self.thunk.borrow().clone().unwrap_code()
+    }
+
     pub fn force(&self, vm: &VM, env: &mut Env) -> Result<Value> {
         {
             let _guard = self.lock.read().unwrap();
@@ -43,20 +48,18 @@ impl VmThunk {
                 _VmThunk::Code(_) => (),
             }
         }
-        {
-            let _guard = self.lock.write().unwrap();
-            let opcodes = std::mem::replace(
-                &mut *self.thunk.borrow_mut(),
-                _VmThunk::SuspendedFrom(self as *const VmThunk),
-            )
-            .unwrap_code();
-            let value = vm.eval(opcodes, env).unwrap();
-            let _ = std::mem::replace(
-                &mut *self.thunk.borrow_mut(),
-                _VmThunk::Value(value.clone()),
-            );
-            Ok(value)
-        }
+        let _guard = self.lock.write().unwrap();
+        let opcodes = std::mem::replace(
+            &mut *self.thunk.borrow_mut(),
+            _VmThunk::SuspendedFrom(self as *const VmThunk),
+        )
+        .unwrap_code();
+        let value = vm.eval(opcodes, env).unwrap();
+        let _ = std::mem::replace(
+            &mut *self.thunk.borrow_mut(),
+            _VmThunk::Value(value.clone()),
+        );
+        Ok(value)
     }
 
     pub fn value(&self) -> Option<Value> {