Merge branch 'master' into feature/count

Author: Tko1

src/persistent_list_map.rs

@@ -63,10 +63,11 @@ macro_rules! persistent_list_map {
         }
     };
 }
-
-/// merge!(base_meta(name, ns), map_entry!("key1", "value1"), map_entry!("key2", "value2"));
+/// Just like conj in Clojure, conj allows you to conjoin a new mapentry onto a map
+/// although currently, that is all it allows
+/// conj!(base_meta(name, ns), map_entry!("key1", "value1"), map_entry!("key2", "value2"));
 #[macro_export]
-macro_rules! merge {
+macro_rules! conj {
     ( $plistmap:expr, $($kv:expr), *) => {
         {
             let mut temp_plistmap_as_vec = $plistmap.clone().iter().collect::<Vec<MapEntry>>();
@@ -78,14 +79,18 @@ macro_rules! merge {
     };
 }
 
-/// merge!(base_meta(name, ns), map_entry!("key1", "value1"), map_entry!("key2", "value2"));
+/// merge!(persistent_list_map!{"a" => 1 "b" => 2}
+///        persistent_list_map!{"b" => 3}
+///        persistent_list_map!{"d" => 5 "e" => 7}
+/// ), ;
 #[macro_export]
-macro_rules! merge_maps {
-    ( $plistmap:expr, $($kv:expr), *) => {
+macro_rules! merge {
+    ( $plistmap:expr, $($map:expr), *) => {
         {
             let mut temp_plistmap_as_vec = $plistmap.clone().iter().collect::<Vec<MapEntry>>();
             $(
-                temp_plistmap_as_vec.push($kv);
+                let next_map_as_vec = $map.clone().iter().collect::<Vec<MapEntry>>();
+                temp_plistmap_as_vec.extend_from_slice(&next_map_as_vec);
             )*
             temp_plistmap_as_vec.into_iter().collect::<PersistentListMap>()
         }

src/reader.rs

@@ -27,6 +27,7 @@ use crate::value::{ToValue, Value};
 use std::rc::Rc;
 use crate::protocols;
 use crate::traits::IObj;
+use crate::traits::IMeta;
 use std::io::BufRead;
 //
 // Note; the difference between ours 'parsers'
@@ -512,11 +513,12 @@ pub fn try_read_meta(input: &str) -> IResult<&str, Value> {
         let column = 1;
         // @TODO merge the meta iobj_value *already* has
         // @TODO define some better macros and / or functions for map handling 
-        meta = merge!(
+        meta = conj!(
             meta,
             map_entry!("line",line),
             map_entry!("column",column)
         );
+        meta = merge!(meta,iobj_value.meta());
         Ok((rest_input,iobj_value.with_meta(meta).unwrap().to_value()))
     }
     else {
@@ -990,6 +992,17 @@ mod tests {
             }
         }
         #[test]
+        fn try_read_multiple_meta_keyword() {
+            let with_meta = "^:cat ^:dog a";
+            match try_read(with_meta).ok().unwrap().1 {
+                Value::Symbol(symbol) => {
+                    assert!(symbol.meta().contains_key(&Keyword::intern("cat").to_rc_value()));
+                    assert!(symbol.meta().contains_key(&Keyword::intern("dog").to_rc_value()));
+                },
+                _ => panic!("try_read_meta \"^:cat a\" should return a symbol")
+            }
+        }
+        #[test]
         fn try_read_meta_keyword() {
             let with_meta = "^:cat a";
             match try_read(with_meta).ok().unwrap().1 {

src/symbol.rs

@@ -197,15 +197,15 @@ mod tests {
                     "namespace",
                     "name"
                 ).with_meta(
-                    merge!(
+                    conj!(
                         PersistentListMap::Empty,
                         map_entry!("key", "value")
                     )
                 ),
                 Symbol {
                     ns: String::from("namespace"),
                     name: String::from("name"),
-                    meta: merge!(
+                    meta: conj!(
                         PersistentListMap::Empty,
                         map_entry!("key", "value")
                     )

src/value.rs

@@ -349,24 +349,17 @@ impl Value {
                 match &**defname {
                     Value::Symbol(sym) => {
                         println!("Def: meta on sym is {}",sym.meta());
-                        // TODO: environment.insert with meta?
-                        let s = if doc_string != Value::Nil {
-                            let ss = Symbol::intern_with_ns(
-                                &sym.ns,
-                                &sym.name
-                                // merge!(
-                                //     meta::base_meta(&sym.ns, &sym.name),
-                                //     map_entry!("doc", doc_string)
-                                // ),
-                            );
-                            ss.clone()
-                        } else {
-                            sym.clone()
-                        };
-                        environment.insert(s.to_owned(), defval);
-                        // @TODO return var. For now, however, we only have symbols
-                        // @TODO intern from environment, don't make new sym ?
-                        Some(s.to_rc_value())
+
+                        let mut meta = sym.meta();
+
+                        if doc_string != Value::Nil {
+                            meta = conj!(meta,map_entry!("doc",doc_string));
+                        }
+
+                        let sym = sym.with_meta(meta);
+                        environment.insert(sym.clone(), defval);
+                        // @TODO return var
+                        Some(sym.to_rc_value())
                     }
                     _ => Some(Rc::new(Value::Condition(std::string::String::from(
                         "First argument to def must be a symbol",
@@ -778,3 +771,43 @@ impl Evaluable for Value {
         self.to_rc_value().eval_to_rc(environment)
     }
 }
+mod tests {
+    use crate::keyword::Keyword;
+    use crate::symbol::Symbol;
+    use crate::protocols;
+    use crate::value::Value;
+    use crate::value::ToValue;
+    use crate::traits::IMeta;
+    use std::rc::Rc;
+    use crate::environment::Environment;
+    use crate::persistent_list_map::PersistentListMap;
+    use crate::persistent_list_map::IPersistentMap;
+    use crate::maps::MapEntry;
+    use crate::protocol::ProtocolCastable;
+    // (def ^{:cat 1 :dog 2} a "Docstring" 1)
+    // ==>
+    // a with meta of {:cat 1 :dog 2 :doc "Docstring"} ?
+    #[test]
+    fn def_with_docstring() {
+        let sym_meta = persistent_list_map!{
+            "cat" => 1,
+            "dog" => 2
+        };
+        let a = sym!("a").with_meta(sym_meta);
+        let result = Value::DefMacro.apply_to_persistent_list(
+            &Rc::new(Environment::new_main_environment()),
+            &Rc::new(list!(a "Docstring" 1))
+        );
+
+        let final_sym_meta =
+            result
+            .unwrap()
+            .as_protocol::<protocols::IMeta>()
+            .meta();
+
+        assert_eq!(Value::I32(1),*final_sym_meta.get(&Keyword::intern("cat").to_rc_value()));
+        assert_eq!(Value::I32(2),*final_sym_meta.get(&Keyword::intern("dog").to_rc_value()));
+        assert_eq!(Value::String("Docstring".to_string()),*final_sym_meta.get(&Keyword::intern("doc").to_rc_value()));
+
+    }  
+}