feat: lots of optimization

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

src/builtins/mod.rs

@@ -1,12 +1,12 @@
-use std::cell::RefCell;
+use std::cell::{OnceCell, RefCell};
-use std::sync::Arc;
+use std::rc::Rc;
 
 use crate::ty::common::Symbol;
 use crate::ty::internal::{_Thunk, Const, PrimOp, RecAttrSet, Thunk, Value};
 use crate::vm::Env;
 
-pub fn env<'vm>() -> Arc<Env<'vm>> {
+pub fn env<'vm>() -> Rc<Env<'vm>> {
-    let env = Arc::new(Env::empty());
+    let env = Rc::new(Env::empty());
     env.insert(Symbol::from("true"), Value::Const(Const::Bool(true)));
     env.insert(Symbol::from("false"), Value::Const(Const::Bool(false)));
 
@@ -43,24 +43,22 @@ pub fn env<'vm>() -> Arc<Env<'vm>> {
         }),
     ];
 
-    let builtins_env = Env::empty();
+    let builtins_env = Rc::new(Env::empty());
-    let map = builtins_env.enter_rec();
+    let map = builtins_env.clone().new_rec();
     for primop in primops {
         env.insert(
             Symbol::from(format!("__{}", primop.name)),
             Value::PrimOp(primop.clone()),
         );
-        map.borrow_mut()
+        map.insert(Symbol::from(primop.name), Value::PrimOp(primop));
-            .insert_mut(Symbol::from(primop.name), Value::PrimOp(primop));
     }
     let builtins = Value::RecAttrSet(RecAttrSet::from_inner(map.clone()));
     let thunk = Thunk {
         thunk: RefCell::new(_Thunk::Value(Box::new(builtins.clone()))),
         env: RefCell::default(),
     };
-    thunk.capture(Arc::new(builtins_env));
+    thunk.capture(builtins_env);
-    map.borrow_mut()
+    map.insert(Symbol::from("builtins"), Value::Thunk(thunk));
-        .insert_mut(Symbol::from("builtins"), Value::Thunk(thunk));
 
     env.insert(Symbol::from("builtins"), builtins);
     env

src/bytecode.rs

@@ -37,8 +37,8 @@ pub enum OpCode {
 
     /// push an empty attribute set onto stack
     AttrSet,
-    /// push an empty recursive attribute set onto stack
+    /// finalize the recursive attribute set at TOS
-    RecAttrSet,
+    FinalizeRec,
     /// [ .. set value ] consume 1 element, push a static kv pair (`name`, `value`) into `set`
     PushStaticAttr { name: EcoString },
     /// [ .. set name value ] consume 2 elements, push a dynamic kv pair (`name`, `value`) in to `set`

src/compile.rs

@@ -95,11 +95,7 @@ impl Compile for ir::Thunk {
 
 impl Compile for ir::Attrs {
     fn compile(self, comp: &mut Compiler) {
-        comp.push(if self.rec {
+        comp.push(OpCode::AttrSet);
-            OpCode::RecAttrSet
-        } else {
-            OpCode::AttrSet
-        });
         for stc in self.stcs {
             stc.1.compile(comp);
             comp.push(OpCode::PushStaticAttr { name: stc.0 });
@@ -110,7 +106,7 @@ impl Compile for ir::Attrs {
             comp.push(OpCode::PushDynamicAttr)
         }
         if self.rec {
-            comp.push(OpCode::LeaveEnv);
+            comp.push(OpCode::FinalizeRec);
         }
     }
 }

src/ir.rs

@@ -695,7 +695,9 @@ fn downgrade_attr(attr: ast::Attr, ctx: &mut DowngradeContext) -> Result<Attr> {
         Ident(ident) => Ok(Attr::Str(ident.to_string().into())),
         Str(string) => {
             let parts = string.normalized_parts();
-            if parts.len() == 1 {
+            if parts.len() == 0 {
+                Ok(Attr::Str("".into()))
+            } else if parts.len() == 1 {
                 match parts.into_iter().next().unwrap() {
                     Literal(ident) => Ok(Attr::Str(ident.into())),
                     Interpolation(interpol) => {

src/ty/internal/attrset.rs

@@ -1,11 +1,10 @@
-use std::cell::RefCell;
+use std::rc::Rc;
-use std::sync::Arc;
 
 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>> {
+    pub fn select(&self, sym: &Symbol) -> Option<Value<'vm>> {
-        self.data.borrow().get(&sym).cloned()
+        self.data.lookup(sym)
     }
 
-    pub fn has_attr(&self, sym: Symbol) -> bool {
+    pub fn has_attr(&self, sym: &Symbol) -> bool {
-        self.data.borrow().get(&sym).is_some()
+        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>> {
+    pub fn into_inner(self) -> Rc<Env<'vm>> {
-        self.data.borrow().clone()
+        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)))

src/ty/internal/func.rs

@@ -54,14 +54,14 @@ impl<'vm> Func<'vm> {
         let env = self.env.get().unwrap().clone().released();
 
         match &self.param {
-            Ident(ident) => env.enter(HashTrieMap::new_sync().insert(ident.clone().into(), arg)),
+            Ident(ident) => env.enter(HashTrieMap::new().insert(ident.clone().into(), arg)),
             Formals {
                 formals,
                 ellipsis,
                 alias,
             } => {
                 let arg = arg.unwrap_attr_set();
-                let mut new = HashTrieMap::new_sync();
+                let mut new = HashTrieMap::new();
                 if !ellipsis
                     && arg
                         .as_inner()
@@ -73,11 +73,12 @@ impl<'vm> Func<'vm> {
                     todo!()
                 }
                 for (formal, default) in formals {
+                    let formal = formal.clone().into();
                     let arg = arg
-                        .select(formal.clone().into())
+                        .select(&formal)
                         .or_else(|| default.map(|idx| Value::ThunkRef(vm.get_thunk(idx))))
                         .unwrap();
-                    new.insert_mut(formal.clone().into(), arg);
+                    new.insert_mut(formal, arg);
                 }
                 if let Some(alias) = alias {
                     new.insert_mut(alias.clone().into(), Value::AttrSet(arg));

src/ty/internal/mod.rs

@@ -1,5 +1,5 @@
 use std::cell::RefCell;
-use std::sync::Arc;
+use std::rc::Rc;
 
 use derive_more::{IsVariant, Unwrap};
 
@@ -32,7 +32,7 @@ pub trait ToPublic {
 #[derive(Debug, Clone)]
 pub struct Thunk<'vm> {
     pub thunk: RefCell<_Thunk<'vm>>,
-    pub env: RefCell<Option<Arc<Env<'vm>>>>,
+    pub env: RefCell<Option<Rc<Env<'vm>>>>,
 }
 
 #[derive(Debug, IsVariant, Unwrap, Clone)]
@@ -54,7 +54,7 @@ impl<'vm> Thunk<'vm> {
         self.thunk.borrow().clone().unwrap_code()
     }
 
-    pub fn capture(&self, env: Arc<Env<'vm>>) {
+    pub fn capture(&self, env: Rc<Env<'vm>>) {
         *self.env.borrow_mut() = Some(env);
     }
 
@@ -137,7 +137,7 @@ pub enum ValueAsMut<'v, 'vm: 'v> {
 }
 
 impl<'v, 'vm: 'v> Value<'vm> {
-    pub fn as_ref(&'vm self) -> ValueAsRef<'v, 'vm> {
+    pub fn as_ref(&'v self) -> ValueAsRef<'v, 'vm> {
         use Value::*;
         use ValueAsRef as R;
         match self {
@@ -154,7 +154,7 @@ impl<'v, 'vm: 'v> Value<'vm> {
         }
     }
 
-    pub fn as_mut(&'vm mut self) -> ValueAsMut<'v, 'vm> {
+    pub fn as_mut(&'v mut self) -> ValueAsMut<'v, 'vm> {
         use Value::*;
         use ValueAsMut as M;
         match self {
@@ -379,13 +379,13 @@ impl<'vm> Value<'vm> {
         }
     }
 
-    pub fn select(&mut self, sym: Symbol) -> Result<&mut Self> {
+    pub fn select(&mut self, sym: &Symbol) -> Result<&mut Self> {
         let val = match self {
             Value::AttrSet(attrs) => attrs
-                .select(sym.clone())
+                .select(sym)
                 .ok_or_else(|| Error::EvalError(format!("{sym:?} not found"))),
             Value::RecAttrSet(attrs) => attrs
-                .select(sym.clone())
+                .select(sym)
                 .ok_or_else(|| Error::EvalError(format!("{sym:?} not found"))),
             Value::Catchable(_) => return Ok(self),
             _ => Err(Error::EvalError(format!(
@@ -397,10 +397,10 @@ impl<'vm> Value<'vm> {
         Ok(self)
     }
 
-    pub fn select_with_default(&mut self, sym: Symbol, default: Value<'vm>) -> Result<&mut Self> {
+    pub fn select_with_default(&mut self, sym: &Symbol, default: Value<'vm>) -> Result<&mut Self> {
         let val = match self {
-            Value::AttrSet(attrs) => attrs.select(sym.clone()).unwrap_or(default),
+            Value::AttrSet(attrs) => attrs.select(sym).unwrap_or(default),
-            Value::RecAttrSet(attrs) => attrs.select(sym.clone()).unwrap_or(default),
+            Value::RecAttrSet(attrs) => attrs.select(sym).unwrap_or(default),
             Value::Catchable(_) => return Ok(self),
             _ => {
                 return Err(Error::EvalError(format!(
@@ -413,7 +413,7 @@ impl<'vm> Value<'vm> {
         Ok(self)
     }
 
-    pub fn has_attr(&mut self, sym: Symbol) -> &mut Self {
+    pub fn has_attr(&mut self, sym: &Symbol) -> &mut Self {
         if let Value::AttrSet(attrs) = self {
             let val = VmConst(Const::Bool(attrs.has_attr(sym)));
             *self = val;
@@ -440,6 +440,9 @@ impl<'vm> Value<'vm> {
         if let Value::Thunk(thunk) = self {
             let value = thunk.force(vm)?;
             *self = value
+        } else if let Value::ThunkRef(thunk) = self {
+            let value = thunk.force(vm)?;
+            *self = value
         }
         Ok(self)
     }
@@ -451,6 +454,11 @@ impl<'vm> Value<'vm> {
                 let _ = value.force_deep(vm)?;
                 *self = value;
             }
+            Value::ThunkRef(thunk) => {
+                let mut value = thunk.force(vm)?;
+                let _ = value.force_deep(vm)?;
+                *self = value;
+            }
             Value::List(list) => list.force_deep(vm)?,
             Value::AttrSet(attrs) => attrs.force_deep(vm)?,
             Value::RecAttrSet(attrs) => attrs.force_deep(vm)?,

src/ty/public/mod.rs

@@ -1,7 +1,7 @@
 use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
 
 use derive_more::{Constructor, IsVariant, Unwrap};
-use rpds::{HashTrieMapSync, VectorSync};
+use rpds::{HashTrieMap, VectorSync};
 
 use super::common::*;
 
@@ -11,7 +11,7 @@ pub use cnst::Const;
 
 #[derive(Constructor, Clone, PartialEq)]
 pub struct AttrSet {
-    data: HashTrieMapSync<Symbol, Value>,
+    data: HashTrieMap<Symbol, Value>,
 }
 
 impl Debug for AttrSet {

src/vm/env.rs

@@ -1,15 +1,15 @@
 use std::cell::RefCell;
-use std::sync::Arc;
+use std::rc::Rc;
 
-use rpds::HashTrieMapSync;
+use rpds::HashTrieMap;
 
 use crate::ty::common::Symbol;
 use crate::ty::internal::Value;
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, PartialEq)]
 pub struct Env<'vm> {
-    last: RefCell<Option<Arc<Env<'vm>>>>,
+    last: RefCell<Option<Rc<Env<'vm>>>>,
-    map: Arc<RefCell<HashTrieMapSync<Symbol, Value<'vm>>>>,
+    pub map: RefCell<HashTrieMap<Symbol, Value<'vm>>>,
 }
 
 impl Clone for Env<'_> {
@@ -19,16 +19,16 @@ impl Clone for Env<'_> {
                 self.last
                     .borrow()
                     .clone()
-                    .map(|e| Arc::new(e.as_ref().clone())),
+                    .map(|e| Rc::new(e.as_ref().clone())),
             ),
-            map: Arc::new(RefCell::new(self.map.borrow().clone())),
+            map: RefCell::new(self.map.borrow().clone()),
         }
     }
 }
 
 #[derive(Debug, Clone)]
 pub struct CapturedEnv<'vm> {
-    env: Arc<Env<'vm>>,
+    env: Rc<Env<'vm>>,
 }
 
 impl<'vm> Env<'vm> {
@@ -36,15 +36,15 @@ impl<'vm> Env<'vm> {
         Env::default()
     }
 
-    pub fn lookup(&self, symbol: Symbol) -> Option<Value<'vm>> {
+    pub fn lookup(&self, symbol: &Symbol) -> Option<Value<'vm>> {
-        self.map.borrow().get(&symbol).cloned()
+        self.map.borrow().get(symbol).cloned()
     }
 
     pub fn insert(&self, symbol: Symbol, value: Value<'vm>) {
         self.map.borrow_mut().insert_mut(symbol, value);
     }
 
-    pub fn enter(&self, new: HashTrieMapSync<Symbol, Value<'vm>>) {
+    pub fn enter(&self, new: HashTrieMap<Symbol, Value<'vm>>) {
         let mut map = self.map.borrow().clone();
         for (k, v) in new.iter() {
             map.insert_mut(k.clone(), v.clone());
@@ -53,17 +53,23 @@ impl<'vm> Env<'vm> {
             last: self.last.clone(),
             map: self.map.clone(),
         };
-        *self.last.borrow_mut() = Some(Arc::new(last));
+        *self.last.borrow_mut() = Some(Rc::new(last));
         *self.map.borrow_mut() = map;
     }
 
-    pub fn enter_rec(&self) -> Arc<RefCell<HashTrieMapSync<Symbol, Value<'vm>>>> {
+    pub fn enter_rec(self: &mut Rc<Self>, new: Rc<Env<'vm>>) {
+        let last = (*self.last.borrow_mut()).take();
+        *self = new;
+        *self.last.borrow_mut() = last;
+    }
+
+    pub fn new_rec(self: Rc<Self>) -> Rc<Self> {
         let last = Env {
             last: self.last.clone(),
             map: self.map.clone(),
         };
-        *self.last.borrow_mut() = Some(Arc::new(last));
+        *self.last.borrow_mut() = Some(Rc::new(last));
-        self.map.clone()
+        self.clone()
     }
 
     pub fn leave(&self) {
@@ -73,17 +79,17 @@ impl<'vm> Env<'vm> {
         *self.map.borrow_mut() = map;
     }
 
-    pub fn captured(self: Arc<Self>) -> CapturedEnv<'vm> {
+    pub fn captured(self: Rc<Self>) -> CapturedEnv<'vm> {
         CapturedEnv { env: self }
     }
 }
 
 impl<'vm> CapturedEnv<'vm> {
-    pub fn lookup(&self, symbol: Symbol) -> Option<Value<'vm>> {
+    pub fn lookup(&self, symbol: &Symbol) -> Option<Value<'vm>> {
         self.env.lookup(symbol)
     }
 
-    pub fn released(self) -> Arc<Env<'vm>> {
+    pub fn released(self) -> Rc<Env<'vm>> {
-        Arc::new(self.env.as_ref().clone())
+        Rc::new(self.env.as_ref().clone())
     }
 }

src/vm/mod.rs

@@ -1,5 +1,5 @@
 use std::cell::OnceCell;
-use std::sync::Arc;
+use std::rc::Rc;
 
 use crate::builtins::env;
 use crate::bytecode::{BinOp, OpCode, OpCodes, Program, UnOp};
@@ -65,11 +65,11 @@ impl<'vm> VM<'vm> {
         unsafe { &*(&self.funcs[idx] as *const _) }
     }
 
-    pub fn eval(&self, opcodes: OpCodes, env: Arc<Env<'vm>>) -> Result<Value<'vm>> {
+    pub fn eval(&self, opcodes: OpCodes, env: Rc<Env<'vm>>) -> Result<Value<'vm>> {
         let mut stack = Stack::<STACK_SIZE>::new();
         let mut iter = opcodes.into_iter();
         while let Some(opcode) = iter.next() {
-            let jmp = self.single_op(opcode, &mut stack, env.clone())?;
+            let jmp = self.single_op(opcode, &mut stack, &env)?;
             for _ in 0..jmp {
                 iter.next().unwrap();
             }
@@ -85,15 +85,16 @@ impl<'vm> VM<'vm> {
         &self,
         opcode: OpCode,
         stack: &'s mut Stack<'vm, CAP>,
-        env: Arc<Env<'vm>>,
+        env: &Rc<Env<'vm>>,
     ) -> Result<usize>
     {
         match opcode {
             OpCode::Illegal => panic!("illegal opcode"),
             OpCode::Const { value } => stack.push(Value::Const(value))?,
             OpCode::LoadThunk { idx } => {
-                self.thunks[idx].capture(env);
+                let thunk = self.get_thunk(idx);
-                stack.push(Value::Thunk(self.thunks[idx].clone()))?
+                thunk.capture(env.clone());
+                stack.push(Value::ThunkRef(self.get_thunk(idx)))?
             }
             OpCode::LoadValue { idx } => {
                 stack.push(self.get_thunk(idx).force(self)?)?;
@@ -123,7 +124,7 @@ impl<'vm> VM<'vm> {
             }
             OpCode::Func { idx } => {
                 let func = self.get_func(idx);
-                func.env.get_or_init(|| env.captured());
+                func.env.get_or_init(|| env.clone().captured());
                 stack.push(Value::Func(func))?;
             }
             OpCode::UnOp { op } => {
@@ -167,13 +168,13 @@ impl<'vm> VM<'vm> {
             OpCode::AttrSet => {
                 stack.push(Value::AttrSet(AttrSet::empty()))?;
             }
-            OpCode::RecAttrSet => {
+            OpCode::FinalizeRec => {
-                let new = env.enter_rec();
+                env.enter(stack.tos()?.clone().unwrap_attr_set().into_inner());
-                stack.push(Value::RecAttrSet(RecAttrSet::new(new)))?;
+                stack.tos_mut()?.as_mut().unwrap_attr_set().capture(env.clone());
-            }
+            },
             OpCode::PushStaticAttr { name } => {
                 let val = stack.pop();
-                stack.tos_mut()?.push_attr(Symbol::new(name), val);
+                stack.tos_mut()?.push_attr(Symbol::new(name.clone()), val);
             }
             OpCode::PushDynamicAttr => {
                 let val = stack.pop();
@@ -183,21 +184,21 @@ impl<'vm> VM<'vm> {
                 stack.tos_mut()?.push_attr(sym, val);
             }
             OpCode::Select { sym } => {
-                stack.tos_mut()?.force(self)?.select(Symbol::new(sym))?;
+                stack.tos_mut()?.force(self)?.select(&Symbol::new(sym))?;
             }
             OpCode::SelectOrDefault { sym } => {
                 let default = stack.pop();
                 stack
                     .tos_mut()?
                     .force(self)?
-                    .select_with_default(Symbol::new(sym), default)?;
+                    .select_with_default(&Symbol::new(sym), default)?;
             }
             OpCode::SelectDynamic => {
                 let mut val = stack.pop();
                 val.force(self)?;
                 val.coerce_to_string();
                 let sym = val.unwrap_const().unwrap_string().into();
-                stack.tos_mut()?.force(self)?.select(sym)?;
+                stack.tos_mut()?.force(self)?.select(&sym)?;
             }
             OpCode::SelectDynamicOrDefault => {
                 let default = stack.pop();
@@ -208,26 +209,26 @@ impl<'vm> VM<'vm> {
                 stack
                     .tos_mut()?
                     .force(self)?
-                    .select_with_default(sym, default)?;
+                    .select_with_default(&sym, default)?;
             }
             OpCode::HasAttr { sym } => {
-                stack.tos_mut()?.force(self)?.has_attr(Symbol::new(sym));
+                stack.tos_mut()?.force(self)?.has_attr(&Symbol::new(sym));
             }
             OpCode::HasDynamicAttr => {
                 let mut val = stack.pop();
                 val.coerce_to_string();
                 let sym = val.unwrap_const().unwrap_string().into();
-                stack.tos_mut()?.force(self)?.has_attr(sym);
+                stack.tos_mut()?.force(self)?.has_attr(&sym);
             }
             OpCode::LookUp { sym } => {
+                let sym = Symbol::new(sym);
                 stack.push(
-                    env.lookup(Symbol::new(sym.clone()))
+                    env.lookup(&sym)
                         .ok_or_else(|| Error::EvalError(format!(r#""{sym}" not found"#)))?,
                 )?;
             }
             OpCode::EnterEnv => match stack.pop() {
                 Value::AttrSet(attrs) => env.enter(attrs.into_inner()),
-                Value::RecAttrSet(attrs) => env.enter(attrs.into_inner()),
                 _ => unreachable!(),
             },
             OpCode::LeaveEnv => {

src/vm/stack.rs

@@ -7,7 +7,8 @@ use crate::ty::internal::Value;
 pub const STACK_SIZE: usize = 8 * 1024 / size_of::<Value>();
 
 pub struct Stack<'vm, const CAP: usize> {
-    items: Box<[MaybeUninit<Value<'vm>>; CAP]>,
+    // items: Box<[MaybeUninit<Value<'vm>>; CAP]>,
+    items: [MaybeUninit<Value<'vm>>; CAP],
     top: usize,
 }
 
@@ -24,11 +25,7 @@ macro_rules! into {
 impl<'vm, const CAP: usize> Stack<'vm, CAP> {
     pub fn new() -> Self {
         Stack {
-            items: (0..CAP)
+            items: [const { MaybeUninit::uninit() }; CAP],
-                .map(|_| MaybeUninit::uninit())
-                .collect::<Box<_>>()
-                .try_into()
-                .unwrap(),
             top: 0,
         }
     }
@@ -55,6 +52,14 @@ impl<'vm, const CAP: usize> Stack<'vm, CAP> {
         unsafe { replace(item, MaybeUninit::uninit()).assume_init() }
     }
 
+    pub fn tos(&self) -> Result<&Value<'vm>> {
+        if self.top == 0 {
+            panic!("stack empty")
+        } else {
+            Ok(into!(&self.items[self.top - 1]))
+        }
+    }
+
     pub fn tos_mut(&mut self) -> Result<&mut Value<'vm>> {
         if self.top == 0 {
             panic!("stack empty")

src/vm/test.rs

@@ -3,7 +3,7 @@ extern crate test;
 use test::{Bencher, black_box};
 
 use ecow::EcoString;
-use rpds::{ht_map_sync, vector_sync};
+use rpds::{ht_map, vector_sync};
 
 use crate::compile::compile;
 use crate::ir::downgrade;
@@ -64,7 +64,7 @@ macro_rules! list {
 
 macro_rules! attrs {
     ($($x:tt)*) => (
-        Value::AttrSet(AttrSet::new(ht_map_sync!{$($x)*}))
+        Value::AttrSet(AttrSet::new(ht_map!{$($x)*}))
     )
 }