feat: lots of optimization

* allocate vm stack on the stack
* use Rc instead of Arc
* optimize recursive attribute set

src/vm/env.rs

@@ -1,15 +1,15 @@
 use std::cell::RefCell;
-use std::sync::Arc;
+use std::rc::Rc;
 
-use rpds::HashTrieMapSync;
+use rpds::HashTrieMap;
 
 use crate::ty::common::Symbol;
 use crate::ty::internal::Value;
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, PartialEq)]
 pub struct Env<'vm> {
-    last: RefCell<Option<Arc<Env<'vm>>>>,
-    map: Arc<RefCell<HashTrieMapSync<Symbol, Value<'vm>>>>,
+    last: RefCell<Option<Rc<Env<'vm>>>>,
+    pub map: RefCell<HashTrieMap<Symbol, Value<'vm>>>,
 }
 
 impl Clone for Env<'_> {
@@ -19,16 +19,16 @@ impl Clone for Env<'_> {
                 self.last
                     .borrow()
                     .clone()
-                    .map(|e| Arc::new(e.as_ref().clone())),
+                    .map(|e| Rc::new(e.as_ref().clone())),
             ),
-            map: Arc::new(RefCell::new(self.map.borrow().clone())),
+            map: RefCell::new(self.map.borrow().clone()),
         }
     }
 }
 
 #[derive(Debug, Clone)]
 pub struct CapturedEnv<'vm> {
-    env: Arc<Env<'vm>>,
+    env: Rc<Env<'vm>>,
 }
 
 impl<'vm> Env<'vm> {
@@ -36,15 +36,15 @@ impl<'vm> Env<'vm> {
         Env::default()
     }
 
-    pub fn lookup(&self, symbol: Symbol) -> Option<Value<'vm>> {
-        self.map.borrow().get(&symbol).cloned()
+    pub fn lookup(&self, symbol: &Symbol) -> Option<Value<'vm>> {
+        self.map.borrow().get(symbol).cloned()
     }
 
     pub fn insert(&self, symbol: Symbol, value: Value<'vm>) {
         self.map.borrow_mut().insert_mut(symbol, value);
     }
 
-    pub fn enter(&self, new: HashTrieMapSync<Symbol, Value<'vm>>) {
+    pub fn enter(&self, new: HashTrieMap<Symbol, Value<'vm>>) {
         let mut map = self.map.borrow().clone();
         for (k, v) in new.iter() {
             map.insert_mut(k.clone(), v.clone());
@@ -53,17 +53,23 @@ impl<'vm> Env<'vm> {
             last: self.last.clone(),
             map: self.map.clone(),
         };
-        *self.last.borrow_mut() = Some(Arc::new(last));
+        *self.last.borrow_mut() = Some(Rc::new(last));
         *self.map.borrow_mut() = map;
     }
 
-    pub fn enter_rec(&self) -> Arc<RefCell<HashTrieMapSync<Symbol, Value<'vm>>>> {
+    pub fn enter_rec(self: &mut Rc<Self>, new: Rc<Env<'vm>>) {
+        let last = (*self.last.borrow_mut()).take();
+        *self = new;
+        *self.last.borrow_mut() = last;
+    }
+
+    pub fn new_rec(self: Rc<Self>) -> Rc<Self> {
         let last = Env {
             last: self.last.clone(),
             map: self.map.clone(),
         };
-        *self.last.borrow_mut() = Some(Arc::new(last));
-        self.map.clone()
+        *self.last.borrow_mut() = Some(Rc::new(last));
+        self.clone()
     }
 
     pub fn leave(&self) {
@@ -73,17 +79,17 @@ impl<'vm> Env<'vm> {
         *self.map.borrow_mut() = map;
     }
 
-    pub fn captured(self: Arc<Self>) -> CapturedEnv<'vm> {
+    pub fn captured(self: Rc<Self>) -> CapturedEnv<'vm> {
         CapturedEnv { env: self }
     }
 }
 
 impl<'vm> CapturedEnv<'vm> {
-    pub fn lookup(&self, symbol: Symbol) -> Option<Value<'vm>> {
+    pub fn lookup(&self, symbol: &Symbol) -> Option<Value<'vm>> {
         self.env.lookup(symbol)
     }
 
-    pub fn released(self) -> Arc<Env<'vm>> {
-        Arc::new(self.env.as_ref().clone())
+    pub fn released(self) -> Rc<Env<'vm>> {
+        Rc::new(self.env.as_ref().clone())
     }
 }