Implemented iobj and imeta protocols, implementd analogous trait

Author: Tko1

src/protocols.rs

@@ -6,3 +6,6 @@ pub use self::ifn::*;
 
 pub(crate) mod imeta;
 pub use self::imeta::*;
+
+pub(crate) mod iobj;
+pub use self::iobj::*;

src/protocols/imeta.rs

@@ -1,14 +1,8 @@
 use crate::keyword::Keyword;
 use crate::maps::MapEntry;
-use crate::persistent_list::PersistentListIter;
-use crate::persistent_list::ToPersistentListIter;
-use crate::persistent_list_map::ToPersistentListMapIter;
-use crate::persistent_list_map::{PersistentListMap, PersistentListMapIter};
-use crate::persistent_vector::PersistentVectorIter;
-use crate::persistent_vector::ToPersistentVector;
-use crate::persistent_vector::ToPersistentVectorIter;
-use crate::protocol::Protocol;
+use crate::persistent_list_map::{PersistentListMap};
 use crate::define_protocol;
+use crate::traits;
 use crate::symbol::Symbol;
 use crate::value::ToValue;
 use crate::value::Value;
@@ -17,54 +11,32 @@ use std::rc::Rc;
 define_protocol!(
     IMeta = PersistentList     |
             PersistentVector   |
-            PersistentList     |
             PersistentListMap  |
-            Symbol             |
-            IFn
+            Symbol //             |
+            // IFn
 );
-
-/// Syntactic sugar, DRY
-/// map_entry!("doc", "this is a docstring");
-#[macro_export]
-macro_rules! map_entry {
-    ($key:expr, $value:expr) => {{
-        MapEntry {
-            key: Keyword::intern($key).to_rc_value(),
-            val: $value.to_rc_value(),
-        }
-    }};
-}
-
-/// Syntactic sugar, DRY
-/// persistent_list_map!(map_entry!("key1", "value1"), map_entry!("key2", "value2"));
-#[macro_export]
-macro_rules! persistent_list_map {}
-    ( $($kv:expr), *) => {
-        {
-            let mut temp_vec = Vec::new();
-            $(
-                temp_vec.push($kv);
-            )*
-            temp_vec.into_iter().collect::<PersistentListMap>()
-        }
-    };
-}
-
-/// Syntactic sugar, DRY
-/// merge!(base_meta(name, ns), map_entry!("key1", "value1"), map_entry!("key2", "value2"));
-#[macro_export]
-macro_rules! merge {
-    ( $plistmap:expr, $($kv:expr), *) => {
-        {
-            let mut temp_plistmap_as_vec = $plistmap.clone().iter().collect::<Vec<MapEntry>>();
-            $(
-                temp_plistmap_as_vec.push($kv);
-            )*
-            temp_plistmap_as_vec.into_iter().collect::<PersistentListMap>()
+impl traits::IMeta for IMeta {
+    fn meta(&self) -> PersistentListMap {
+        match &*self.value {
+            Value::PersistentList(val) => {
+                val.meta()
+            }
+            Value::PersistentVector(val) => {
+                val.meta()
+            }
+            Value::PersistentListMap(val) => {
+                val.meta()
+            }
+            Value::Symbol(val) => {
+                val.meta()
+            }
+            _ => panic!("protocols::IMeta was wrapping an invalid type {} when calling meta()",self.value.type_tag())
+            // Value::IFn(val) => {
+            //     val.with_meta(meta)
+            // }
         }
-    };
+    }
 }
-
 /// Constructs base meta if none provided
 /// {:line 1
 ///  :column 1
@@ -81,3 +53,6 @@ pub fn base_meta(ns: &str, name: &str) -> PersistentListMap {
         map_entry!("name", Symbol::intern(name))
     )
 }
+
+mod tests {
+}

src/protocols/iobj.rs

@@ -0,0 +1,65 @@
+use crate::persistent_list_map::{PersistentListMap};
+use crate::protocol::ProtocolCastable;
+use crate::define_protocol;
+use crate::value::{Value,ToValue};
+use crate::traits;
+use std::rc::Rc;
+// TODO allow nullable protocols 
+define_protocol!(
+    IObj = PersistentList     |
+           PersistentVector   |
+           PersistentListMap  |
+           Symbol //              |
+           // IFn
+);
+impl traits::IMeta for IObj {
+    fn meta(&self) -> PersistentListMap {
+        match &*self.value {
+            Value::PersistentList(val) => {
+                val.meta()
+            }
+            Value::PersistentVector(val) => {
+                val.meta()
+            }
+            Value::PersistentListMap(val) => {
+                val.meta()
+            }
+            Value::Symbol(val) => {
+                val.meta()
+            }
+            _ => {
+                panic!("protocols::IMeta was wrapping an invalid type {} when calling meta()",self.value.type_tag())
+                //PersistentListMap::Empty
+            }
+            // Value::IFn(val) => {
+            //     val.with_meta(meta)
+            // }
+        }
+    }
+}
+impl traits::IObj for IObj {
+    fn with_meta(&self,meta: PersistentListMap) -> IObj {
+        match &*self.value {
+            Value::PersistentList(val) => {
+                val.with_meta(meta).to_rc_value().as_protocol::<IObj>()
+            }
+            Value::PersistentVector(val) => {
+                val.with_meta(meta).to_rc_value().as_protocol::<IObj>()
+            }
+            Value::PersistentListMap(val) => {
+                val.with_meta(meta).to_rc_value().as_protocol::<IObj>()
+            }
+            Value::Symbol(val) => {
+                val.with_meta(meta).to_rc_value().as_protocol::<IObj>()
+            }
+            _ => {
+                panic!("protocols::IMeta was wrapping an invalid type {} when calling meta()",self.value.type_tag())
+            }
+            // Value::IFn(val) => {
+            //     val.with_meta(meta)
+            // }
+        }
+    }
+}
+mod tests {
+}

src/traits.rs

@@ -0,0 +1,8 @@
+pub(crate) mod iobj;
+pub use self::iobj::*;
+
+pub(crate) mod ifn;
+pub use self::ifn::*;
+
+pub(crate) mod imeta;
+pub use self::imeta::*;

src/traits/ifn.rs

@@ -0,0 +1,42 @@
+//! Trait for function-like things
+//!
+//! An IFn is something that can be invoked on arguments, like:
+//! a function,
+//!    (+ 1 2)
+//! a macro
+//!    (-> 1 (+ 5) (* 10)))
+//! a keyword
+//!    (:name {:name "Blah" :age 20})
+//! a map
+//!    ({:name "Blah" :age 20} :name)
+//! As well as a few more types.
+use crate::value::Value;
+
+use dyn_clone::DynClone;
+
+use std::fmt::Debug;
+use std::rc::Rc;
+
+//
+// Based on: clojure.lang.IFn
+//
+// Naming this is a bit difficult, as
+// 1. Rust already has a Fn trait
+// 2. Naming this IFn or not naming this IFn introduces consistency and inconsistency;
+//
+//    Keeping 'IFn' introduces consistency because not just does the
+//    original ClojureJVM have an IFn in the Java underneath, but
+//    Clojure itself carries on this idea even as we leave the JVM (as,
+//    for instance, ifn is implemented in Clojurescript via)
+//
+//    Inconsistency, because Rust surely does not name traits 'ITrait'.
+//
+// I've regardless kept it as IFn, and you might say IFn here is
+// referring to the Clojure idea of an IFn, implemented in Rust with a
+// trait, rather than saying 'this is an interface called Fn'
+//
+
+pub trait IFn: Debug + DynClone {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value;
+}
+dyn_clone::clone_trait_object!(IFn);

src/traits/imeta.rs

@@ -0,0 +1,6 @@
+use std::fmt::Debug;
+use crate::persistent_list_map::PersistentListMap;
+
+pub trait IMeta: Debug {
+    fn meta(&self) -> PersistentListMap;
+}

src/traits/iobj.rs

@@ -0,0 +1,10 @@
+use crate::traits::imeta::IMeta;
+use std::fmt::Debug;
+use crate::persistent_list_map::PersistentListMap;
+
+// @TODO start swapping PersistentListMap signatures for protocol::IPersistentMap or
+// with_meta<I: traits::IPersistentMap>(meta: I)
+
+pub trait IObj: IMeta + Debug {
+    fn with_meta(&self,meta: PersistentListMap) -> Self;
+}