Add Collection ABC and conj (#109)

* Add Collection ABC and conj

* Match list empty method to Collection ABC

* Silence linter

Author: chrisrink10

basilisp/lang/collection.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+
+class Collection(ABC):
+    __slots__ = ()
+
+    @abstractmethod
+    def cons(self, *elems):
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    def empty() -> "Collection":
+        raise NotImplementedError()

basilisp/lang/list.py

@@ -1,11 +1,12 @@
 from pyrsistent import plist, PList
 
+from basilisp.lang.collection import Collection
 from basilisp.lang.meta import Meta
 from basilisp.lang.seq import Seq
 from basilisp.lang.util import lrepr
 
 
-class List(Meta, Seq):
+class List(Collection, Meta, Seq):
     """Basilisp List. Delegates internally to a pyrsistent.PList object.
 
     Do not instantiate directly. Instead use the l() and list() factory
@@ -53,14 +54,14 @@ def first(self):
     def rest(self) -> "List":
         return List(self._inner.rest)
 
-    def conj(self, elem) -> "List":
-        return List(self._inner.cons(elem))
-
-    def cons(self, elem) -> "List":
-        return List(self._inner.cons(elem))
+    def cons(self, *elems) -> "List":
+        l = self._inner
+        for elem in elems:
+            l = l.cons(elem)
+        return List(l)
 
     @staticmethod
-    def empty(meta=None) -> "List":
+    def empty(meta=None) -> "List":  # pylint:disable=arguments-differ
         return l(meta=meta)
 
 

basilisp/lang/map.py

@@ -1,11 +1,12 @@
 from collections import Sequence
-from typing import Any, Optional  # noqa: F401
+from typing import Optional  # noqa: F401
 
 from functional import seq
 from pyrsistent import pmap, PMap
 
 import basilisp.lang.vector as vec
 from basilisp.lang.associative import Associative
+from basilisp.lang.collection import Collection
 from basilisp.lang.meta import Meta
 from basilisp.lang.seq import Seqable, sequence, Seq
 from basilisp.lang.util import lrepr
@@ -58,7 +59,7 @@ def from_vec(v: Sequence) -> "MapEntry":
         return MapEntry(vec.vector(v))
 
 
-class Map(Associative, Meta, Seqable):
+class Map(Associative, Collection, Meta, Seqable):
     """Basilisp Map. Delegates internally to a pyrsistent.PMap object.
     Do not instantiate directly. Instead use the m() and map() factory
     methods below."""
@@ -148,18 +149,24 @@ def update(self, *maps) -> "Map":
         m: PMap = self._inner.update(*maps)
         return Map(m)
 
-    def _conj(self, entry: MapEntry) -> "Map":
+    def _cons(self, *entries) -> "Map":
         try:
-            return Map(self._inner.set(entry.key, entry.value), meta=self.meta)
+            e = self._inner.evolver()
+            for entry in entries:
+                e.set(entry.key, entry.value)
+            return Map(e.persistent(), meta=self.meta)
         except AttributeError:
             raise ValueError(
                 "Argument to map conj must be castable to MapEntry")
 
-    def conj(self, entry: Any) -> "Map":
+    def cons(self, *entries) -> "Map":
         try:
-            return Map(self._inner.set(entry.key, entry.value), meta=self.meta)
+            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._conj(MapEntry.from_vec(entry))
+            return self._cons(*seq(entries).map(MapEntry.from_vec))
 
     @staticmethod
     def empty() -> "Map":

basilisp/lang/runtime.py

@@ -8,6 +8,7 @@
 from pyrsistent import pmap, PMap, PSet, pset
 
 import basilisp.lang.associative as lassoc
+import basilisp.lang.collection as lcoll
 import basilisp.lang.list as llist
 import basilisp.lang.map as lmap
 import basilisp.lang.seq as lseq
@@ -487,6 +488,16 @@ def assoc(m, *kvs):
     raise TypeError(f"Object of type {type(m)} does not implement Associative interface")
 
 
+def conj(coll, *xs):
+    """Conjoin xs to collection. """
+    if coll is None:
+        l = llist.List.empty()
+        return l.cons(*xs)
+    if isinstance(coll, lcoll.Collection):
+        return coll.cons(*xs)
+    raise TypeError(f"Object of type {type(coll)} does not implement Collection interface")
+
+
 def _collect_args(args) -> lseq.Seq:
     """Collect Python starred arguments into a Basilisp list."""
     if isinstance(args, tuple):

basilisp/lang/set.py

@@ -2,13 +2,14 @@
 
 from pyrsistent import PSet, pset
 
+from basilisp.lang.collection import Collection
 from basilisp.lang.map import Map
 from basilisp.lang.meta import Meta
 from basilisp.lang.seq import Seqable, Seq, sequence
 from basilisp.lang.util import lrepr
 
 
-class Set(Meta, Seqable):
+class Set(Collection, Meta, Seqable):
     """Basilisp Set. Delegates internally to a pyrsistent.PSet object.
 
     Do not instantiate directly. Instead use the s() and set() factory
@@ -51,8 +52,11 @@ def with_meta(self, meta: Map) -> "Set":
             meta)
         return set(self._inner, meta=new_meta)
 
-    def conj(self, elem) -> "Set":
-        return Set(self._inner.add(elem), meta=self.meta)
+    def cons(self, *elems) -> "Set":
+        e = self._inner.evolver()
+        for elem in elems:
+            e.add(elem)
+        return Set(e.persistent(), meta=self.meta)
 
     @staticmethod
     def empty() -> "Set":

basilisp/lang/vector.py

@@ -1,12 +1,13 @@
 from pyrsistent import PVector, pvector
 
 from basilisp.lang.associative import Associative
+from basilisp.lang.collection import Collection
 from basilisp.lang.meta import Meta
 from basilisp.lang.seq import Seqable, Seq, sequence
 from basilisp.lang.util import lrepr
 
 
-class Vector(Associative, Meta, Seqable):
+class Vector(Associative, Collection, Meta, Seqable):
     """Basilisp Vector. Delegates internally to a pyrsistent.PVector object.
     Do not instantiate directly. Instead use the v() and vec() factory
     methods below."""
@@ -45,8 +46,11 @@ def with_meta(self, meta) -> "Vector":
             meta)
         return vector(self._inner, meta=new_meta)
 
-    def conj(self, elem) -> "Vector":
-        return Vector(self._inner.append(elem), meta=self.meta)
+    def cons(self, *elems) -> "Vector":
+        e = self._inner.evolver()
+        for elem in elems:
+            e.append(elem)
+        return Vector(e.persistent(), meta=self.meta)
 
     def assoc(self, *kvs):
         return Vector(self._inner.mset(*kvs))

tests/list_test.py

@@ -1,3 +1,4 @@
+import basilisp.lang.collection as lcoll
 import basilisp.lang.list as llist
 import basilisp.lang.map as lmap
 import basilisp.lang.meta as meta
@@ -6,6 +7,11 @@
 from basilisp.lang.symbol import symbol
 
 
+def test_list_collection_interface():
+    assert isinstance(llist.l(), lcoll.Collection)
+    assert issubclass(llist.List, lcoll.Collection)
+
+
 def test_list_meta_interface():
     assert isinstance(llist.l(), meta.Meta)
     assert issubclass(llist.List, meta.Meta)
@@ -20,10 +26,10 @@ def test_list_slice():
     assert isinstance(llist.l(1, 2, 3)[1:], llist.List)
 
 
-def test_list_conj():
+def test_list_cons():
     meta = lmap.m(tag="async")
     l1 = llist.l(keyword("kw1"), meta=meta)
-    l2 = l1.conj(keyword("kw2"))
+    l2 = l1.cons(keyword("kw2"))
     assert l1 is not l2
     assert l1 != l2
     assert len(l2) == 2

tests/map_test.py

@@ -1,6 +1,7 @@
 import pytest
 
 import basilisp.lang.associative as lassoc
+import basilisp.lang.collection as lcoll
 import basilisp.lang.map as lmap
 import basilisp.lang.meta as meta
 import basilisp.lang.seq as lseq
@@ -14,6 +15,11 @@ def test_map_associative_interface():
     assert issubclass(lmap.Map, lassoc.Associative)
 
 
+def test_map_collection_interface():
+    assert isinstance(lmap.m(), lcoll.Collection)
+    assert issubclass(lmap.Map, lcoll.Collection)
+
+
 def test_map_meta_interface():
     assert isinstance(lmap.m(), meta.Meta)
     assert issubclass(lmap.Map, meta.Meta)
@@ -61,28 +67,51 @@ def test_entry():
     assert None is lmap.Map.empty().entry("a")
 
 
-def test_map_conj():
+def test_map_cons():
     meta = lmap.m(tag="async")
     m1 = lmap.map({"first": "Chris"}, meta=meta)
-    m2 = m1.conj(MapEntry.of("last", "Cronk"))
+    m2 = m1.cons(MapEntry.of("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.conj(["last", "Cronk"])
+    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(["last", "Cronk"], ["middle", "L"])
+    assert m1 is not m2
+    assert m1 != m2
+    assert len(m2) == 3
+    assert meta == m1.meta
+    assert meta == m2.meta
+    assert "Chris" == m1.get("first")
+    assert not m1.contains("middle")
+    assert not m1.contains("last")
+    assert "Cronk" == m2.get("last")
+    assert "L" == m2.get("middle")
+    assert "Chris" == m2.get("first")
 
     with pytest.raises(ValueError):
         m1 = lmap.map({"first": "Chris"})
-        m1.conj(["last"])
+        m1.cons(["last"])
 
 
 def test_map_meta():

tests/runtime_test.py

@@ -167,3 +167,37 @@ def test_assoc():
 
     with pytest.raises(TypeError):
         runtime.assoc(llist.List.empty(), 1, "a")
+
+
+def test_conj():
+    assert llist.l(1) == runtime.conj(None, 1)
+    assert llist.l(3, 2, 1) == runtime.conj(None, 1, 2, 3)
+    assert llist.l(llist.l(1, 2, 3)) == runtime.conj(None, llist.l(1, 2, 3))
+
+    assert llist.l(1) == runtime.conj(llist.List.empty(), 1)
+    assert llist.l(3, 2, 1) == runtime.conj(llist.List.empty(), 1, 2, 3)
+    assert llist.l(3, 2, 1, 1) == runtime.conj(llist.l(1), 1, 2, 3)
+    assert llist.l(llist.l(1, 2, 3), 1) == runtime.conj(llist.l(1), llist.l(1, 2, 3))
+
+    assert lset.s(1) == runtime.conj(lset.Set.empty(), 1)
+    assert lset.s(1, 2, 3) == runtime.conj(lset.Set.empty(), 1, 2, 3)
+    assert lset.s(1, 2, 3) == runtime.conj(lset.s(1), 1, 2, 3)
+    assert lset.s(1, lset.s(1, 2, 3)) == runtime.conj(lset.s(1), lset.s(1, 2, 3))
+
+    assert vec.v(1) == runtime.conj(vec.Vector.empty(), 1)
+    assert vec.v(1, 2, 3) == runtime.conj(vec.Vector.empty(), 1, 2, 3)
+    assert vec.v(1, 1, 2, 3) == runtime.conj(vec.v(1), 1, 2, 3)
+    assert vec.v(1, vec.v(1, 2, 3)) == runtime.conj(vec.v(1), vec.v(1, 2, 3))
+
+    assert lmap.map({"a": 1}) == runtime.conj(lmap.Map.empty(), ["a", 1])
+    assert lmap.map({"a": 1, "b": 93}) == runtime.conj(lmap.Map.empty(), ["a", 1], ["b", 93])
+    assert lmap.map({"a": 1, "b": 93}) == runtime.conj(lmap.map({"a": 8}), ["a", 1], ["b", 93])
+
+    with pytest.raises(ValueError):
+        runtime.conj(lmap.map({"a": 8}), "a", 1, "b", 93)
+
+    with pytest.raises(TypeError):
+        runtime.conj(3, 1, "a")
+
+    with pytest.raises(TypeError):
+        runtime.conj("b", 1, "a")

tests/set_test.py

@@ -1,3 +1,4 @@
+import basilisp.lang.collection as lcoll
 import basilisp.lang.map as lmap
 import basilisp.lang.meta as meta
 import basilisp.lang.seq as lseq
@@ -6,6 +7,11 @@
 from basilisp.lang.symbol import symbol
 
 
+def test_list_collection_interface():
+    assert isinstance(lset.s(), lcoll.Collection)
+    assert issubclass(lset.Set, lcoll.Collection)
+
+
 def test_list_meta_interface():
     assert isinstance(lset.s(), meta.Meta)
     assert issubclass(lset.Set, meta.Meta)
@@ -19,7 +25,7 @@ def test_set_seqable_interface():
 def test_set_conj():
     meta = lmap.m(tag="async")
     s1 = lset.s(keyword("kw1"), meta=meta)
-    s2 = s1.conj(keyword("kw2"))
+    s2 = s1.cons(keyword("kw2"))
     assert s1 is not s2
     assert s1 != s2
     assert len(s2) == 2