Map conj supports other maps (#163)

* Map conj supports other maps

* Actual merge function

Author: chrisrink10

basilisp/core/__init__.lpy

@@ -928,3 +928,12 @@
    (lazy-seq (cons (f) (repeatedly f))))
   ([n f]
    (lazy-seq (cons (f) (repeatedly (dec n) f)))))
+
+(defn merge
+  "Merge maps together from left to right as by conj. If a duplicate key
+  appears in a map, the rightmost map's value for that key will be taken."
+  [& maps]
+  (when (some identity maps)
+    (reduce #(conj %1 %2)
+            {}
+            maps)))

basilisp/lang/map.py

@@ -153,24 +153,22 @@ def update_with(self, merge_fn, *maps) -> "Map":
         m: PMap = self._inner.update_with(merge_fn, *maps)
         return Map(m)
 
-    def _cons(self, *entries) -> "Map":
+    def cons(self, *elems) -> "Map":
+        e = self._inner.evolver()
         try:
-            e = self._inner.evolver()
-            for entry in entries:
-                e.set(entry.key, entry.value)
+            for elem in elems:
+                if isinstance(elem, Map):
+                    for entry in elem:
+                        e.set(entry.key, entry.value)
+                elif isinstance(elem, MapEntry):
+                    e.set(elem.key, elem.value)
+                else:
+                    entry = MapEntry.from_vec(elem)
+                    e.set(entry.key, entry.value)
             return Map(e.persistent(), meta=self.meta)
-        except AttributeError:
+        except (TypeError, ValueError):
             raise ValueError(
-                "Argument to map conj must be castable to MapEntry")
-
-    def cons(self, *entries) -> "Map":
-        try:
-            e = self._inner.evolver()
-            for entry in entries:
-                e.set(entry.key, entry.value)
-            return Map(e.persistent(), meta=self.meta)
-        except AttributeError:
-            return self._cons(*seq(entries).map(MapEntry.from_vec))
+                "Argument to map conj must be another Map or castable to MapEntry")
 
     @staticmethod
     def empty() -> "Map":

tests/core_test.py

@@ -596,3 +596,12 @@ def test_not_any__Q__():
     assert False is core.not_any__Q__(core.odd__Q__, vec.v(2, 3, 5, 7, 9))
     assert False is core.not_any__Q__(core.odd__Q__, vec.v(3, 5, 2, 7, 9))
     assert True is core.not_any__Q__(core.odd__Q__, vec.v(2, 4, 6, 8, 10))
+
+
+def test_merge():
+    assert None is core.merge()
+    assert lmap.Map.empty() == core.merge(lmap.Map.empty())
+    assert lmap.map({kw.keyword("a"): 1}) == core.merge(lmap.map({kw.keyword("a"): 1}))
+    assert lmap.map({kw.keyword("a"): 53, kw.keyword("b"): "hi"}) == core.merge(
+        lmap.map({kw.keyword("a"): 1, kw.keyword("b"): "hi"}),
+        lmap.map({kw.keyword("a"): 53}))

tests/map_test.py

@@ -68,6 +68,19 @@ def test_entry():
 
 
 def test_map_cons():
+    meta = lmap.m(tag="async")
+    m1 = lmap.map({"first": "Chris"}, meta=meta)
+    m2 = m1.cons({"last", "Cronk"})
+    assert m1 is not m2
+    assert m1 != m2
+    assert len(m2) == 2
+    assert meta == m1.meta
+    assert meta == m2.meta
+    assert "Chris" == m1.get("first")
+    assert not m1.contains("last")
+    assert "Cronk" == m2.get("last")
+    assert "Chris" == m2.get("first")
+
     meta = lmap.m(tag="async")
     m1 = lmap.map({"first": "Chris"}, meta=meta)
     m2 = m1.cons(MapEntry.of("last", "Cronk"))