Clean up the interface hierarchy (#372)

* Restructure interfaces

* Fix that

* And this

* CLEANER

Author: chrisrink10

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.black]
 line-length = 88
-py36 = true
+target-version = ['py36']
 include = '\.pyi?$'
 exclude = '''
 /(

src/basilisp/core/__init__.lpy

@@ -621,9 +621,15 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defn deref
-  "Dereference a delay or atom and returns its contents."
-  [o]
-  (basilisp.lang.runtime/deref o))
+  "Dereference a delay or atom and returns its contents.
+  If o is an object implementing IBlockingDeref and timeout-s and
+  timeout-val are supplied, deref will wait at most timeout-s seconds,
+  returning timeout-val if timeout-s seconds elapse and o has not
+  returned."
+  ([o]
+   (basilisp.lang.runtime/deref o))
+  ([o timeout-s timeout-val]
+   (basilisp.lang.runtime/deref o timeout-s timeout-val)))
 
 (defn compare-and-set!
   "Atomically set the value of atom to new-val if and only if old-val

src/basilisp/lang/delay.py

@@ -13,12 +13,12 @@
 @attr.s(
     auto_attribs=True,
     frozen=True,
-    these={"f": attr.ib(), "value": attr.ib(), "computed": attr.ib()},
+    these={"f": attr.ib(), "value": attr.ib(), "computed": attr.ib(default=False)},
 )
 class _DelayState(Generic[T]):
     f: Callable[[], T]
     value: Optional[T]
-    computed: bool = False
+    computed: bool
 
 
 class Delay(IDeref[T]):

src/basilisp/lang/interfaces.py

@@ -4,34 +4,24 @@
 
 from basilisp.lang.obj import LispObject as _LispObject, seq_lrepr
 
-K = TypeVar("K")
-V = TypeVar("V")
+T = TypeVar("T")
 
 
-class IAssociative(Mapping[K, V]):
+class IDeref(Generic[T]):
     __slots__ = ()
 
     @abstractmethod
-    def assoc(self, *kvs) -> "IAssociative[K, V]":
-        raise NotImplementedError()
-
-    @abstractmethod
-    def contains(self, k: K) -> bool:
-        raise NotImplementedError()
-
-    @abstractmethod
-    def entry(self, k: K, default: Optional[V] = None) -> Optional[V]:
+    def deref(self) -> Optional[T]:
         raise NotImplementedError()
 
 
-T = TypeVar("T")
-
-
-class IDeref(Generic[T]):
+class IBlockingDeref(IDeref[T]):
     __slots__ = ()
 
     @abstractmethod
-    def deref(self) -> Optional[T]:
+    def deref(
+        self, timeout: Optional[float] = None, timeout_val: Optional[T] = None
+    ) -> Optional[T]:
         raise NotImplementedError()
 
 
@@ -48,6 +38,10 @@ def data(self) -> "IPersistentMap":
         raise NotImplementedError()
 
 
+K = TypeVar("K")
+V = TypeVar("V")
+
+
 class IMapEntry(Generic[K, V]):
     __slots__ = ()
 
@@ -78,7 +72,15 @@ def with_meta(self, meta: "IPersistentMap") -> "IMeta":
 ILispObject = _LispObject
 
 
-class IPersistentCollection(Generic[T]):
+class ISeqable(Iterable[T]):
+    __slots__ = ()
+
+    @abstractmethod
+    def seq(self) -> "ISeq[T]":
+        raise NotImplementedError()
+
+
+class IPersistentCollection(ISeqable[T]):
     __slots__ = ()
 
     @abstractmethod
@@ -91,6 +93,22 @@ def empty() -> "IPersistentCollection[T]":
         raise NotImplementedError()
 
 
+class IAssociative(Mapping[K, V], IPersistentCollection[IMapEntry[K, V]]):
+    __slots__ = ()
+
+    @abstractmethod
+    def assoc(self, *kvs) -> "IAssociative[K, V]":
+        raise NotImplementedError()
+
+    @abstractmethod
+    def contains(self, k: K) -> bool:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def entry(self, k: K, default: Optional[V] = None) -> Optional[V]:
+        raise NotImplementedError()
+
+
 class IPersistentStack(IPersistentCollection[T]):
     __slots__ = ()
 
@@ -123,17 +141,31 @@ def disj(self, *elems: T) -> "IPersistentSet[T]":
         raise NotImplementedError()
 
 
+# MyPy has a lot of trouble dealing with the fact that Vectors are
+# considered as mapping types (from int -> T) and more traditional
+# sequential collections since the Python supertypes signatures conflict.
+# Below, we override the supertype signatures to select the signature
+# we specifically want to appear, but MyPy still complains. For now,
+# we will simply silence MyPy.
 class IPersistentVector(  # type: ignore
-    IAssociative[int, T], IPersistentStack[T], Sequence[T]
+    Sequence[T], IAssociative[int, T], IPersistentStack[T]
 ):
     __slots__ = ()
 
+    @abstractmethod
+    def cons(self, *elems: T) -> "IPersistentVector[T]":  # type: ignore
+        raise NotImplementedError()
+
+    @abstractmethod
+    def seq(self) -> "ISeq[T]":  # type: ignore
+        raise NotImplementedError()
+
 
 class IRecord(ABC):
     __slots__ = ()
 
 
-class ISeq(ILispObject, Iterable[T]):
+class ISeq(ILispObject, ISeqable[T]):
     __slots__ = ()
 
     @property
@@ -155,6 +187,9 @@ def rest(self) -> "ISeq[T]":
     def cons(self, elem: T) -> "ISeq[T]":
         raise NotImplementedError()
 
+    def seq(self) -> "ISeq[T]":
+        return self
+
     def _lrepr(self, **kwargs):
         return seq_lrepr(iter(self), "(", ")", **kwargs)
 
@@ -174,12 +209,5 @@ def __iter__(self):
             o = o.rest
 
 
-class ISeqable(ABC, Iterable[T]):
-    __slots__ = ()
-
-    def seq(self) -> ISeq[T]:
-        raise NotImplementedError()
-
-
 class IType(ABC):
     __slots__ = ()

src/basilisp/lang/list.py

@@ -85,9 +85,13 @@ def pop(self) -> "List":
 
 def list(members, meta=None) -> List:  # pylint:disable=redefined-builtin
     """Creates a new list."""
-    return List(plist(iterable=members), meta=meta)
+    return List(  # pylint: disable=abstract-class-instantiated
+        plist(iterable=members), meta=meta
+    )
 
 
 def l(*members, meta=None) -> List:
     """Creates a new list from members."""
-    return List(plist(iterable=members), meta=meta)
+    return List(  # pylint: disable=abstract-class-instantiated
+        plist(iterable=members), meta=meta
+    )

src/basilisp/lang/map.py

@@ -8,15 +8,7 @@
     pvector,
 )
 
-from basilisp.lang.interfaces import (
-    ILispObject,
-    IMapEntry,
-    IMeta,
-    IPersistentCollection,
-    IPersistentMap,
-    ISeq,
-    ISeqable,
-)
+from basilisp.lang.interfaces import ILispObject, IMapEntry, IMeta, IPersistentMap, ISeq
 from basilisp.lang.obj import map_lrepr as _map_lrepr
 from basilisp.lang.seq import sequence
 from basilisp.lang.vector import Vector
@@ -56,13 +48,7 @@ def from_vec(v: Sequence[Union[K, V]]) -> "MapEntry[K, V]":
         return MapEntry(pvector(v))
 
 
-class Map(
-    IPersistentCollection[MapEntry[K, V]],
-    ILispObject,
-    IMeta,
-    ISeqable[MapEntry[K, V]],
-    IPersistentMap[K, V],
-):
+class Map(ILispObject, IMeta, IPersistentMap[K, V]):
     """Basilisp Map. Delegates internally to a pyrsistent.PMap object.
     Do not instantiate directly. Instead use the m() and map() factory
     methods below."""
@@ -155,8 +141,11 @@ def update_with(
 
     def cons(
         self,
-        *elems: Union["Map[K, V]", Dict[K, V], MapEntry[K, V], Vector[Union[K, V]]],
+        *elems: Union["Map[K, V]", Dict[K, V], IMapEntry[K, V], Vector[Union[K, V]]],
     ) -> "Map[K, V]":
+        # For now, this definition does not take the generic Mapping[K, V] type
+        # because Vectors are technically Mapping[int, V] types, so this would
+        # require restructuring of the logic.
         e = self._inner.evolver()
         try:
             for elem in elems:
@@ -166,7 +155,7 @@ def cons(
                 elif isinstance(elem, dict):
                     for k, v in elem.items():
                         e.set(k, v)
-                elif isinstance(elem, MapEntry):
+                elif isinstance(elem, IMapEntry):
                     e.set(elem.key, elem.value)
                 else:
                     entry = MapEntry.from_vec(elem)
@@ -181,7 +170,7 @@ def cons(
     def empty() -> "Map":
         return m()
 
-    def seq(self) -> ISeq[MapEntry[K, V]]:
+    def seq(self) -> ISeq[IMapEntry[K, V]]:
         return sequence(self)