Refactor primary interfaces so they are easier to use in deftype (#370)

Refactor all of the primary data structure interfaces so they are easier to use for deftype* forms. Precursor to #369

In particular, reduce the use of concrete types in favor of interface types, particularly in Basilisp code.

Author: chrisrink10

.prospector.yaml

@@ -5,6 +5,12 @@ test-warnings: true
 doc-warnings: false
 
 ignore-paths:
+  - .cache
+  - .mypy_cache
+  - .pytest_cache
+  - .tox
+  - build
+  - dist
   - tests
 
 pep8:

mypy.ini

@@ -0,0 +1,15 @@
+[mypy]
+check_untyped_defs = True
+warn_unused_ignores = True
+
+[mypy-atomos.*]
+ignore_missing_imports = True
+
+[mypy-astor.*]
+ignore_missing_imports = True
+
+[mypy-functional.*]
+ignore_missing_imports = True
+
+[mypy-pytest.*]
+ignore_missing_imports = True

src/basilisp/cli.py

@@ -160,18 +160,18 @@ def repl(
             if result is eof:  # pragma: no cover
                 continue
             print(runtime.lrepr(result))
-            repl_module.mark_repl_result(result)
+            repl_module.mark_repl_result(result)  # type: ignore
         except reader.SyntaxError as e:
             traceback.print_exception(reader.SyntaxError, e, e.__traceback__)
-            repl_module.mark_exception(e)
+            repl_module.mark_exception(e)  # type: ignore
             continue
         except compiler.CompilerException as e:
             traceback.print_exception(compiler.CompilerException, e, e.__traceback__)
-            repl_module.mark_exception(e)
+            repl_module.mark_exception(e)  # type: ignore
             continue
         except Exception as e:
             traceback.print_exception(Exception, e, e.__traceback__)
-            repl_module.mark_exception(e)
+            repl_module.mark_exception(e)  # type: ignore
             continue
 
 

src/basilisp/core/__init__.lpy

@@ -135,35 +135,35 @@
     :arglists '([o])}
   list?
   (fn list? [o]
-    (instance? basilisp.lang.list/List o)))
+    (instance? basilisp.lang.interfaces/IPersistentList o)))
 
 (def
   ^{:doc      "Return true if o is a map."
     :arglists '([o])}
   map?
   (fn map? [o]
-    (instance? basilisp.lang.map/Map o)))
+    (instance? basilisp.lang.interfaces/IPersistentMap o)))
 
 (def
   ^{:doc      "Return true if o is a set."
     :arglists '([o])}
   set?
   (fn set? [o]
-    (instance? basilisp.lang.set/Set o)))
+    (instance? basilisp.lang.interfaces/IPersistentSet o)))
 
 (def
   ^{:doc      "Return true if o is a vector."
     :arglists '([o])}
   vector?
   (fn vector? [o]
-    (instance? basilisp.lang.vector/Vector o)))
+    (instance? basilisp.lang.interfaces/IPersistentVector o)))
 
 (def
   ^{:doc      "Return true if o implements Seq."
     :arglists '([o])}
   seq?
   (fn seq? [o]
-    (instance? basilisp.lang.seq/Seq o)))
+    (instance? basilisp.lang.interfaces/ISeq o)))
 
 (def ^{:doc      "Coerce the argument o to a Seq. If o is nil, return nil."
        :arglists '([o])}

src/basilisp/importer.py

@@ -7,7 +7,7 @@
 import sys
 import types
 from importlib.abc import MetaPathFinder, SourceLoader
-from typing import Optional, List, Dict
+from typing import List, Mapping, MutableMapping, Optional
 
 import basilisp.lang.compiler as compiler
 import basilisp.lang.reader as reader
@@ -92,7 +92,7 @@ class BasilispImporter(MetaPathFinder, SourceLoader):
     Python."""
 
     def __init__(self):
-        self._cache = {}
+        self._cache: MutableMapping[str, dict] = {}
 
     def find_spec(
         self,
@@ -175,8 +175,8 @@ def create_module(self, spec: importlib.machinery.ModuleSpec):
     def _exec_cached_module(
         self,
         fullname: str,
-        loader_state: Dict[str, str],
-        path_stats: Dict[str, int],
+        loader_state: Mapping[str, str],
+        path_stats: Mapping[str, int],
         module: types.ModuleType,
     ):
         """Load and execute a cached Basilisp module."""
@@ -203,8 +203,8 @@ def _exec_cached_module(
     def _exec_module(
         self,
         fullname: str,
-        loader_state: Dict[str, str],
-        path_stats: Dict[str, int],
+        loader_state: Mapping[str, str],
+        path_stats: Mapping[str, int],
         module: types.ModuleType,
     ):
         """Load and execute a non-cached Basilisp module."""

src/basilisp/lang/associative.py

@@ -1,17 +1,17 @@
-from typing import Generic, TypeVar, Callable
+from typing import Callable, Generic, TypeVar
 
 import atomos.atom
 
-from basilisp.lang.deref import Deref
+from basilisp.lang.interfaces import IDeref
 
 T = TypeVar("T")
 
 
-class Atom(Deref, Generic[T]):
+class Atom(IDeref[T], Generic[T]):
     __slots__ = ("_atom",)
 
     def __init__(self, state: T) -> None:
-        self._atom = atomos.atom.Atom(state)
+        self._atom = atomos.atom.Atom(state)  # pylint: disable=assigning-non-slot
 
     def compare_and_set(self, old, new):
         return self._atom.compare_and_set(old, new)

src/basilisp/lang/atom.py

@@ -2,7 +2,7 @@
 import itertools
 import os
 import types
-from typing import Any, Callable, Dict, Iterable, List, Optional
+from typing import Any, Callable, Iterable, List, Mapping, Optional
 
 from astor import code_gen as codegen
 
@@ -44,7 +44,7 @@ def to_py_str(t: ast.AST) -> str:
 class CompilerContext:
     __slots__ = ("_filename", "_gctx", "_pctx", "_optimizer")
 
-    def __init__(self, filename: str, opts: Optional[Dict[str, bool]] = None):
+    def __init__(self, filename: str, opts: Optional[Mapping[str, bool]] = None):
         self._filename = filename
         self._gctx = GeneratorContext(filename=filename, opts=opts)
         self._pctx = ParserContext(filename=filename, opts=opts)

src/basilisp/lang/collection.py

@@ -6,7 +6,7 @@
 
 import basilisp.lang.keyword as kw
 from basilisp.lang.compiler.nodes import Node
-from basilisp.lang.seq import Seq
+from basilisp.lang.interfaces import ISeq
 from basilisp.lang.typing import LispForm
 
 
@@ -21,6 +21,6 @@ class CompilerPhase(Enum):
 class CompilerException(Exception):
     msg: str
     phase: CompilerPhase
-    form: Union[LispForm, None, Seq] = None
+    form: Union[LispForm, None, ISeq] = None
     lisp_ast: Optional[Node] = None
     py_ast: Optional[ast.AST] = None