feat: better builtins implementaion

get rid of circular references

src/ty/internal/attrset.rs

@@ -1,11 +1,13 @@
-use std::rc::Rc;
 use std::collections::HashSet;
+use std::rc::Rc;
 
 use derive_more::Constructor;
+use itertools::Itertools;
 use rpds::HashTrieMap;
 
 use crate::error::Result;
 use crate::vm::{Env, VM};
+
 use super::super::public as p;
 use super::Value;
 
@@ -27,7 +29,7 @@ impl<'vm> AttrSet<'vm> {
     }
 
     pub fn push_attr(&mut self, sym: usize, val: Value<'vm>) {
-        if self.data.get_mut(&sym).is_some() {
+        if self.data.get(&sym).is_some() {
             todo!()
         }
         self.data.insert_mut(sym, val);
@@ -42,17 +44,12 @@ impl<'vm> AttrSet<'vm> {
     }
 
     pub fn capture(&mut self, env: &Rc<Env<'vm>>) {
-        self
-            .data
-            .iter()
-            .for_each(|(_, v)| {
-                    match v.clone() {
-                        Value::Thunk(ref thunk) => {
-                            thunk.capture(env.clone());
-                        }
-                        _ => ()
-                    }
-            })
+        self.data.iter().for_each(|(_, v)| match v.clone() {
+            Value::Thunk(ref thunk) => {
+                thunk.capture(env.clone());
+            }
+            _ => (),
+        })
     }
 
     pub fn update(&mut self, other: &AttrSet<'vm>) {
@@ -61,20 +58,18 @@ impl<'vm> AttrSet<'vm> {
         }
     }
 
-    pub fn update_rec(&mut self, other: &RecAttrSet<'vm>) {
-        for (k, v) in other.data.map.borrow().iter() {
-            self.push_attr_force(k.clone(), v.clone())
-        }
-    }
-
     pub fn as_inner(&self) -> &HashTrieMap<usize, Value<'vm>> {
         &self.data
     }
 
+    pub fn from_inner(data: HashTrieMap<usize, Value<'vm>>) -> Self {
+        Self { data }
+    }
+
     pub fn force_deep(&mut self, vm: &'vm VM<'_>) -> Result<()> {
         let mut map: Vec<_> = self
             .data
-            .into_iter()
+            .iter()
             .map(|(k, v)| (k.clone(), v.clone()))
             .collect();
         for (_, v) in map.iter_mut() {
@@ -84,99 +79,20 @@ impl<'vm> AttrSet<'vm> {
         Ok(())
     }
 
-    pub fn to_public(&self, vm: &'vm VM, seen: &mut HashSet<Value<'vm>>) -> p::Value {
-        p::Value::AttrSet(p::AttrSet::new(
-            self.data
-                .iter()
-                .map(|(&sym, value)| (vm.get_sym(sym), value.clone().to_public(vm, seen)))
-                .collect(),
-        ))
-    }
-}
-
-#[derive(Debug, Constructor, Clone, PartialEq)]
-pub struct RecAttrSet<'vm> {
-    data: Rc<Env<'vm>>,
-}
-
-impl<'vm> RecAttrSet<'vm> {
-    pub fn empty() -> Self {
-        RecAttrSet {
-            data: Rc::default(),
-        }
-    }
-
-    pub fn push_attr_force(&mut self, sym: usize, val: Value<'vm>) {
-        self.data.insert(sym, val);
-    }
-
-    pub fn push_attr(&mut self, sym: usize, val: Value<'vm>) {
-        if self.data.lookup(sym).is_some() {
-            todo!()
-        }
-        self.data.insert(sym, val);
-    }
-
-    pub fn select(&self, sym: usize) -> Option<Value<'vm>> {
-        self.data.lookup(sym)
-    }
-
-    pub fn has_attr(&self, sym: usize) -> bool {
-        self.data.lookup(sym).is_some()
-    }
-
-    pub fn update(&mut self, other: RecAttrSet<'vm>) {
-        for (k, v) in other.data.map.borrow().iter() {
-            self.push_attr_force(k.clone(), v.clone())
-        }
-    }
-
-    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()))
-            .collect();
-        let mut new = AttrSet::new(map);
-        for (k, v) in other.data.iter() {
-            new.push_attr_force(k.clone(), v.clone())
-        }
-        new
-    }
-
-    pub fn into_inner(self) -> Rc<Env<'vm>> {
-        self.data
-    }
-
-    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()))
-            .collect();
-        map.iter_mut()
-            .map(|(_, v)| v.force_deep(vm).map(|_| ()))
-            .find(|v| v.is_err())
-            .map_or(Ok(()), |err| err)?;
-        *self.data.map.borrow_mut() = map.into_iter().collect();
-        Ok(())
+    pub fn eq_impl(&self, other: &AttrSet<'vm>, vm: &'vm VM<'_>) -> bool {
+        self.data.iter().len() == other.data.iter().len()
+            && std::iter::zip(
+                self.data.iter().sorted_by_key(|(k, _)| **k),
+                self.data.iter().sorted_by_key(|(k, _)| **k),
+            )
+            .all(|((_, v1), (_, v2))| v1.eq_impl(v2, vm))
     }
 
     pub fn to_public(&self, vm: &'vm VM, seen: &mut HashSet<Value<'vm>>) -> p::Value {
         p::Value::AttrSet(p::AttrSet::new(
             self.data
-                .map
-                .borrow()
                 .iter()
-                .map(|(&sym, value)| (vm.get_sym(sym), value.clone().to_public(vm, seen)))
+                .map(|(&sym, value)| (vm.get_sym(sym), value.to_public(vm, seen)))
                 .collect(),
         ))
     }