basilisp 0.5.0.dev2__tar.gz → 0.5.1__tar.gz

{basilisp-0.5.0.dev2 → basilisp-0.5.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: basilisp
-Version: 0.5.0.dev2
-Summary: A Clojure-like lisp written for Python
+Version: 0.5.1
+Summary: A Clojure-compatible(-ish) Lisp dialect hosted on Python 3 with seamless Python interop.
 License-Expression: EPL-1.0
 License-File: LICENSE
 Author: Christopher Rink
@@ -28,19 +28,25 @@ Requires-Dist: pygments (>=2.9.0,<3.0.0) ; extra == "pygments"
 Requires-Dist: pyrsistent (>=0.18.0,<1.0.0)
 Requires-Dist: pytest (>=7.0.0,<9.0.0) ; extra == "pytest"
 Requires-Dist: typing-extensions (>=4.7.0,<5.0.0)
+Project-URL: Bug Tracker, https://github.com/basilisp-lang/basilisp/issues
+Project-URL: Changelog, https://github.com/basilisp-lang/basilisp/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://docs.basilisp.org
+Project-URL: Homepage, https://github.com/basilisp-lang/basilisp
+Project-URL: Repository, https://github.com/basilisp-lang/basilisp
 Description-Content-Type: text/markdown
 
 # 🐍 basilisp 🐍
 
-A Clojure-compatible(-ish) Lisp dialect targeting Python 3.10+.
+A Clojure-compatible(-ish) Lisp dialect hosted on Python 3 with seamless Python
+interop.
 
-[![PyPI](https://img.shields.io/pypi/v/basilisp.svg?style=flat-square)](https://pypi.org/project/basilisp/) [![python](https://img.shields.io/pypi/pyversions/basilisp.svg?style=flat-square)](https://pypi.org/project/basilisp/) [![pyimpl](https://img.shields.io/pypi/implementation/basilisp.svg?style=flat-square)](https://pypi.org/project/basilisp/) [![readthedocs](https://img.shields.io/readthedocs/basilisp.svg?style=flat-square)](https://basilisp.readthedocs.io/) [![Run tests](https://github.com/basilisp-lang/basilisp/actions/workflows/run-tests.yml/badge.svg?branch=main)](https://github.com/basilisp-lang/basilisp/actions/workflows/run-tests.yml) [![Coveralls github](https://img.shields.io/coveralls/github/basilisp-lang/basilisp.svg?style=flat-square)](https://coveralls.io/github/basilisp-lang/basilisp) [![license](https://img.shields.io/github/license/basilisp-lang/basilisp.svg?style=flat-square)](https://github.com/basilisp-lang/basilisp/blob/master/LICENSE) [![Slack](https://img.shields.io/badge/Slack-Clojurians-green?style=flat-square)](https://clojurians.slack.com/archives/C071RFV2Z1D)
+[![PyPI](https://img.shields.io/pypi/v/basilisp.svg?style=flat-square)](https://pypi.org/project/basilisp/) [![python](https://img.shields.io/pypi/pyversions/basilisp.svg?style=flat-square)](https://pypi.org/project/basilisp/) [![pyimpl](https://img.shields.io/pypi/implementation/basilisp.svg?style=flat-square)](https://pypi.org/project/basilisp/) [![readthedocs](https://img.shields.io/readthedocs/basilisp.svg?style=flat-square)](https://basilisp.readthedocs.io/) [![Run tests](https://github.com/basilisp-lang/basilisp/actions/workflows/run-tests.yml/badge.svg?branch=main)](https://github.com/basilisp-lang/basilisp/actions/workflows/run-tests.yml) [![Run clojure-test-suite](https://github.com/basilisp-lang/basilisp/actions/workflows/run-clojure-test-suite.yml/badge.svg?branch=main)](https://github.com/basilisp-lang/basilisp/actions/workflows/run-clojure-test-suite.yml) [![Coveralls github](https://img.shields.io/coveralls/github/basilisp-lang/basilisp.svg?style=flat-square)](https://coveralls.io/github/basilisp-lang/basilisp) [![license](https://img.shields.io/github/license/basilisp-lang/basilisp.svg?style=flat-square)](https://github.com/basilisp-lang/basilisp/blob/master/LICENSE) [![Slack](https://img.shields.io/badge/Slack-Clojurians-green?style=flat-square)](https://clojurians.slack.com/archives/C071RFV2Z1D)
 
 ## Getting Started
 
 Basilisp is developed on [GitHub](https://github.com/basilisp-lang/basilisp) and
 hosted on [PyPI](https://pypi.python.org/pypi/basilisp). You can fetch Basilisp
-using `pip`:
+using `pip` (or any other Python dependency manager which can pull from PyPI):
 
 ```bash
 pip install basilisp
@@ -52,27 +58,24 @@ Once Basilisp is installed, you can enter into the REPL using:
 basilisp repl
 ```
 
-Basilisp [documentation](https://basilisp.readthedocs.io) can help guide your
-exploration at the REPL. Additionally, Basilisp features many of the same functions
-and idioms as [Clojure](https://clojure.org/), so you may find guides and
-documentation there helpful for getting started.
+## Documentation
+
+Basilisp [documentation](https://docs.basilisp.org) can help guide your
+exploration at the REPL and beyond. Additionally, Basilisp features many of the
+same functions and idioms as [Clojure](https://clojure.org/), so you may find
+guides and documentation there helpful for getting started.
 
 For those who prefer a video introduction, feel free to check out this
 [talk](https://youtu.be/ruGRHYpq448?si=0jr2a6uWlq6Vi2_k) hosted by the
 [London Clojurians](https://www.meetup.com/london-clojurians/) group about Basilisp.
 
-## Why does this project exist?
-
-Basilisp is a project I (@chrisrink10) created to learn about Python, Clojure,
-hosted  languages, and compilers.
+## Contributing
 
-That said, it is generally stable at this point with reasonably high test
-coverage, linting, and type checking. Work is ongoing to complete the rest of the
-standard library implementations. I suspect it could be used to build small
-applications and tools at this point, though I would not recommend it unless you
-like being an early adopter.
+Contributions are welcome, but please review the [contributing guidelines](https://docs.basilisp.org/en/latest/contributing.html)
+before submitting an issue or pull request.
 
-_Use in a production setting at your own risk._
+If you have a question, please use [Github Discussions](https://github.com/basilisp-lang/basilisp/discussions)
+or post in the [`#basilisp` channel](https://clojurians.slack.com/archives/C0A2CQQQVPB) in the Clojurians Slack.
 
 ## License
 

basilisp-0.5.1/README.md

@@ -0,0 +1,45 @@
+# 🐍 basilisp 🐍
+
+A Clojure-compatible(-ish) Lisp dialect hosted on Python 3 with seamless Python
+interop.
+
+[![PyPI](https://img.shields.io/pypi/v/basilisp.svg?style=flat-square)](https://pypi.org/project/basilisp/) [![python](https://img.shields.io/pypi/pyversions/basilisp.svg?style=flat-square)](https://pypi.org/project/basilisp/) [![pyimpl](https://img.shields.io/pypi/implementation/basilisp.svg?style=flat-square)](https://pypi.org/project/basilisp/) [![readthedocs](https://img.shields.io/readthedocs/basilisp.svg?style=flat-square)](https://basilisp.readthedocs.io/) [![Run tests](https://github.com/basilisp-lang/basilisp/actions/workflows/run-tests.yml/badge.svg?branch=main)](https://github.com/basilisp-lang/basilisp/actions/workflows/run-tests.yml) [![Run clojure-test-suite](https://github.com/basilisp-lang/basilisp/actions/workflows/run-clojure-test-suite.yml/badge.svg?branch=main)](https://github.com/basilisp-lang/basilisp/actions/workflows/run-clojure-test-suite.yml) [![Coveralls github](https://img.shields.io/coveralls/github/basilisp-lang/basilisp.svg?style=flat-square)](https://coveralls.io/github/basilisp-lang/basilisp) [![license](https://img.shields.io/github/license/basilisp-lang/basilisp.svg?style=flat-square)](https://github.com/basilisp-lang/basilisp/blob/master/LICENSE) [![Slack](https://img.shields.io/badge/Slack-Clojurians-green?style=flat-square)](https://clojurians.slack.com/archives/C071RFV2Z1D)
+
+## Getting Started
+
+Basilisp is developed on [GitHub](https://github.com/basilisp-lang/basilisp) and
+hosted on [PyPI](https://pypi.python.org/pypi/basilisp). You can fetch Basilisp
+using `pip` (or any other Python dependency manager which can pull from PyPI):
+
+```bash
+pip install basilisp
+```
+
+Once Basilisp is installed, you can enter into the REPL using:
+
+```bash
+basilisp repl
+```
+
+## Documentation
+
+Basilisp [documentation](https://docs.basilisp.org) can help guide your
+exploration at the REPL and beyond. Additionally, Basilisp features many of the
+same functions and idioms as [Clojure](https://clojure.org/), so you may find
+guides and documentation there helpful for getting started.
+
+For those who prefer a video introduction, feel free to check out this
+[talk](https://youtu.be/ruGRHYpq448?si=0jr2a6uWlq6Vi2_k) hosted by the
+[London Clojurians](https://www.meetup.com/london-clojurians/) group about Basilisp.
+
+## Contributing
+
+Contributions are welcome, but please review the [contributing guidelines](https://docs.basilisp.org/en/latest/contributing.html)
+before submitting an issue or pull request.
+
+If you have a question, please use [Github Discussions](https://github.com/basilisp-lang/basilisp/discussions)
+or post in the [`#basilisp` channel](https://clojurians.slack.com/archives/C0A2CQQQVPB) in the Clojurians Slack.
+
+## License
+
+Eclipse Public License 1.0

{basilisp-0.5.0.dev2 → basilisp-0.5.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "basilisp"
-version = "0.5.0.dev2"
-description = "A Clojure-like lisp written for Python"
+version = "0.5.1"
+description = "A Clojure-compatible(-ish) Lisp dialect hosted on Python 3 with seamless Python interop."
 authors = [
     { name = "Christopher Rink", email = "chris@crink.dev" },
 ]
@@ -11,8 +11,6 @@ requires-python = ">=3.10"
 packages = [
     { include = "basilisp", from = "src" },
 ]
-repository = "https://github.com/basilisp-lang/basilisp"
-documentation = "https://basilisp.readthedocs.io/"
 classifiers = [
     # Trove classifiers
     # Full list: https://pypi.python.org/pypi?%3Aaction=list_classifiers
@@ -38,6 +36,13 @@ dependencies = [
     "typing-extensions (>=4.7.0,<5.0.0)",
 ]
 
+[project.urls]
+Homepage = "https://github.com/basilisp-lang/basilisp"
+Documentation = "https://docs.basilisp.org"
+Repository = "https://github.com/basilisp-lang/basilisp"
+"Bug Tracker" = "https://github.com/basilisp-lang/basilisp/issues"
+Changelog = "https://github.com/basilisp-lang/basilisp/blob/main/CHANGELOG.md"
+
 [dependency-groups]
 dev = [
     "black >=24.0.0",
@@ -108,7 +113,6 @@ omit = [
     "*/__version__.py",
     "*/basilisp/contrib/sphinx/*",
 ]
-patch = ["subprocess"]
 
 [tool.coverage.paths]
 source = [

{basilisp-0.5.0.dev2 → basilisp-0.5.1}/src/basilisp/cli.py

@@ -324,7 +324,9 @@ def _add_debug_arg_group(parser: argparse.ArgumentParser) -> None:
     )
 
 
-def _add_import_arg_group(parser: argparse.ArgumentParser) -> None:
+def _add_import_arg_group(
+    parser: argparse.ArgumentParser, include_unsafe_path_default: bool = True
+) -> None:
     group = parser.add_argument_group(
         "path options",
         description=(
@@ -336,14 +338,16 @@ def _add_import_arg_group(parser: argparse.ArgumentParser) -> None:
         "--include-unsafe-path",
         action="store",
         nargs="?",
-        const=True,
-        default=os.getenv("BASILISP_INCLUDE_UNSAFE_PATH", "true"),
+        const=include_unsafe_path_default,
+        default=os.getenv(
+            "BASILISP_INCLUDE_UNSAFE_PATH", str(include_unsafe_path_default)
+        ),
         type=_to_bool,
         help=(
             "if true, automatically prepend a potentially unsafe path to `sys.path`; "
             "setting `--include-unsafe-path=false` is the Basilisp equivalent to "
             "setting PYTHONSAFEPATH to a non-empty string for CPython's REPL "
-            "(env: BASILISP_INCLUDE_UNSAFE_PATH; default: true)"
+            f"(env: BASILISP_INCLUDE_UNSAFE_PATH; default: {str(include_unsafe_path_default).lower()})"
         ),
     )
     group.add_argument(
@@ -732,12 +736,23 @@ def test(
     args: argparse.Namespace,
     extra: list[str],
 ) -> None:  # pragma: no cover
+    # Add `test` or `tests` directory to the current working directory
+    if args.include_default_test_path:
+        if not getattr(args, "include_path", []):
+            args.include_path = []
+        for d in ("tests", "test"):
+            p = Path.cwd() / d
+            if p.exists():
+                args.include_path.append(str(p))
+
     init_path(args)
     basilisp.init(_compiler_opts(args))
+
     # parse_known_args leaves the `--` separator as the first element if it is present
     # but retaining that causes PyTest to interpret all the arguments as positional
     if extra and extra[0] == "--":
         extra = extra[1:]
+
     try:
         import pytest
     except (ImportError, ModuleNotFoundError):
@@ -784,8 +799,23 @@ def test(
     allows_extra=True,
 )
 def _add_test_subcommand(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "-d",
+        "--include-default-test-path",
+        action="store",
+        nargs="?",
+        const=True,
+        default=os.getenv("BASILISP_INCLUDE_DEFAULT_TEST_PATH", "true"),
+        type=_to_bool,
+        help=(
+            "if true, automatically prepend a 'test' or 'tests' directory to the "
+            "PYTHONPATH enabling discovery and importing of test namespaces "
+            "(env: BASILISP_INCLUDE_DEFAULT_TEST_PATH; default: true)"
+        ),
+    )
+
     _add_compiler_arg_group(parser)
-    _add_import_arg_group(parser)
+    _add_import_arg_group(parser, include_unsafe_path_default=False)
     _add_runtime_arg_group(parser)
     _add_debug_arg_group(parser)
 

{basilisp-0.5.0.dev2 → basilisp-0.5.1}/src/basilisp/core.lpy

@@ -23,7 +23,7 @@
 (def ^{:doc      "Create a list from the arguments."
        :arglists '([& args])}
   list
-  (fn* list [& args] (if args args '())))
+  (fn* list [& args] (if args (basilisp.lang.list/list args) '())))
 
 (def
   ^{:doc      "If ``seq`` is a Seq, return the first element from ``seq``. If ``seq``
@@ -209,11 +209,17 @@
   (fn iterator-seq [it]
     (basilisp.lang.runtime/to-iterator-seq it)))
 
-
 (def ^{:doc      "Apply function ``f`` to the arguments provided.
 
                   The last argument must always be coercible to a Seq. Intermediate
-                  arguments are not modified."
+                  arguments are not modified. The Seq in the last argument may be
+                  infinite if the called function ``f`` is lazy.
+
+                  .. warning::
+
+                     Applying arguments to Python functions (rather than Basilisp
+                     functions) will consume the argument Seq eagerly. Infinite
+                     Seqs are **not** supported for Python functions."
        :arglists '([f & args])}
   apply
   (fn apply [f & args]
@@ -231,7 +237,7 @@
        :arglists '([& seqs])}
   concat
   (fn concat [& seqs]
-    (apply basilisp.lang.runtime/concat seqs)))
+    (basilisp.lang.runtime/concat-from-seq seqs)))
 
 (def
   ^{:doc      "Create a hash map from pairs of input arguments."
@@ -2840,11 +2846,13 @@
       (cons (f (first coll)) (map f (rest coll))))))
   ([f coll & colls]
    (lazy-seq
-    (when-let [coll (seq coll)]
-      (let [colls (map seq colls)]
-        (when (every? identity colls)
-          (cons (apply f (first coll) (map first colls))
-                (apply map f (rest coll) (map rest colls)))))))))
+    (let [step-elems (fn step-elems [colls]
+                       (lazy-seq
+                        (let [colls (map seq colls)]
+                          (when (every? identity colls)
+                            (cons (map first colls)
+                                  (step-elems (map rest colls)))))))]
+      (map #(apply f %) (step-elems (cons coll colls)))))))
 
 (def ^{:doc "Return a vector of ``(f elem)`` for elements in ``coll``\\. More than one
              collection may be supplied. If more than one collection is supplied, the
@@ -2878,10 +2886,8 @@
   "Return a lazy sequence of the concatenated results of mapping ``f`` over ``colls``\\."
   ([f]
    (comp (map f) cat))
-  ([f coll]
-   (apply concat (map f coll)))
-  ([f coll & colls]
-   (apply concat (apply map f coll colls))))
+  ([f & colls]
+   (apply concat (apply map f colls))))
 
 (defn filter
   "Return a lazy sequence of elements from ``coll`` where ``(pred elem)`` returns a

basilisp-0.5.1/src/basilisp/csv.lpy

@@ -0,0 +1,59 @@
+(ns basilisp.csv
+  "Wrapper functions for :external:py:mod:`csv` which reads and writes CSVs."
+  (:require
+   [basilisp.io :as bio])
+  (:import
+   csv))
+
+(defn read-csv
+  "Returns a lazy sequence of vectors corresponding to the rows of a CSV file.
+
+  If ``input`` is a string, it will be treated as the contents of a CSV. Otherwise,
+  it will be treated as a :external:py:class:`io.TextIOBase`.
+
+  The reader function supports the following keyword arguments:
+
+   :keyword ``:separator``: the character used as the separator for a fields in a row
+       default is \",\"
+   :keyword ``:quote``: the quote character used on quoted fields; default is ``true``"
+  [input & {:keys [separator quote] :or {separator "," quote "\""}}]
+  (let [f       (if (string? input)
+                  (io/StringIO input)
+                  input)
+        reader  (csv/reader f ** :delimiter separator :quotechar quote)
+        do-read (fn read-csv*
+                  []
+                  (when-some [row (python/next reader nil)]
+                    (cons (vec row) (lazy-seq (read-csv*)))))]
+    (lazy-seq (do-read))))
+
+(defn rows->maps
+  "Returns a lazy sequence mapping over a sequence of CSV data (as vectors)
+  converting them to maps.
+
+  The first row will be used as the headers. The ``:key-fn`` keyword argument
+  names a function which will be used to map over the keys."
+  [rows & {:keys [key-fn] :or {key-fn keyword}}]
+  (let [header (mapv key-fn (first rows))]
+    (map #(zipmap header %) (rest rows))))
+
+(defn write-csv
+  "Write a sequence of rows in CSV format to ``writer``, which should be an
+  :external:py:class:`io.TextIOBase`.
+
+  The writing function supports the following keyword arguments:
+
+   :keyword ``:separator``: the character used as the separator for a fields in a row
+       default is \",\"
+   :keyword ``:quote``: the quote character used on quoted fields; default is ``true``
+   :keyword ``:newline``: the newline character to use between rows (``:lf`` or
+       ``:cr+lf``)"
+  [writer data & {:keys [separator quote newline] :or {separator "," quote "\"" newline :lf}}]
+  (let [nl (cond
+             (= newline :lf)    "\n"
+             (= newline :cr+lf) "\r\n"
+             :else              (throw
+                                 (ex-info "newline must be one of: :lf or :cr+lf"
+                                          {:newline newline})))
+        w  (csv/writer writer ** :delimiter separator :quotechar quote :lineterminator nl)]
+    (.writerows w (map #(mapv str %) data))))

{basilisp-0.5.0.dev2 → basilisp-0.5.1}/src/basilisp/lang/compiler/generator.py

@@ -799,6 +799,7 @@ _ATTR_FROZEN_DECORATOR_NAME = _load_attr(f"{_ATTR_ALIAS}.frozen")
 _ATTRIB_FIELD_FN_NAME = _load_attr(f"{_ATTR_ALIAS}.field")
 _BASILISP_LOAD_CONSTANT_NAME = _load_attr(f"{_RUNTIME_ALIAS}._load_constant")
 _COERCE_SEQ_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}.to_seq")
+_UNWRAP_REST_ARGS_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}._unwrap_rest_args")
 _BASILISP_FN_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}._basilisp_fn")
 _FN_WITH_ATTRS_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}._with_attrs")
 _BASILISP_TYPE_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}._basilisp_type")
@@ -1707,7 +1708,7 @@ def __fn_args_to_py_ast(
                     value=ast.IfExp(
                         test=ast.Name(id=arg_name, ctx=ast.Load()),
                         body=ast.Call(
-                            func=_NEW_LIST_FN_NAME,
+                            func=_UNWRAP_REST_ARGS_FN_NAME,
                             args=[ast.Name(id=arg_name, ctx=ast.Load())],
                             keywords=[],
                         ),
@@ -1738,6 +1739,8 @@ def __fn_args_to_py_ast(
 def __fn_decorator(
     arities: Iterable[int],
     has_rest_arg: bool = False,
+    *,
+    max_fixed_arity: int,
 ) -> ast.Call:
     return ast.Call(
         func=_BASILISP_FN_FN_NAME,
@@ -1767,7 +1770,8 @@ def __fn_decorator(
                     ),
                     ctx=ast.Load(),
                 ),
-            )
+            ),
+            ast.keyword(arg="max_fixed_arity", value=ast.Constant(max_fixed_arity)),
         ],
     )
 
@@ -1875,6 +1879,7 @@ def __single_arity_fn_to_py_ast(  # pylint: disable=too-many-locals
                                         __fn_decorator(
                                             (len(fn_args),),
                                             has_rest_arg=method.is_variadic,
+                                            max_fixed_arity=node.max_fixed_arity,
                                         )
                                     ],
                                     (
@@ -1905,10 +1910,11 @@ def __multi_arity_dispatch_fn(  # pylint: disable=too-many-arguments,too-many-lo
     ctx: GeneratorContext,
     name: str,
     arity_map: Mapping[int, str],
+    *,
     return_tags: Iterable[Node | None],
     default_name: str | None = None,
     rest_arity_fixed_arity: int | None = None,
-    max_fixed_arity: int | None = None,
+    max_fixed_arity: int,
     meta_node: MetaNode | None = None,
     is_async: bool = False,
 ) -> GeneratedPyAST[ast.expr]:
@@ -2085,6 +2091,7 @@ def __multi_arity_dispatch_fn(  # pylint: disable=too-many-arguments,too-many-lo
                                         )
                                     ),
                                     has_rest_arg=default_name is not None,
+                                    max_fixed_arity=max_fixed_arity,
                                 )
                             ],
                         )
@@ -3688,7 +3695,7 @@ def _const_val_to_py_ast(
     `_const_node_to_py_ast`."""
     try:
         serialized = pickle.dumps(form)
-    except (pickle.PicklingError, RecursionError) as e:
+    except (pickle.PicklingError, RecursionError) as e:  # pragma: no cover
         # For types without custom "constant" handling code, we defer to pickle
         # to generate a representation that can be reloaded from the generated
         # byte code. There are a few cases where that may not be possible for one

{basilisp-0.5.0.dev2 → basilisp-0.5.1}/src/basilisp/lang/interfaces.py

@@ -76,18 +76,28 @@ class ICounted(Sized, ABC):
     __slots__ = ()
 
 
-class IIndexed(ICounted, ABC):
-    """``IIndexed`` is a marker interface for types can be accessed by index.
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+class IIndexed(ICounted, Generic[V], ABC):
+    """``IIndexed`` is an interface for types can be accessed by index.
 
     Of the builtin collections, only Vectors are ``IIndexed`` . ``IIndexed`` types
     respond ``True`` to the :lpy:fn:`indexed?` predicate.
 
     .. seealso::
 
-       :lpy:fn:`indexed?`"""
+       :lpy:fn:`indexed?`, :lpy:fn:`nth`"""
 
     __slots__ = ()
 
+    NTH_SENTINEL = object()
+
+    @abstractmethod
+    def nth(self, k: int, notfound: V | None = NTH_SENTINEL) -> V | None:  # type: ignore[assignment]
+        raise NotImplementedError()
+
 
 T_ExceptionInfo = TypeVar("T_ExceptionInfo", bound="IPersistentMap")
 
@@ -109,10 +119,6 @@ class IExceptionInfo(Exception, Generic[T_ExceptionInfo], ABC):
         raise NotImplementedError()
 
 
-K = TypeVar("K")
-V = TypeVar("V")
-
-
 class IMapEntry(Generic[K, V], ABC):
     """``IMapEntry`` values are produced :lpy:fn:`seq` ing over any
     :py:class:`IAssociative` (such as a Basilisp map).

{basilisp-0.5.0.dev2 → basilisp-0.5.1}/src/basilisp/lang/map.py

@@ -21,7 +21,7 @@ from basilisp.lang.interfaces import (
     ReduceKVFunction,
 )
 from basilisp.lang.obj import (
-    PRINT_SEPARATOR,
+    MAP_PRINT_SEPARATOR,
     SURPASSED_PRINT_LENGTH,
     SURPASSED_PRINT_LEVEL,
     PrintSettings,
@@ -194,7 +194,7 @@ def map_lrepr(  # pylint: disable=too-many-locals
     else:
         items = list(entry_reprs())
 
-    seq_lrepr = PRINT_SEPARATOR.join(items + trailer)
+    seq_lrepr = MAP_PRINT_SEPARATOR.join(items + trailer)
 
     ns_prefix = ("#:" + ns_name_shared) if ns_name_shared else ""
     if kwargs["print_meta"] and meta:

{basilisp-0.5.0.dev2 → basilisp-0.5.1}/src/basilisp/lang/obj.py

@@ -26,7 +26,8 @@ PRINT_LEVEL: PrintCountSetting = None
 PRINT_META = False
 PRINT_NAMESPACE_MAPS = False
 PRINT_READABLY = True
-PRINT_SEPARATOR = " "
+SEQ_PRINT_SEPARATOR = " "
+MAP_PRINT_SEPARATOR = ", "
 
 
 class PrintSettings(TypedDict, total=False):
@@ -115,7 +116,7 @@ def seq_lrepr(
     kw_items = kwargs.copy()
     kw_items["human_readable"] = False
     items = list(map(lambda o: lrepr(o, **kw_items), items))
-    seq_lrepr = PRINT_SEPARATOR.join(items + trailer)
+    seq_lrepr = SEQ_PRINT_SEPARATOR.join(items + trailer)
 
     print_meta = kwargs["print_meta"]
     if print_meta and meta:

{basilisp-0.5.0.dev2 → basilisp-0.5.1}/src/basilisp/lang/reader.py

@@ -1797,7 +1797,7 @@ def _read_next_consuming_comment(ctx: ReaderContext) -> RawReaderForm:
     while True:
         v = _read_next(ctx)
         if v is ctx.eof:
-            return ctx.eof
+            return cast(RawReaderForm, ctx.eof)
         if v is COMMENT or isinstance(v, Comment):
             continue
         return v