feat: less clone on symbol

src/ty/common.rs

@@ -1,11 +1,7 @@
 use std::fmt::{Display, Formatter, Result as FmtResult};
-use std::ops::Deref;
-
-use std::sync::LazyLock;
 
 use derive_more::Constructor;
-use ecow::EcoString;
-use regex::Regex;
+
 
 #[derive(Clone, Debug, PartialEq, Constructor)]
 pub struct Catchable {
@@ -18,46 +14,3 @@ impl Display for Catchable {
     }
 }
 
-#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Constructor)]
-pub struct Symbol(EcoString);
-
-impl<T: Into<EcoString>> From<T> for Symbol {
-    fn from(value: T) -> Self {
-        Symbol(value.into())
-    }
-}
-
-impl Display for Symbol {
-    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        if self.normal() {
-            write!(f, r#""{}""#, self.0)
-        } else {
-            write!(f, "{}", self.0)
-        }
-    }
-}
-
-static REGEX: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r#"^[a-zA-Z\_][a-zA-Z0-9\_\'\-]*$"#).unwrap());
-impl Symbol {
-    fn normal(&self) -> bool {
-        !REGEX.is_match(self)
-    }
-}
-
-impl Deref for Symbol {
-    type Target = str;
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl Symbol {
-    pub fn into_inner(self) -> EcoString {
-        self.0
-    }
-
-    pub fn as_inner(&self) -> &EcoString {
-        &self.0
-    }
-}

src/ty/internal/attrset.rs

@@ -5,15 +5,13 @@ use rpds::HashTrieMap;
 
 use crate::error::Result;
 use crate::vm::{Env, VM};
-
-use super::super::common::Symbol;
 use super::super::public as p;
 use super::{ToPublic, Value};
 
 #[repr(C)]
 #[derive(Debug, Constructor, Clone, PartialEq)]
 pub struct AttrSet<'vm> {
-    data: HashTrieMap<Symbol, Value<'vm>>,
+    data: HashTrieMap<usize, Value<'vm>>,
 }
 
 impl<'vm> AttrSet<'vm> {
@@ -23,22 +21,22 @@ impl<'vm> AttrSet<'vm> {
         }
     }
 
-    pub fn push_attr_force(&mut self, sym: Symbol, val: Value<'vm>) {
+    pub fn push_attr_force(&mut self, sym: usize, val: Value<'vm>) {
         self.data.insert_mut(sym, val);
     }
 
-    pub fn push_attr(&mut self, sym: Symbol, val: Value<'vm>) {
+    pub fn push_attr(&mut self, sym: usize, val: Value<'vm>) {
         if self.data.get_mut(&sym).is_some() {
             todo!()
         }
         self.data.insert_mut(sym, val);
     }
 
-    pub fn select(&self, sym: &Symbol) -> Option<Value<'vm>> {
+    pub fn select(&self, sym: usize) -> Option<Value<'vm>> {
         self.data.get(&sym).cloned()
     }
 
-    pub fn has_attr(&self, sym: &Symbol) -> bool {
+    pub fn has_attr(&self, sym: usize) -> bool {
         self.data.get(&sym).is_some()
     }
 
@@ -70,11 +68,11 @@ impl<'vm> AttrSet<'vm> {
         self
     }
 
-    pub fn into_inner(self) -> HashTrieMap<Symbol, Value<'vm>> {
+    pub fn into_inner(self) -> HashTrieMap<usize, Value<'vm>> {
         self.data
     }
 
-    pub fn as_inner(&self) -> &HashTrieMap<Symbol, Value<'vm>> {
+    pub fn as_inner(&self) -> &HashTrieMap<usize, Value<'vm>> {
         &self.data
     }
 
@@ -98,7 +96,7 @@ impl ToPublic for AttrSet<'_> {
         p::Value::AttrSet(p::AttrSet::new(
             self.data
                 .iter()
-                .map(|(sym, value)| (sym.clone(), value.clone().to_public(vm)))
+                .map(|(&sym, value)| (vm.get_sym(sym), value.clone().to_public(vm)))
                 .collect(),
         ))
     }
@@ -116,22 +114,22 @@ impl<'vm> RecAttrSet<'vm> {
         }
     }
 
-    pub fn push_attr_force(&mut self, sym: Symbol, val: Value<'vm>) {
+    pub fn push_attr_force(&mut self, sym: usize, val: Value<'vm>) {
         self.data.insert(sym, val);
     }
 
-    pub fn push_attr(&mut self, sym: Symbol, val: Value<'vm>) {
-        if self.data.lookup(&sym).is_some() {
+    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: &Symbol) -> Option<Value<'vm>> {
+    pub fn select(&self, sym: usize) -> Option<Value<'vm>> {
         self.data.lookup(sym)
     }
 
-    pub fn has_attr(&self, sym: &Symbol) -> bool {
+    pub fn has_attr(&self, sym: usize) -> bool {
         self.data.lookup(sym).is_some()
     }
 
@@ -189,7 +187,7 @@ impl ToPublic for RecAttrSet<'_> {
                 .map
                 .borrow()
                 .iter()
-                .map(|(sym, value)| (sym.clone(), value.clone().to_public(vm)))
+                .map(|(&sym, value)| (vm.get_sym(sym), value.clone().to_public(vm)))
                 .collect(),
         ))
     }

src/ty/internal/func.rs

@@ -1,6 +1,5 @@
 use std::rc::Rc;
 
-use ecow::EcoString;
 use itertools::Itertools;
 use rpds::HashTrieMap;
 use derive_more::Constructor;
@@ -13,11 +12,11 @@ use crate::vm::{Env, VM};
 
 #[derive(Debug, Clone)]
 pub enum Param {
-    Ident(EcoString),
+    Ident(usize),
     Formals {
-        formals: Vec<(EcoString, Option<usize>)>,
+        formals: Vec<(usize, Option<usize>)>,
         ellipsis: bool,
-        alias: Option<EcoString>,
+        alias: Option<usize>,
     },
 }
 
@@ -69,7 +68,7 @@ impl<'vm> Func<'vm> {
                     && arg
                         .as_inner()
                         .iter()
-                        .map(|(k, _)| k.as_inner())
+                        .map(|(k, _)| k)
                         .sorted()
                         .ne(formals.iter().map(|(k, _)| k).sorted())
                 {
@@ -78,7 +77,7 @@ impl<'vm> Func<'vm> {
                 for (formal, default) in formals {
                     let formal = formal.clone().into();
                     let arg = arg
-                        .select(&formal)
+                        .select(formal)
                         .or_else(|| default.map(|idx| Value::Thunk(Thunk::new(vm.get_thunk(idx)))))
                         .unwrap();
                     new.insert_mut(formal, arg);

src/ty/internal/mod.rs

@@ -7,8 +7,6 @@ use derive_more::{IsVariant, Unwrap};
 use super::common as c;
 use super::public as p;
 
-use c::Symbol;
-
 use crate::bytecode::OpCodes;
 use crate::error::*;
 use crate::vm::{Env, VM};
@@ -285,7 +283,7 @@ impl<'vm> Value<'vm> {
         }
     }
 
-    pub fn push_attr(&mut self, sym: Symbol, val: Value<'vm>) -> &mut Self {
+    pub fn push_attr(&mut self, sym: usize, val: Value<'vm>) -> &mut Self {
         if let Value::AttrSet(attrs) = self {
             attrs.push_attr(sym, val)
         } else if let Value::RecAttrSet(attrs) = self {
@@ -309,7 +307,7 @@ impl<'vm> Value<'vm> {
         }
     }
 
-    pub fn select(&mut self, sym: &Symbol) -> Result<&mut Self> {
+    pub fn select(&mut self, sym: usize) -> Result<&mut Self> {
         let val = match self {
             Value::AttrSet(attrs) => attrs
                 .select(sym)
@@ -327,7 +325,7 @@ 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: usize, default: Value<'vm>) -> Result<&mut Self> {
         let val = match self {
             Value::AttrSet(attrs) => attrs.select(sym).unwrap_or(default),
             Value::RecAttrSet(attrs) => attrs.select(sym).unwrap_or(default),
@@ -343,7 +341,7 @@ impl<'vm> Value<'vm> {
         Ok(self)
     }
 
-    pub fn has_attr(&mut self, sym: &Symbol) -> &mut Self {
+    pub fn has_attr(&mut self, sym: usize) -> &mut Self {
         if let Value::AttrSet(attrs) = self {
             let val = VmConst(Const::Bool(attrs.has_attr(sym)));
             *self = val;

src/ty/public/mod.rs

@@ -1,7 +1,11 @@
 use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
+use std::ops::Deref;
+use std::sync::LazyLock;
 
 use derive_more::{Constructor, IsVariant, Unwrap};
 use rpds::{HashTrieMap, VectorSync};
+use ecow::EcoString;
+use regex::Regex;
 
 use super::common::*;
 
@@ -9,6 +13,50 @@ mod cnst;
 
 pub use cnst::Const;
 
+#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Constructor)]
+pub struct Symbol(EcoString);
+
+impl<T: Into<EcoString>> From<T> for Symbol {
+    fn from(value: T) -> Self {
+        Symbol(value.into())
+    }
+}
+
+impl Display for Symbol {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        if self.normal() {
+            write!(f, r#""{}""#, self.0)
+        } else {
+            write!(f, "{}", self.0)
+        }
+    }
+}
+
+static REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r#"^[a-zA-Z\_][a-zA-Z0-9\_\'\-]*$"#).unwrap());
+impl Symbol {
+    fn normal(&self) -> bool {
+        !REGEX.is_match(self)
+    }
+}
+
+impl Deref for Symbol {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Symbol {
+    pub fn into_inner(self) -> EcoString {
+        self.0
+    }
+
+    pub fn as_inner(&self) -> &EcoString {
+        &self.0
+    }
+}
+
 #[derive(Constructor, Clone, PartialEq)]
 pub struct AttrSet {
     data: HashTrieMap<Symbol, Value>,