Add Associative ABC and apply to Map and Vector (#105)

Author: chrisrink10

basilisp/compiler.py

@@ -1525,8 +1525,8 @@ def with_lineno_and_col(ctx: CompilerContext, form: LispForm) -> ASTStream:
             col = meta.get(reader.READER_COL_KW)  # type: ignore
 
             for astnode in f(ctx, form):
-                astnode.node.lineno = line
-                astnode.node.col_offset = col
+                astnode.node.lineno = line  # type: ignore
+                astnode.node.col_offset = col  # type: ignore
                 yield astnode
         except AttributeError:
             yield from f(ctx, form)

basilisp/lang/associative.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar, Mapping
+
+K = TypeVar('K')
+V = TypeVar('V')
+
+
+class Associative(ABC, Mapping[K, V]):
+    __slots__ = ()
+
+    @abstractmethod
+    def assoc(self, *kvs) -> "Associative":
+        raise NotImplementedError()
+
+    @abstractmethod
+    def contains(self, k):
+        raise NotImplementedError()
+
+    @abstractmethod
+    def entry(self, k):
+        raise NotImplementedError()

basilisp/lang/map.py

@@ -5,6 +5,7 @@
 from pyrsistent import pmap, PMap
 
 import basilisp.lang.vector as vec
+from basilisp.lang.associative import Associative
 from basilisp.lang.meta import Meta
 from basilisp.lang.seq import Seqable, sequence, Seq
 from basilisp.lang.util import lrepr
@@ -57,9 +58,8 @@ def from_vec(v: Sequence) -> "MapEntry":
         return MapEntry(vec.vector(v))
 
 
-class Map(Meta, Seqable):
+class Map(Associative, Meta, Seqable):
     """Basilisp Map. Delegates internally to a pyrsistent.PMap object.
-
     Do not instantiate directly. Instead use the m() and map() factory
     methods below."""
     __slots__ = ('_inner', '_meta',)
@@ -119,19 +119,30 @@ def with_meta(self, meta: "Map") -> "Map":
         return Map(self._inner, meta=new_meta)
 
     def assoc(self, *kvs) -> "Map":
-        m = self._inner
+        m = self._inner.evolver()
         for k, v in seq(kvs).grouped(2):
-            m = m.set(k, v)
-        return Map(m)
+            m[k] = v
+        return Map(m.persistent())
+
+    def contains(self, k):
+        if k in self._inner:
+            return True
+        return False
 
     def dissoc(self, *ks) -> "Map":
         return self.discard(*ks)
 
     def discard(self, *ks) -> "Map":
-        m: PMap = self._inner
+        m = self._inner.evolver()
         for k in ks:
-            m = m.discard(k)
-        return Map(m)
+            try:
+                del m[k]
+            except KeyError:
+                pass
+        return Map(m.persistent())
+
+    def entry(self, k):
+        return self._inner.get(k, None)
 
     def update(self, *maps) -> "Map":
         m: PMap = self._inner.update(*maps)

basilisp/lang/runtime.py

@@ -7,7 +7,9 @@
 from functional import seq
 from pyrsistent import pmap, PMap, PSet, pset
 
+import basilisp.lang.associative as lassoc
 import basilisp.lang.list as llist
+import basilisp.lang.map as lmap
 import basilisp.lang.seq as lseq
 import basilisp.lang.symbol as sym
 from basilisp.lang import atom
@@ -23,7 +25,6 @@
 
 def _new_module(name: str, doc=None) -> types.ModuleType:
     """Create a new empty Basilisp Python module.
-
     Modules are created for each Namespace when it is created."""
     mod = types.ModuleType(name, doc=doc)
     mod.__loader__ = None
@@ -158,26 +159,21 @@ class Namespace:
     """Namespaces serve as organizational units in Basilisp code, just as
     they do in Clojure code. Vars are mutable containers for functions and
     data which may be interned in a namespace and referred to by a Symbol.
-
     Namespaces additionally may have aliases to other namespaces, so code
     organized in one namespace may conveniently refer to code or data in
     other namespaces using that alias as the Symbol's namespace.
-
     Namespaces are constructed def-by-def as Basilisp reads in each form
     in a file (which will typically declare a namespace at the top).
-
     Namespaces have the following fields of interest:
-
     - `mappings` is a mapping between a symbolic name and a Var. The
       Var may point to code, data, or nothing, if it is unbound.
-
     - `aliases` is a mapping between a symbolic alias and another
       Namespace. The fully qualified name of a namespace is also
       an alias for itself.
-
     - `imports` is a set of Python modules imported into the current
       namespace"""
     DEFAULT_IMPORTS = atom.Atom(pset(seq(['builtins',
+                                          'operator',
                                           'basilisp.lang.exception',
                                           'basilisp.lang.keyword',
                                           'basilisp.lang.list',
@@ -204,7 +200,6 @@ def __init__(self, name: sym.Symbol, module: types.ModuleType = None) -> None:
     @classmethod
     def add_default_import(cls, module: str):
         """Add a gated default import to the default imports.
-
         In particular, we need to avoid importing 'basilisp.core' before we have
         finished macro-expanding."""
         if module in cls.GATED_IMPORTS:
@@ -221,7 +216,6 @@ def module(self):
     @module.setter
     def module(self, m: types.ModuleType):
         """Override the Python module for this Namespace.
-
         This should only be done by basilisp.importer code to make sure the
         correct module is generated for `basilisp.core`."""
         self._module = m
@@ -254,7 +248,6 @@ def get_alias(self, alias: sym.Symbol) -> "Optional[Namespace]":
 
     def intern(self, sym: sym.Symbol, var: Var, force: bool = False) -> Var:
         """Intern the Var given in this namespace mapped by the given Symbol.
-
         If the Symbol already maps to a Var, this method _will not overwrite_
         the existing Var mapping unless the force keyword argument is given
         and is True."""
@@ -322,15 +315,13 @@ def __get_or_create(ns_cache: PMap,
     def get_or_create(cls, name: sym.Symbol, module: types.ModuleType = None) -> "Namespace":
         """Get the namespace bound to the symbol `name` in the global namespace
         cache, creating it if it does not exist.
-
         Return the namespace."""
         return cls._NAMESPACES.swap(Namespace.__get_or_create, name, module=module)[name]
 
     @classmethod
     def remove(cls, name: sym.Symbol) -> Optional["Namespace"]:
         """Remove the namespace bound to the symbol `name` in the global
         namespace cache and return that namespace.
-
         Return None if the namespace did not exist in the cache."""
         while True:
             oldval: PMap = cls._NAMESPACES.deref()
@@ -446,10 +437,8 @@ def concat(*seqs) -> lseq.Seq:
 
 def apply(f, args):
     """Apply function f to the arguments provided.
-
     The last argument must always be coercible to a Seq. Intermediate
     arguments are not modified.
-
     For example:
         (apply max [1 2 3])   ;=> 3
         (apply max 4 [1 2 3]) ;=> 4"""
@@ -483,6 +472,16 @@ def nth(coll, i):
     raise TypeError(f"nth not supported on object of type {type(coll)}")
 
 
+def assoc(m, *kvs):
+    """Associate keys to values in associative data structure m. If m is None,
+    returns a new Map with key-values kvs."""
+    if m is None:
+        return lmap.Map.empty().assoc(*kvs)
+    if isinstance(m, lassoc.Associative):
+        return m.assoc(*kvs)
+    raise TypeError(f"Object of type {type(m)} does not implement Associative interface")
+
+
 def _collect_args(args) -> lseq.Seq:
     """Collect Python starred arguments into a Basilisp list."""
     if isinstance(args, tuple):

basilisp/lang/vector.py

@@ -1,13 +1,13 @@
 from pyrsistent import PVector, pvector
 
+from basilisp.lang.associative import Associative
 from basilisp.lang.meta import Meta
 from basilisp.lang.seq import Seqable, Seq, sequence
 from basilisp.lang.util import lrepr
 
 
-class Vector(Meta, Seqable):
+class Vector(Associative, Meta, Seqable):
     """Basilisp Vector. Delegates internally to a pyrsistent.PVector object.
-
     Do not instantiate directly. Instead use the v() and vec() factory
     methods below."""
     __slots__ = ('_inner', '_meta',)
@@ -48,6 +48,18 @@ def with_meta(self, meta) -> "Vector":
     def conj(self, elem) -> "Vector":
         return Vector(self._inner.append(elem), meta=self.meta)
 
+    def assoc(self, *kvs):
+        return Vector(self._inner.mset(*kvs))
+
+    def contains(self, k):
+        return 0 <= k < len(self._inner)
+
+    def entry(self, k):
+        try:
+            return self._inner[k]
+        except IndexError:
+            return None
+
     @staticmethod
     def empty() -> "Vector":
         return v()

tests/map_test.py

@@ -1,5 +1,6 @@
 import pytest
 
+import basilisp.lang.associative as lassoc
 import basilisp.lang.map as lmap
 import basilisp.lang.meta as meta
 import basilisp.lang.seq as lseq
@@ -8,6 +9,11 @@
 from basilisp.lang.symbol import symbol
 
 
+def test_map_associative_interface():
+    assert isinstance(lmap.m(), lassoc.Associative)
+    assert issubclass(lmap.Map, lassoc.Associative)
+
+
 def test_map_meta_interface():
     assert isinstance(lmap.m(), meta.Meta)
     assert issubclass(lmap.Map, meta.Meta)
@@ -18,6 +24,43 @@ def test_map_seqable_interface():
     assert issubclass(lmap.Map, lseq.Seqable)
 
 
+def test_assoc():
+    m = lmap.m()
+    assert lmap.map({"k": 1}) == m.assoc("k", 1)
+    assert lmap.Map.empty() == m
+    assert lmap.map({"a": 1, "b": 2}) == m.assoc("a", 1, "b", 2)
+
+    m1 = lmap.map({"a": 3})
+    assert lmap.map({"a": 1, "b": 2}) == m1.assoc("a", 1, "b", 2)
+    assert lmap.map({"a": 3, "b": 2}) == m1.assoc("b", 2)
+
+
+def test_contains():
+    assert True is lmap.map({"a": 1}).contains("a")
+    assert False is lmap.map({"a": 1}).contains("b")
+    assert False is lmap.Map.empty().contains("a")
+
+
+def test_dissoc():
+    assert lmap.Map.empty() == lmap.Map.empty().dissoc("a")
+    assert lmap.Map.empty() == lmap.Map.empty().dissoc("a", "b", "c")
+
+    m1 = lmap.map({"a": 3})
+    assert m1 == m1.dissoc("b")
+    assert lmap.Map.empty() == m1.dissoc("a")
+
+    m2 = lmap.map({"a": 3, "b": 2})
+    assert lmap.map({"a": 3}) == m2.dissoc("b")
+    assert lmap.map({"b": 2}) == m2.dissoc("a")
+    assert lmap.Map.empty() == m2.dissoc("a", "b")
+
+
+def test_entry():
+    assert 1 == lmap.map({"a": 1}).entry("a")
+    assert None is lmap.map({"a": 1}).entry("b")
+    assert None is lmap.Map.empty().entry("a")
+
+
 def test_map_conj():
     meta = lmap.m(tag="async")
     m1 = lmap.map({"first": "Chris"}, meta=meta)

tests/runtime_test.py

@@ -150,3 +150,20 @@ def test_nth():
 
     with pytest.raises(TypeError):
         runtime.nth(3, 1)
+
+
+def test_assoc():
+    assert lmap.Map.empty() == runtime.assoc(None)
+    assert lmap.map({"a": 1}) == runtime.assoc(None, "a", 1)
+    assert lmap.map({"a": 8}) == runtime.assoc(lmap.map({"a": 1}), "a", 8)
+    assert lmap.map({"a": 1, "b": "string"}) == runtime.assoc(lmap.map({"a": 1}), "b", "string")
+
+    assert vec.v("a") == runtime.assoc(vec.Vector.empty(), 0, "a")
+    assert vec.v("c", "b") == runtime.assoc(vec.v("a", "b"), 0, "c")
+    assert vec.v("a", "c") == runtime.assoc(vec.v("a", "b"), 1, "c")
+
+    with pytest.raises(IndexError):
+        runtime.assoc(vec.Vector.empty(), 1, "a")
+
+    with pytest.raises(TypeError):
+        runtime.assoc(llist.List.empty(), 1, "a")

tests/vector_test.py

@@ -1,3 +1,4 @@
+import basilisp.lang.associative as lassoc
 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_map_associative_interface():
+    assert isinstance(lmap.m(), lassoc.Associative)
+    assert issubclass(lmap.Map, lassoc.Associative)
+
+
 def test_vector_meta_interface():
     assert isinstance(vector.v(), meta.Meta)
     assert issubclass(vector.Vector, meta.Meta)
@@ -20,6 +26,27 @@ def test_vector_slice():
     assert isinstance(vector.v(1, 2, 3)[1:], vector.Vector)
 
 
+def test_assoc():
+    v = vector.Vector.empty()
+    assert vector.v("a") == v.assoc(0, "a")
+    assert vector.Vector.empty() == v
+    assert vector.vector(["a", "b"]) == v.assoc(0, "a", 1, "b")
+
+    v1 = vector.v("a")
+    assert vector.v("c", "b") == v1.assoc(0, "c", 1, "b")
+    assert vector.v("a", "b") == v1.assoc(1, "b")
+
+
+def test_contains():
+    assert True is vector.v("a").contains(0)
+    assert True is vector.v("a", "b").contains(1)
+    assert False is vector.v("a", "b").contains(2)
+    assert False is vector.v("a", "b").contains(-1)
+    assert False is vector.Vector.empty().contains(0)
+    assert False is vector.Vector.empty().contains(1)
+    assert False is vector.Vector.empty().contains(-1)
+
+
 def test_vector_conj():
     meta = lmap.m(tag="async")
     v1 = vector.v(keyword("kw1"), meta=meta)
@@ -31,6 +58,16 @@ def test_vector_conj():
     assert meta == v2.meta
 
 
+def test_entry():
+    assert "a" == vector.v("a").entry(0)
+    assert "b" == vector.v("a", "b").entry(1)
+    assert None is vector.v("a", "b").entry(2)
+    assert "b" == vector.v("a", "b").entry(-1)
+    assert None is vector.Vector.empty().entry(0)
+    assert None is vector.Vector.empty().entry(1)
+    assert None is vector.Vector.empty().entry(-1)
+
+
 def test_vector_meta():
     assert vector.v("vec").meta is None
     meta = lmap.m(type=symbol("str"))