feat: use hashbrown

src/vm/env.rs

@@ -1,13 +1,12 @@
 use std::rc::Rc;
-
-use rpds::HashTrieMap;
+use hashbrown::HashMap;
 
 use crate::ty::internal::{AttrSet, Value};
 
 #[derive(Debug, Default, Clone)]
 pub struct Env<'vm> {
     last: Option<Rc<Env<'vm>>>,
-    map: HashTrieMap<usize, Value<'vm>>,
+    map: Rc<HashMap<usize, Value<'vm>>>,
 }
 
 impl<'vm> Env<'vm> {
@@ -16,18 +15,22 @@ impl<'vm> Env<'vm> {
     }
 
     pub fn lookup(&self, symbol: usize) -> Option<Value<'vm>> {
-        self.map.get(&symbol).cloned()
+        if let Some(val) = self.map.get(&symbol).cloned() {
+            return Some(val)
+        }
+        self.last.as_ref().map(|env| env.lookup(symbol)).flatten()
     }
 
     pub fn insert(&mut self, symbol: usize, value: Value<'vm>) {
-        self.map.insert_mut(symbol, value);
+        Rc::make_mut(&mut self.map).insert(symbol, value);
     }
 
     pub fn enter(self, new: impl Iterator<Item = (usize, Value<'vm>)>) -> Self {
-        let mut map = self.map.clone();
+        /* let mut map = self.map.clone();
         for (k, v) in new {
             map.insert_mut(k, v);
-        }
+        } */
+        let map = Rc::new(new.collect());
         let last = Some(
             Env {
                 last: self.last,
@@ -39,7 +42,7 @@ impl<'vm> Env<'vm> {
     }
 
     pub fn enter_with(self, new: Rc<AttrSet<'vm>>) -> Self {
-        let mut map = self.map.clone();
+        /* let mut map = self.map.clone();
         for (k, v) in new.as_inner().iter() {
             let v = if let Value::Builtins = v {
                 Value::AttrSet(new.clone())
@@ -47,7 +50,14 @@ impl<'vm> Env<'vm> {
                 v.clone()
             };
             map.insert_mut(k.clone(), v);
-        }
+        } */
+        let map = Rc::new(new.as_inner().iter().map(|(&k, v)| {
+            (k, if let Value::Builtins = v {
+                Value::AttrSet(new.clone())
+            } else {
+                v.clone()
+            })
+        }).collect());
         let last = Some(
             Env {
                 last: self.last.clone(),

src/vm/mod.rs

@@ -1,5 +1,5 @@
 use std::cell::RefCell;
-use std::collections::{HashMap, HashSet};
+use hashbrown::{HashMap, HashSet};
 use std::pin::Pin;
 
 use crate::builtins::env;
@@ -161,7 +161,7 @@ impl<'vm, 'jit: 'vm> VM<'jit> {
                     Div => lhs.div(rhs)?,
                     And => lhs.and(rhs),
                     Or => lhs.or(rhs),
-                    Eq => lhs.eq(rhs),
+                    Eq => lhs.eq(rhs, self),
                     Lt => lhs.lt(rhs),
                     Con => lhs.concat(rhs),
                     Upd => lhs.update(rhs),

src/vm/test.rs

@@ -1,10 +1,12 @@
 extern crate test;
 
+use hashbrown::HashMap;
+
 use inkwell::context::Context;
 use test::{Bencher, black_box};
 
 use ecow::EcoString;
-use rpds::{ht_map, vector_sync};
+use rpds::vector_sync;
 
 use crate::compile::compile;
 use crate::ir::downgrade;
@@ -24,6 +26,19 @@ fn test_expr(expr: &str, expected: Value) {
     assert_eq!(run(prog, jit).unwrap(), expected);
 }
 
+macro_rules! map {
+    ($($k:expr => $v:expr),*) => {
+        {
+            #[allow(unused_mut)]
+            let mut m = HashMap::new();
+            $(
+                m.insert($k, $v);
+            )*
+            m
+        }
+    };
+}
+
 macro_rules! thunk {
     () => {
         Value::Thunk
@@ -68,7 +83,7 @@ macro_rules! list {
 
 macro_rules! attrs {
     ($($x:tt)*) => (
-        Value::AttrSet(AttrSet::new(ht_map!{$($x)*}))
+        Value::AttrSet(AttrSet::new(map!{$($x)*}))
     )
 }