feat: init

src/value/mod.rs

@@ -0,0 +1,108 @@
+use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
+use std::ops::Deref;
+use std::sync::Arc;
+
+use derive_more::{Constructor, IsVariant, Unwrap};
+use ecow::EcoString;
+use rpds::{HashTrieMapSync, VectorSync};
+
+use crate::bytecode::{Args, Const, OpCodes};
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq, Constructor)]
+pub struct Symbol(EcoString);
+
+impl<T: Into<EcoString>> From<T> for Symbol {
+    fn from(value: T) -> Self {
+        Symbol(value.into())
+    }
+}
+
+impl Deref for Symbol {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[derive(Debug, Clone, Hash)]
+pub struct Func {
+    pub args: Args,
+    pub opcodes: OpCodes,
+}
+
+impl PartialEq for Func {
+    fn eq(&self, _: &Self) -> bool {
+        false
+    }
+}
+
+/* #[derive(IsVariant, Unwrap, Clone, Debug, PartialEq)]
+pub enum Const {
+    Int(i64),
+    Float(f64),
+    Bool(bool),
+    String(EcoString),
+    Func(Arc<Func>),
+}
+
+impl Display for Const {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        write!(f, "Const::")?;
+        match self {
+            Const::Int(int) => write!(f, "Int@{}", int),
+            Const::Float(float) => write!(f, "Float@{}", float),
+            Const::Bool(bool) => write!(f, "Bool@{}", bool),
+            Const::String(string) => write!(f, r#"String@"{}""#, string.as_ref()),
+            Const::Func(func) => write!(f, "Func@{:?}", func.as_ref() as *const Func),
+        }
+    }
+}
+
+impl From<ByteCodeConst> for Const {
+    fn from(value: ByteCodeConst) -> Self {
+        use ByteCodeConst::*;
+        match value {
+            Int(int) => Const::Int(int),
+            Float(float) => Const::Float(float),
+            Bool(bool) => Const::Bool(bool),
+            String(string) => Const::String(EcoString::from(string)),
+            Func(func) => Const::Func(Arc::new(func)),
+        }
+    }
+} */
+
+#[derive(Constructor, Clone, PartialEq)]
+pub struct AttrSet {
+    data: HashTrieMapSync<Symbol, Value>,
+}
+
+impl Debug 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>,
+}
+
+#[derive(Clone, Debug, PartialEq, Constructor)]
+pub struct Catchable {
+    msg: Option<String>
+}
+
+#[derive(IsVariant, Unwrap, Clone, Debug, PartialEq)]
+pub enum Value {
+    Const(Const),
+    AttrSet(AttrSet),
+    List(List),
+    Catchable(Catchable),
+    Thunk,
+    PrimOp,
+    PartialPrimOp,
+}