Use a threading.Lock internally for multi-methods (#478)

Author: chrisrink10

CHANGELOG.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
  * Change the default user namespace to `basilisp.user` (#466)
+ * Changed multi-methods to use a `threading.Lock` internally rather than an Atom (#477)
 
 ### Fixed
  * Fixed a reader bug where no exception was being thrown splicing reader conditional forms appeared outside of valid splicing contexts (#470)

src/basilisp/lang/multifn.py

@@ -1,8 +1,9 @@
+import threading
 from typing import Any, Callable, Generic, Optional, TypeVar
 
-import basilisp.lang.atom as atom
 import basilisp.lang.map as lmap
 import basilisp.lang.symbol as sym
+from basilisp.lang.interfaces import IPersistentMap
 from basilisp.util import Maybe
 
 T = TypeVar("T")
@@ -11,71 +12,61 @@
 
 
 class MultiFunction(Generic[T]):
-    __slots__ = ("_name", "_default", "_dispatch", "_methods")
+    __slots__ = ("_name", "_default", "_dispatch", "_lock", "_methods")
 
+    # pylint:disable=assigning-non-slot
     def __init__(
         self, name: sym.Symbol, dispatch: DispatchFunction, default: T
     ) -> None:
-        self._name = name  # pylint:disable=assigning-non-slot
-        self._default = default  # pylint:disable=assigning-non-slot
-        self._dispatch = dispatch  # pylint:disable=assigning-non-slot
-        self._methods: atom.Atom = atom.Atom(  # pylint:disable=assigning-non-slot
-            lmap.Map.empty()
-        )
+        self._name = name
+        self._default = default
+        self._dispatch = dispatch
+        self._lock = threading.Lock()
+        self._methods: IPersistentMap[T, Method] = lmap.Map.empty()
 
     def __call__(self, *args, **kwargs):
         key = self._dispatch(*args, **kwargs)
-        method_cache = self.methods
-        method: Optional[Method] = Maybe(method_cache.val_at(key, None)).or_else(
-            lambda: method_cache.val_at(self._default, None)  # type: ignore
-        )
-        if method:
+        method = self.get_method(key)
+        if method is not None:
             return method(*args, **kwargs)
         raise NotImplementedError
 
-    @staticmethod
-    def __add_method(m: lmap.Map, key: T, method: Method) -> lmap.Map:
-        """Swap the methods atom to include method with key."""
-        return m.assoc(key, method)
-
     def add_method(self, key: T, method: Method) -> None:
         """Add a new method to this function which will respond for
         key returned from the dispatch function."""
-        self._methods.swap(MultiFunction.__add_method, key, method)
+        with self._lock:
+            self._methods = self._methods.assoc(key, method)
 
     def get_method(self, key: T) -> Optional[Method]:
         """Return the method which would handle this dispatch key or
         None if no method defined for this key and no default."""
-        method_cache = self.methods
+        method_cache = self._methods
         # The 'type: ignore' comment below silences a spurious MyPy error
         # about having a return statement in a method which does not return.
         return Maybe(method_cache.val_at(key, None)).or_else(
             lambda: method_cache.val_at(self._default, None)  # type: ignore
         )
 
-    @staticmethod
-    def __remove_method(m: lmap.Map, key: T) -> lmap.Map:
-        """Swap the methods atom to remove method with key."""
-        return m.dissoc(key)
-
     def remove_method(self, key: T) -> Optional[Method]:
         """Remove the method defined for this key and return it."""
-        method = self.methods.val_at(key, None)
-        if method:
-            self._methods.swap(MultiFunction.__remove_method, key)
-        return method
+        with self._lock:
+            method = self._methods.val_at(key, None)
+            if method:
+                self._methods = self._methods.dissoc(key)
+            return method
 
     def remove_all_methods(self) -> None:
         """Remove all methods defined for this multi-function."""
-        self._methods.reset(lmap.Map.empty())
+        with self._lock:
+            self._methods = lmap.Map.empty()
 
     @property
     def default(self) -> T:
         return self._default
 
     @property
-    def methods(self) -> lmap.Map:
-        return self._methods.deref()
+    def methods(self) -> IPersistentMap[T, Method]:
+        return self._methods
 
 
 def multifn(dispatch: DispatchFunction, default=None) -> MultiFunction[T]: