Allow builtin Basilisp types to be pickled (#543)

Author: chrisrink10

CHANGELOG.md

@@ -18,6 +18,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * Fixed a bug where aliased Python submodule imports referred to the top-level module rather than the submodule (#533)
  * Fixed a bug where static methods and class methods on types created by `deftype` could not be referred to directly (defeating the purpose of the static or class method) (#537)
  * Fixed a bug where `defftype` forms could not be declared without at least one field (#540)
+ * Fixed a bug where not all builtin Basilisp types could be pickled (#518)
 
 ## [v0.1.dev13] - 2020-03-16
 ### Added

src/basilisp/core.lpy

@@ -4467,9 +4467,22 @@
 (defn gen-interface
   "Generate and return a new Python interface (abstract base clase).
 
+  Options may be specified as key-value pairs. The following options are supported:
+  - :name    - the name of the interface as a string; required
+  - :extends - a vector of interfaces the new interface should extend; optional
+  - :methods - an optional vector of method signatures like:
+               [ (method-name [args ...] docstring) ... ]
+
   Callers should use `definterface` to generate new interfaces."
-  [interface-name methods]
-  (let [methods (reduce (fn [m [method-name args docstring]]
+  [& opts]
+  (let [opt-map        (apply hash-map opts)
+        interface-name (:name opt-map)
+        extends        (as-> (:extends opt-map []) $
+                         (remove #(identical? abc/ABC %) $)
+                         (concat $ [abc/ABC])
+                         (python/tuple $))
+
+        methods (reduce (fn [m [method-name args docstring]]
                           (let [method-args (->> (concat ['^:no-warn-when-unused self] args)
                                                  (apply vector))
                                 method      (->> (list 'fn* method-name method-args)
@@ -4479,10 +4492,10 @@
                               (set! (.- method __doc__) docstring))
                             (assoc m (munge method-name) method)))
                         {}
-                        methods)]
+                        (:methods opt-map))]
     (python/type interface-name
-                   #py (abc/ABC)
-                   (lisp->py methods))))
+                 extends
+                 (lisp->py methods))))
 
 ;; The behavior described below where `definterface` forms are not permitted
 ;; to be used in `deftype` and `defrecord` forms when they are not top-level
@@ -4513,7 +4526,8 @@
   (let [name-str    (name interface-name)
         method-sigs (map #(list 'quote %) methods)]
     `(def ~interface-name
-       (gen-interface ~name-str [~@method-sigs]))))
+       (gen-interface :name ~name-str
+                      :methods [~@method-sigs]))))
 
 ;;;;;;;;;;;;;;;;
 ;; Data Types ;;

src/basilisp/lang/keyword.py

@@ -29,7 +29,10 @@ def _lrepr(self, **kwargs) -> str:
         return ":{name}".format(name=self._name)
 
     def __eq__(self, other):
-        return self is other
+        return self is other or (
+            isinstance(other, Keyword)
+            and (self._name, self._ns) == (other._name, other._ns)
+        )
 
     def __hash__(self):
         return hash((self._name, self._ns))
@@ -40,6 +43,9 @@ def __call__(self, m: IAssociative, default=None):
         except AttributeError:
             return None
 
+    def __reduce__(self):
+        return keyword, (self._name, self._ns)
+
 
 def complete(
     text: str, kw_cache: atom.Atom["PMap[int, Keyword]"] = __INTERN

src/basilisp/lang/map.py

@@ -46,9 +46,6 @@ def __contains__(self, item):
     def __eq__(self, other):
         return self._inner == other
 
-    def __getattr__(self, item):
-        return getattr(self._inner, item)
-
     def __getitem__(self, item):
         return self._inner[item]
 

tests/basilisp/conftest.py

@@ -0,0 +1,8 @@
+import sys
+
+import pytest
+
+
+@pytest.fixture(params=[3, 4] if sys.version_info < (3, 8) else [3, 4, 5])
+def pickle_protocol(request) -> int:
+    return request.param

tests/basilisp/keyword_test.py

@@ -1,3 +1,5 @@
+import pickle
+
 import pytest
 from pyrsistent import PMap, pmap
 
@@ -47,6 +49,19 @@ def test_keyword_as_function():
     assert None is kw(lmap.map({"hi": kw}))
 
 
+@pytest.mark.parametrize(
+    "o",
+    [
+        keyword("kw1"),
+        keyword("very-long-name"),
+        keyword("kw1", ns="namespaced.keyword"),
+        keyword("long-named-kw", ns="also.namespaced.keyword"),
+    ],
+)
+def test_keyword_pickleability(pickle_protocol: int, o: Keyword):
+    assert o == pickle.loads(pickle.dumps(o, protocol=pickle_protocol))
+
+
 class TestKeywordCompletion:
     @pytest.fixture
     def empty_cache(self) -> Atom["PMap[int, Keyword]"]:

tests/basilisp/list_test.py

@@ -1,3 +1,5 @@
+import pickle
+
 import pytest
 
 import basilisp.lang.list as llist
@@ -95,6 +97,20 @@ def test_list_rest():
     assert llist.l(keyword("kw1"), keyword("kw2")).rest == llist.l(keyword("kw2"))
 
 
+@pytest.mark.parametrize(
+    "o",
+    [
+        llist.l(),
+        llist.l(keyword("kw1")),
+        llist.l(keyword("kw1"), 2),
+        llist.l(keyword("kw1"), 2, None, "nothingness"),
+        llist.l(keyword("kw1"), llist.l("string", 4)),
+    ],
+)
+def test_list_pickleability(pickle_protocol: int, o: llist.List):
+    assert o == pickle.loads(pickle.dumps(o, protocol=pickle_protocol))
+
+
 @pytest.mark.parametrize(
     "l,str_repr",
     [

tests/basilisp/map_test.py

@@ -1,3 +1,4 @@
+import pickle
 from typing import Mapping
 
 import pytest
@@ -181,3 +182,16 @@ def test_hash_map_creator():
 
     with pytest.raises(IndexError):
         lmap.hash_map(1, 2, 3)
+
+
+@pytest.mark.parametrize(
+    "o",
+    [
+        lmap.m(),
+        lmap.map({"a": 2}),
+        lmap.map({"a": 2, None: "NOTHINGNESS"}),
+        lmap.map({"a": 2, keyword("b"): lmap.map({keyword("c"): "string"})}),
+    ],
+)
+def test_map_pickleability(pickle_protocol: int, o: lmap.Map):
+    assert o == pickle.loads(pickle.dumps(o, protocol=pickle_protocol))

tests/basilisp/set_test.py

@@ -1,3 +1,4 @@
+import pickle
 import typing
 
 import pytest
@@ -62,6 +63,20 @@ def test_set_with_meta():
     assert s4.meta == lmap.m(tag=keyword("macro"))
 
 
+@pytest.mark.parametrize(
+    "o",
+    [
+        lset.s(),
+        lset.s(keyword("kw1")),
+        lset.s(keyword("kw1"), 2),
+        lset.s(keyword("kw1"), 2, None, "nothingness"),
+        lset.s(keyword("kw1"), lset.s("string", 4)),
+    ],
+)
+def test_set_pickleability(pickle_protocol: int, o: lset.Set):
+    assert o == pickle.loads(pickle.dumps(o, protocol=pickle_protocol))
+
+
 @pytest.mark.parametrize(
     "l,str_repr",
     [

tests/basilisp/symbol_test.py

@@ -1,6 +1,10 @@
+import pickle
+
+import pytest
+
 import basilisp.lang.map as lmap
 from basilisp.lang.keyword import keyword
-from basilisp.lang.symbol import symbol
+from basilisp.lang.symbol import Symbol, symbol
 
 
 def test_symbol_name_and_ns():
@@ -40,6 +44,19 @@ def test_symbol_with_meta():
     assert sym3.meta == lmap.m(tag=keyword("macro"))
 
 
+@pytest.mark.parametrize(
+    "o",
+    [
+        symbol("kw1"),
+        symbol("very-long-name"),
+        symbol("kw1", ns="namespaced.keyword"),
+        symbol("long-named-kw", ns="also.namespaced.keyword"),
+    ],
+)
+def test_symbol_pickleability(pickle_protocol: int, o: Symbol):
+    assert o == pickle.loads(pickle.dumps(o, protocol=pickle_protocol))
+
+
 def test_symbol_str_and_repr():
     sym = symbol("sym", ns="ns")
     assert str(sym) == "ns/sym"