Cast wasm types

projects/valkyrie-types/Cargo.toml

@@ -10,6 +10,7 @@ license = "MPL-2.0"
 edition = "2021"
 
 [dependencies]
+pretty-print = "0.1.9"
 ordered-float = "4.1.1"
 heck = "0.4.1"
 serde = "1.0.188"

projects/valkyrie-types/src/definitions/ids.rs → projects/valkyrie-types/src/atomic/id/mod.rs

@@ -1,21 +1,22 @@
-use shredder::Scan;
-use std::fmt::{Debug, Display, Formatter};
+use super::*;
+use nyar_error::FileSpan;
 
 /// A unique identifier used to query the valkyrie object
-#[derive(Clone, PartialEq, Eq, Hash, Scan)]
+#[derive(Clone, PartialEq, Eq, Hash)]
 pub struct ValkyrieID {
-    path: Vec<String>,
+    name: Vec<String>,
+    file: FileSpan,
 }
 
 impl Debug for ValkyrieID {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple("ValkyrieID").field(&self.path).finish()
+        f.debug_tuple("ValkyrieID").field(&self.name).finish()
     }
 }
 
 impl Display for ValkyrieID {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&self.path.join("∷"))
+        f.write_str(&self.name.join("∷"))
     }
 }
 
@@ -24,22 +25,22 @@ impl ValkyrieID {
     where
         I: IntoIterator<Item = String>,
     {
-        Self { path: path.into_iter().collect() }
+        Self { name: path.into_iter().collect(), file: Default::default() }
     }
     pub fn name(&self) -> &str {
-        match self.path.last() {
+        match self.name.last() {
             Some(s) => s.as_str(),
             None => panic!("Empty namepath"),
         }
     }
     pub fn full_name(&self) -> &[String] {
-        self.path.as_slice()
+        self.name.as_slice()
     }
     pub fn namespace(&self) -> &[String] {
-        match self.path.len() {
+        match self.name.len() {
             0 => panic!("Empty namepath"),
             1 => &[],
-            _ => &self.path[0..self.path.len() - 1],
+            _ => &self.name[0..self.name.len() - 1],
         }
     }
 }

projects/valkyrie-types/src/builtin/maybe/mod.rs → projects/valkyrie-types/src/atomic/maybe/mod.rs

@@ -9,13 +9,13 @@ pub struct ValkyrieMaybe {
 }
 
 impl ValkyrieMaybe {
-    pub fn value<V>(v: V, rhs: ValkyrieType) -> ValkyrieMaybe
+    pub fn value<V>(v: &V, rhs: ValkyrieType) -> ValkyrieMaybe
     where
         V: ValkyrieValueType,
     {
         Self { ok: true, value: Some(v.as_valkyrie()), lhs_type: Some(v.as_type()), rhs_type: Some(rhs) }
     }
-    pub fn error<V>(v: V, lhs: ValkyrieType) -> ValkyrieMaybe
+    pub fn error<V>(v: &V, lhs: ValkyrieType) -> ValkyrieMaybe
     where
         V: ValkyrieValueType,
     {

projects/valkyrie-types/src/atomic/mod.rs

@@ -0,0 +1,74 @@
+// pub mod boolean;
+// #[cfg(feature = "polars")]
+// pub mod data_frame;
+// pub mod images;
+// pub mod json_like;
+// pub mod list;
+// pub mod module_name;
+pub mod id;
+pub mod maybe;
+pub mod text;
+
+// pub mod primitive;
+// pub mod result;
+
+pub mod boolean;
+pub mod number;
+
+use crate::values::{ValkyrieValue, ValkyrieValueType};
+use std::fmt::{Debug, Display, Formatter};
+//
+// use crate::{
+//     collection::list::{ValkyrieList, ValkyrieOrdinal},
+//     types::ValkyrieMetaType,
+//     ValkyrieDict, ValkyrieType, ValkyrieValue,
+// };
+// use indexmap::IndexMap;
+// use shredder::{marker::GcSafe, Gc, Scan, Scanner};
+// use std::{
+//     collections::{hash_map::DefaultHasher, BTreeMap, BTreeSet},
+//     fmt::{Debug, Formatter},
+//     hash::{Hash, Hasher},
+//     ops::Not,
+//     sync::Arc,
+// };
+//
+/// The display style of a token
+pub enum TokenType {
+    /// A keyword
+    Keyword,
+    /// `a, b, c`
+    Punctuation,
+    /// `a + b`
+    Operator,
+    /// `structure StructureName`
+    Structure,
+    /// `class ClassName`
+    Class,
+    /// `enumerate EnumerateName`
+    Enumerate,
+    /// `union UnionName`
+    Union,
+    /// `unite UniteName`
+    Unite,
+    /// `variant VariantName`
+    Variant,
+    /// `interfaces InterfaceName`
+    Interface,
+    /// `trait TraitName`
+    Trait,
+    /// `let variable`
+    Variable,
+    /// `let mut variable`
+    VariableMutable,
+    /// `method(parameter)`
+    Parameter,
+    /// `method(mut parameter)`
+    ParameterMutable,
+    /// `method(self)`
+    ParameterSelf,
+    /// `method(mut self)`
+    ParameterSelfMutable,
+    /// `constant`
+    Constant,
+}

projects/valkyrie-types/src/builtin/text/mod.rs → projects/valkyrie-types/src/atomic/text/mod.rs

@@ -26,3 +26,21 @@ impl ValkyrieValueType for char {
         ValkyrieType::Text { character: true, encoding: "Unicode" }
     }
 }
+
+impl<'a> ValkyrieValueType for &'a str {
+    fn as_valkyrie(&self) -> ValkyrieValue {
+        ValkyrieValue::Text(ValkyrieText { character: false, encoding: "Utf8Text", buffer: self.as_bytes().to_vec() })
+    }
+    fn as_type(&self) -> ValkyrieType {
+        ValkyrieType::Text { character: false, encoding: "Utf8Text" }
+    }
+}
+
+impl ValkyrieValueType for String {
+    fn as_valkyrie(&self) -> ValkyrieValue {
+        ValkyrieValue::Text(ValkyrieText { character: false, encoding: "Utf8Text", buffer: self.as_bytes().to_vec() })
+    }
+    fn as_type(&self) -> ValkyrieType {
+        ValkyrieType::Text { character: false, encoding: "Utf8Text" }
+    }
+}

projects/valkyrie-types/src/combine/mod.rs

@@ -0,0 +1,16 @@
+// use crate::{
+//     modifiers::AccessType,
+//     types::{atomic_type::ValkyrieDocument, ValkyrieMetaType},
+//     InitializeType, ValkyrieID,
+// };
+// use std::{
+//     collections::BTreeMap,
+//     fmt::{Debug, Formatter},
+//     ops::Range,
+// };
+// use valkyrie_ast::ExpressionNode;
+// pub mod classes;
+// pub mod fields;
+pub mod unions;
+// pub mod interfaces;
+// pub mod names;

projects/valkyrie-types/src/combine/unions/mod.rs

@@ -0,0 +1,8 @@
+use crate::{ValkyrieID, ValkyrieType};
+use indexmap::IndexMap;
+use std::collections::BTreeSet;
+
+pub struct ValkyrieUnion {
+    structured: Option<ValkyrieID>,
+    set: IndexMap<String, ValkyrieType>,
+}

projects/valkyrie-types/src/lib.rs

@@ -7,13 +7,13 @@
 
 extern crate core;
 
-mod builtin;
+mod atomic;
 // mod codegen;
 // mod collection;
 // mod functions;
 // mod modifiers;
 // // #[cfg(test)]
-// mod definitions;
+mod combine;
 // mod encoding;
 // mod singletons;
 // pub mod testing;
@@ -25,7 +25,8 @@ mod values;
 //
 
 pub use crate::{
-    builtin::{maybe::ValkyrieMaybe, number::ValkyrieNumber, text::ValkyrieText},
+    atomic::{id::ValkyrieID, maybe::ValkyrieMaybe, number::ValkyrieNumber, text::ValkyrieText},
+    combine::unions::ValkyrieUnion,
     values::{ValkyrieType, ValkyrieValue, ValkyrieValueType},
 };
 // pub use self::{