feat: usable?

src/vm/env.rs

@@ -1,63 +1,84 @@
+use std::cell::RefCell;
+use std::sync::Arc;
+
 use rpds::HashTrieMapSync;
 
 use crate::ty::common::Symbol;
 use crate::ty::internal::Value;
 
+#[derive(Debug, Default)]
 pub struct Env {
-    last: Option<Box<Env>>,
-    map: HashTrieMapSync<Symbol, Value>,
+    last: RefCell<Option<Arc<Env>>>,
+    map: Arc<RefCell<HashTrieMapSync<Symbol, Value>>>,
+}
+
+impl Clone for Env {
+    fn clone(&self) -> Self {
+        Env {
+            last: RefCell::new(self.last.borrow().clone().map(|e| Arc::new(e.as_ref().clone()))),
+            map: Arc::new(RefCell::new(self.map.borrow().clone()))
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
-pub struct LockedEnv {
-    map: HashTrieMapSync<Symbol, Value>
+pub struct CapturedEnv {
+    env: Arc<Env>,
 }
 
 impl Env {
     pub fn empty() -> Env {
-        Env {
-            last: None,
-            map: HashTrieMapSync::new_sync(),
-        }
+        Env::default()
     }
 
     pub fn lookup(&self, symbol: Symbol) -> Option<Value> {
-        self.map.get(&symbol).cloned()
+        self.map.borrow().get(&symbol).cloned()
     }
 
-    pub fn insert(&mut self, symbol: Symbol, value: Value) {
-        self.map.insert_mut(symbol, value);
+    pub fn insert(&self, symbol: Symbol, value: Value) {
+        self.map.borrow_mut().insert_mut(symbol, value);
     }
 
-    pub fn enter(&mut self, new: HashTrieMapSync<Symbol, Value>) {
-        let mut map = self.map.clone();
+    pub fn enter(&self, new: HashTrieMapSync<Symbol, Value>) {
+        let mut map = self.map.borrow().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));
+        let last = Env {
+            last: self.last.clone(),
+            map: self.map.clone(),
+        };
+        *self.last.borrow_mut() = Some(Arc::new(last));
+        *self.map.borrow_mut() = map;
     }
 
-    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;
+    pub fn enter_rec(&self) -> Arc<RefCell<HashTrieMapSync<Symbol, Value>>> {
+        let last = Env {
+            last: self.last.clone(),
+            map: self.map.clone(),
+        };
+        *self.last.borrow_mut() = Some(Arc::new(last));
+        self.map.clone()
     }
 
-    pub fn locked(&self) -> LockedEnv {
-        LockedEnv { map: self.map.clone() }
+    pub fn leave(&self) {
+        let last = std::mem::replace(&mut *self.last.borrow_mut(), None).unwrap();
+        let _ = std::mem::replace(&mut *self.last.borrow_mut(), last.last.borrow().clone());
+        let map = last.map.borrow().clone();
+        *self.map.borrow_mut() = map;
+    }
+
+    pub fn captured(self: Arc<Self>) -> CapturedEnv {
+        CapturedEnv { env: self }
     }
 }
 
-impl LockedEnv {
+impl CapturedEnv {
     pub fn lookup(&self, symbol: Symbol) -> Option<Value> {
-        self.map.get(&symbol).cloned()
+        self.env.lookup(symbol)
     }
 
-    pub fn unlocked(self) -> Env {
-        Env {
-            map: self.map,
-            last: None
-        }
+    pub fn released(self) -> Arc<Env> {
+        Arc::new(self.env.as_ref().clone())
     }
 }