feat: lots of optimization

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

src/ty/internal/attrset.rs

@@ -1,11 +1,10 @@
-use std::cell::RefCell;
-use std::sync::Arc;
+use std::rc::Rc;
 
 use derive_more::Constructor;
-use rpds::HashTrieMapSync;
+use rpds::HashTrieMap;
 
 use crate::error::Result;
-use crate::vm::VM;
+use crate::vm::{Env, VM};
 
 use super::super::common::Symbol;
 use super::super::public as p;
@@ -13,13 +12,13 @@ use super::{ToPublic, Value};
 
 #[derive(Debug, Constructor, Clone, PartialEq)]
 pub struct AttrSet<'vm> {
-    data: HashTrieMapSync<Symbol, Value<'vm>>,
+    data: HashTrieMap<Symbol, Value<'vm>>,
 }
 
 impl<'vm> AttrSet<'vm> {
     pub fn empty() -> Self {
         AttrSet {
-            data: HashTrieMapSync::new_sync(),
+            data: HashTrieMap::new(),
         }
     }
 
@@ -34,14 +33,22 @@ impl<'vm> AttrSet<'vm> {
         self.data.insert_mut(sym, val);
     }
 
-    pub fn select(&self, sym: Symbol) -> Option<Value<'vm>> {
+    pub fn select(&self, sym: &Symbol) -> Option<Value<'vm>> {
         self.data.get(&sym).cloned()
     }
 
-    pub fn has_attr(&self, sym: Symbol) -> bool {
+    pub fn has_attr(&self, sym: &Symbol) -> bool {
         self.data.get(&sym).is_some()
     }
 
+    pub fn capture(&mut self, env: Rc<Env<'vm>>) {
+        self.data = self
+            .data
+            .into_iter()
+            .map(|(k, v)| (k.clone(), match v.clone() { x @ Value::ThunkRef(thunk) => { thunk.capture(env.clone()); x }, x => x }))
+            .collect();
+    }
+
     pub fn update(mut self, other: AttrSet<'vm>) -> AttrSet<'vm> {
         for (k, v) in other.data.iter() {
             self.push_attr_force(k.clone(), v.clone())
@@ -50,17 +57,17 @@ impl<'vm> AttrSet<'vm> {
     }
 
     pub fn update_rec(mut self, other: RecAttrSet<'vm>) -> AttrSet<'vm> {
-        for (k, v) in other.data.borrow().iter() {
+        for (k, v) in other.data.map.borrow().iter() {
             self.push_attr_force(k.clone(), v.clone())
         }
         self
     }
 
-    pub fn into_inner(self) -> HashTrieMapSync<Symbol, Value<'vm>> {
+    pub fn into_inner(self) -> HashTrieMap<Symbol, Value<'vm>> {
         self.data
     }
 
-    pub fn as_inner(&self) -> &HashTrieMapSync<Symbol, Value<'vm>> {
+    pub fn as_inner(&self) -> &HashTrieMap<Symbol, Value<'vm>> {
         &self.data
     }
 
@@ -92,37 +99,37 @@ impl ToPublic for AttrSet<'_> {
 
 #[derive(Debug, Constructor, Clone, PartialEq)]
 pub struct RecAttrSet<'vm> {
-    data: Arc<RefCell<HashTrieMapSync<Symbol, Value<'vm>>>>,
+    data: Rc<Env<'vm>>
 }
 
 impl<'vm> RecAttrSet<'vm> {
     pub fn empty() -> Self {
         RecAttrSet {
-            data: Arc::default(),
+            data: Rc::default(),
         }
     }
 
     pub fn push_attr_force(&mut self, sym: Symbol, val: Value<'vm>) {
-        self.data.borrow_mut().insert_mut(sym, val);
+        self.data.insert(sym, val);
     }
 
     pub fn push_attr(&mut self, sym: Symbol, val: Value<'vm>) {
-        if self.data.borrow().get(&sym).is_some() {
+        if self.data.lookup(&sym).is_some() {
             todo!()
         }
-        self.data.borrow_mut().insert_mut(sym, val);
+        self.data.insert(sym, val);
     }
 
-    pub fn select(&self, sym: Symbol) -> Option<Value<'vm>> {
-        self.data.borrow().get(&sym).cloned()
+    pub fn select(&self, sym: &Symbol) -> Option<Value<'vm>> {
+        self.data.lookup(sym)
     }
 
-    pub fn has_attr(&self, sym: Symbol) -> bool {
-        self.data.borrow().get(&sym).is_some()
+    pub fn has_attr(&self, sym: &Symbol) -> bool {
+        self.data.lookup(sym).is_some()
     }
 
     pub fn update(mut self, other: RecAttrSet<'vm>) -> RecAttrSet<'vm> {
-        for (k, v) in other.data.borrow().iter() {
+        for (k, v) in other.data.map.borrow().iter() {
             self.push_attr_force(k.clone(), v.clone())
         }
         self
@@ -131,6 +138,7 @@ impl<'vm> RecAttrSet<'vm> {
     pub fn update_normal(self, other: AttrSet<'vm>) -> AttrSet<'vm> {
         let map = self
             .data
+            .map
             .borrow()
             .into_iter()
             .map(|(k, v)| (k.clone(), v.clone()))
@@ -142,17 +150,18 @@ impl<'vm> RecAttrSet<'vm> {
         new
     }
 
-    pub fn into_inner(self) -> HashTrieMapSync<Symbol, Value<'vm>> {
-        self.data.borrow().clone()
+    pub fn into_inner(self) -> Rc<Env<'vm>> {
+        self.data
     }
 
-    pub fn from_inner(data: Arc<RefCell<HashTrieMapSync<Symbol, Value<'vm>>>>) -> Self {
+    pub fn from_inner(data: Rc<Env<'vm>>) -> Self {
         RecAttrSet { data }
     }
 
     pub fn force_deep(&mut self, vm: &VM<'vm>) -> Result<()> {
         let mut map: Vec<_> = self
             .data
+            .map
             .borrow()
             .into_iter()
             .map(|(k, v)| (k.clone(), v.clone()))
@@ -161,7 +170,7 @@ impl<'vm> RecAttrSet<'vm> {
             .map(|(_, v)| v.force_deep(vm).map(|_| ()))
             .find(|v| v.is_err())
             .map_or(Ok(()), |err| err)?;
-        *self.data.borrow_mut() = map.into_iter().collect();
+        *self.data.map.borrow_mut() = map.into_iter().collect();
         Ok(())
     }
 }
@@ -169,7 +178,7 @@ impl<'vm> RecAttrSet<'vm> {
 impl ToPublic for RecAttrSet<'_> {
     fn to_public(self, vm: &VM) -> p::Value {
         p::Value::AttrSet(p::AttrSet::new(
-            self.data
+            self.data.map
                 .borrow()
                 .iter()
                 .map(|(sym, value)| (sym.clone(), value.clone().to_public(vm)))