feat: JIT (WIP)

src/ty/public.rs

@@ -0,0 +1,131 @@
+use hashbrown::HashMap;
+use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
+use std::ops::Deref;
+use std::sync::LazyLock;
+
+use derive_more::{Constructor, IsVariant, Unwrap};
+use ecow::EcoString;
+use regex::Regex;
+use rpds::VectorSync;
+
+use super::common::*;
+
+#[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: HashMap<Symbol, Value>,
+}
+
+impl Debug for AttrSet {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        use Value::*;
+        write!(f, "{{ ")?;
+        for (k, v) in self.data.iter() {
+            match v {
+                List(_) => write!(f, "{k:?} = [ ... ]; ")?,
+                AttrSet(_) => write!(f, "{k:?} = {{ ... }}; ")?,
+                v => write!(f, "{k:?} = {v:?}; ")?,
+            }
+        }
+        write!(f, "}}")
+    }
+}
+
+impl Display for AttrSet {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        write!(f, "{{ ")?;
+        for (k, v) in self.data.iter() {
+            write!(f, "{k} = {v}; ")?;
+        }
+        write!(f, "}}")
+    }
+}
+
+#[derive(Constructor, Clone, Debug, PartialEq)]
+pub struct List {
+    data: VectorSync<Value>,
+}
+
+impl Display for List {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        write!(f, "[ ")?;
+        for v in self.data.iter() {
+            write!(f, "{v} ")?;
+        }
+        write!(f, "]")
+    }
+}
+
+#[derive(IsVariant, Unwrap, Clone, Debug, PartialEq)]
+pub enum Value {
+    Const(Const),
+    AttrSet(AttrSet),
+    List(List),
+    Catchable(Catchable),
+    Thunk,
+    Func,
+    PrimOp(&'static str),
+    PartialPrimOp(&'static str),
+    Repeated,
+}
+
+impl Display for Value {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        use Value::*;
+        match self {
+            Const(x) => write!(f, "{x}"),
+            AttrSet(x) => write!(f, "{x}"),
+            List(x) => write!(f, "{x}"),
+            Catchable(x) => write!(f, "{x}"),
+            Thunk => write!(f, "<CODE>"),
+            Func => write!(f, "<LAMBDA>"),
+            PrimOp(x) => write!(f, "<PRIMOP {x}>"),
+            PartialPrimOp(x) => write!(f, "<PARTIAL PRIMOP {x}>"),
+            Repeated => write!(f, "<REPEATED>"),
+        }
+    }
+}
+