feat: use hashbrown

src/builtins/mod.rs

@@ -1,7 +1,6 @@
+use hashbrown::HashMap;
 use std::rc::Rc;
 
-use rpds::HashTrieMap;
-
 use crate::ty::internal::{AttrSet, Const, PrimOp, Value};
 use crate::vm::{Env, VM};
 
@@ -43,14 +42,14 @@ pub fn env<'vm>(vm: &'vm VM) -> Env<'vm> {
         }),
     ];
 
-    let mut map = HashTrieMap::new();
+    let mut map = HashMap::new();
     for primop in primops {
         let primop = Rc::new(primop);
         env.insert(
             vm.new_sym(format!("__{}", primop.name)),
             Value::PrimOp(primop.clone()),
         );
-        map.insert_mut(vm.new_sym(primop.name), Value::PrimOp(primop));
+        map.insert(vm.new_sym(primop.name), Value::PrimOp(primop));
     }
     let attrs: Rc<_> = AttrSet::from_inner(map).into();
     let mut builtins = Value::AttrSet(attrs);

src/bytecode.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use hashbrown::HashMap;
 
 use ecow::EcoString;
 

src/ir.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use hashbrown::HashMap;
 
 use ecow::EcoString;
 use rnix::ast::{self, Expr};

src/ty/internal/attrset.rs

@@ -1,8 +1,7 @@
-use std::collections::HashSet;
+use hashbrown::{HashMap, HashSet};
 
 use derive_more::Constructor;
 use itertools::Itertools;
-use rpds::HashTrieMap;
 
 use crate::error::Result;
 use crate::vm::{Env, VM};
@@ -13,25 +12,25 @@ use super::Value;
 #[repr(C)]
 #[derive(Debug, Constructor, Clone, PartialEq)]
 pub struct AttrSet<'vm> {
-    data: HashTrieMap<usize, Value<'vm>>,
+    data: HashMap<usize, Value<'vm>>,
 }
 
 impl<'vm> AttrSet<'vm> {
     pub fn empty() -> Self {
         AttrSet {
-            data: HashTrieMap::new(),
+            data: HashMap::new(),
         }
     }
 
     pub fn push_attr_force(&mut self, sym: usize, val: Value<'vm>) {
-        self.data.insert_mut(sym, val);
+        self.data.insert(sym, val);
     }
 
     pub fn push_attr(&mut self, sym: usize, val: Value<'vm>) {
         if self.data.get(&sym).is_some() {
             todo!()
         }
-        self.data.insert_mut(sym, val);
+        self.data.insert(sym, val);
     }
 
     pub fn select(&self, sym: usize) -> Option<Value<'vm>> {
@@ -57,11 +56,11 @@ impl<'vm> AttrSet<'vm> {
         }
     }
 
-    pub fn as_inner(&self) -> &HashTrieMap<usize, Value<'vm>> {
+    pub fn as_inner(&self) -> &HashMap<usize, Value<'vm>> {
         &self.data
     }
 
-    pub fn from_inner(data: HashTrieMap<usize, Value<'vm>>) -> Self {
+    pub fn from_inner(data: HashMap<usize, Value<'vm>>) -> Self {
         Self { data }
     }
 

src/ty/internal/list.rs

@@ -1,4 +1,4 @@
-use std::collections::HashSet;
+use hashbrown::HashSet;
 
 use derive_more::Constructor;
 use rpds::Vector;

src/ty/internal/mod.rs

@@ -1,6 +1,6 @@
 use std::cell::OnceCell;
 use std::cell::RefCell;
-use std::collections::HashSet;
+use hashbrown::HashSet;
 use std::hash::Hash;
 use std::rc::Rc;
 
@@ -219,11 +219,11 @@ impl<'vm> Value<'vm> {
         }
     }
 
-    pub fn eq(self, other: Self) -> Self {
+    pub fn eq(self, other: Self, vm: &'vm VM<'_>) -> Self {
         use Const::Bool;
         match (self, other) {
             (x @ Value::Catchable(_), _) | (_, x @ Value::Catchable(_)) => x,
-            (s, other) => VmConst(Bool(s == other)),
+            (s, other) => VmConst(Bool(s.eq_impl(&other, vm))),
         }
     }
 

src/ty/public/mod.rs

@@ -1,3 +1,4 @@
+use hashbrown::HashMap;
 use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
 use std::ops::Deref;
 use std::sync::LazyLock;
@@ -5,7 +6,7 @@ use std::sync::LazyLock;
 use derive_more::{Constructor, IsVariant, Unwrap};
 use ecow::EcoString;
 use regex::Regex;
-use rpds::{HashTrieMap, VectorSync};
+use rpds::VectorSync;
 
 use super::common::*;
 
@@ -59,7 +60,7 @@ impl Symbol {
 
 #[derive(Constructor, Clone, PartialEq)]
 pub struct AttrSet {
-    data: HashTrieMap<Symbol, Value>,
+    data: HashMap<Symbol, Value>,
 }
 
 impl Debug for AttrSet {

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)*}))
     )
 }