Added meta and with-meta

Author: Tko1

src/environment.rs

@@ -336,7 +336,8 @@ impl Environment {
         let ns_macro = rust_core::NsMacro::new(Rc::clone(&environment));
         let load_file_fn = rust_core::LoadFileFn::new(Rc::clone(&environment));
         let refer_fn = rust_core::ReferFn::new(Rc::clone(&environment));
-        //let meta_fn = rust_core::MetaFn::new(Rc::clone(&environment));
+        let meta_fn = rust_core::MetaFn::new(Rc::clone(&environment));
+        let with_meta_fn = rust_core::WithMetaFn::new(Rc::clone(&environment));
         let var_fn = rust_core::special_form::VarFn::new(Rc::clone(&environment));
         // @TODO after we merge this with all the other commits we have,
         //       just change all the `insert`s here to use insert_in_namespace
@@ -356,6 +357,8 @@ impl Environment {
         environment.insert(Symbol::intern("fn"), fn_macro.to_rc_value());
         environment.insert(Symbol::intern("defmacro"), defmacro_macro.to_rc_value());
         environment.insert(Symbol::intern("eval"), eval_fn.to_rc_value());
+        environment.insert(Symbol::intern("meta"), meta_fn.to_rc_value());
+        environment.insert(Symbol::intern("with-meta"), with_meta_fn.to_rc_value());
         environment.insert(Symbol::intern("var-fn*"), var_fn.to_rc_value());
 
         // Thread namespace

src/rust_core.rs

@@ -9,6 +9,10 @@ pub use self::special_form::*;
 pub(crate) mod eval;
 pub use self::eval::*;
 
+pub(crate) mod meta;
+pub use self::meta::*;
+pub(crate) mod with_meta;
+pub use self::with_meta::*;
 // macros
 pub(crate) mod do_macro;
 pub use self::do_macro::*;

src/rust_core/meta.rs

@@ -0,0 +1,50 @@
+use crate::environment::Environment;
+use crate::error_message;
+ use crate::ifn::IFn;
+use crate::type_tag::TypeTag;
+use crate::protocol::ProtocolCastable;
+use crate::protocols;
+use crate::traits::IMeta;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+/// Returns meta for symbol
+/// Todo: currently uses form (meta 'clojure.string/join)
+/// should use #'var-form
+/// TODO: macro: true/false
+/// TODO: argslists for functions
+#[derive(Debug, Clone)]
+pub struct MetaFn {
+    enclosing_environment: Rc<Environment>,
+}
+impl MetaFn {
+    pub fn new(enclosing_environment: Rc<Environment>) -> MetaFn {
+        MetaFn {
+            enclosing_environment,
+        }
+    }
+}
+impl ToValue for MetaFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for MetaFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 1 {
+            return error_message::wrong_arg_count(1, args.len());
+        }
+        match args.get(0).unwrap().try_as_protocol::<protocols::IMeta>() {
+            Some(imeta) => imeta.meta().to_value(),
+            // In order to avoid having the cryptic error messages of Clojure, we're experimenting here
+            // already with some other error messages. As we finds ones we like, they will likewise be
+            // abstracted out to their own functions -- for now, they're just one offs
+            _ => error_message::custom(&format!(
+                "In (meta ..), .. must be an instance of IMeta, and {} is of type {}, which is not",
+                args.get(0).unwrap(),
+                args.get(0).unwrap().type_tag())
+            )
+            //error_message::cast_error(Cast("IMeta"), TypeTag::PersistentListMap)
+        }
+    }
+}

src/rust_core/with_meta.rs

@@ -0,0 +1,55 @@
+use crate::environment::Environment;
+use crate::error_message;
+use crate::ifn::IFn;
+use crate::protocol::ProtocolCastable;
+use crate::protocols;
+use crate::protocol::Protocol;
+use crate::traits::IObj;
+use crate::persistent_list_map::PersistentListMap;
+use crate::type_tag::TypeTag;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+/// (with-meta obj m)
+/// returns object with given metadata
+#[derive(Debug, Clone)]
+pub struct WithMetaFn {
+    enclosing_environment: Rc<Environment>,
+}
+impl WithMetaFn {
+    pub fn new(enclosing_environment: Rc<Environment>) -> WithMetaFn {
+        WithMetaFn {
+            enclosing_environment,
+        }
+    }
+}
+impl ToValue for WithMetaFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for WithMetaFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 2 {
+            return error_message::wrong_arg_count(2, args.len());
+        }
+
+        match args.get(0).unwrap().try_as_protocol::<protocols::IObj>() {
+            Some(obj) => match args.get(1).unwrap().to_value() {
+                Value::PersistentListMap(plistmap) => {
+                    obj.with_meta(plistmap).unwrap().to_value()
+                }
+                _ => error_message::type_mismatch(
+                    TypeTag::PersistentListMap,
+                    args.get(0).unwrap(),
+                ),
+            }
+            // Again, this will likely be swapped for a proper error function, we are currently
+            // experimenting with new error messages
+            _ => error_message::custom(&format!(
+                "In with-meta: first argument is supposed to be of instance IObj, but its type {} is not",
+                args.get(0).unwrap().type_tag()
+            ))
+        }
+    }
+}