Produce a Lisp string representation from LispObject ABC (#316)

* Produce a Lisp string representation from LispObject ABC

* Fix linting and MyPy errors

* Fix old references

* Add some tests

* More lrepr tests

* Fix emergent MyPy error

* repr/str support

* Fix unicode

* Refactor a bit

* Test print-dup and print-readably

* Reformat

Author: chrisrink10

src/basilisp/core/__init__.lpy

@@ -276,13 +276,13 @@
 (defn str
   "Create a string representation of o."
   ([] "")
-  ([o] (builtins/str o))
+  ([o] (basilisp.lang.runtime/lstr o))
   ([o & args]
    (let [coerce (fn [in out]
                   (if (seq (rest in))
                     (recur (rest in)
-                           (conj out (builtins/str (first in))))
-                    (conj out (builtins/str (first in)))))
+                           (conj out (basilisp.lang.runtime/lstr (first in))))
+                    (conj out (basilisp.lang.runtime/lstr (first in)))))
          strs   (coerce (conj args o) [])]
      (.join "" strs))))
 
@@ -1250,7 +1250,7 @@
 (defn repr
   "Return the reader representation of an object."
   [x]
-  (basilisp.lang.util/lrepr x))
+  (basilisp.lang.runtime/lrepr x))
 
 (defn flush
   "Flush the buffer currently bound to *out*."

src/basilisp/lang/compiler.py

@@ -41,7 +41,6 @@
 import basilisp.lang.seq as lseq
 import basilisp.lang.set as lset
 import basilisp.lang.symbol as sym
-import basilisp.lang.util
 import basilisp.lang.vector as vec
 from basilisp.lang.runtime import Var
 from basilisp.lang.typing import LispForm
@@ -2428,4 +2427,4 @@ def compile_bytecode(
         exec(bytecode, module.__dict__)
 
 
-lrepr = basilisp.lang.util.lrepr
+lrepr = runtime.lrepr

src/basilisp/lang/exception.py

@@ -1,5 +1,5 @@
 import basilisp.lang.map as lmap
-from basilisp.lang.util import lrepr
+from basilisp.lang.obj import lrepr
 
 
 class ExceptionInfo(Exception):

src/basilisp/lang/keyword.py

@@ -4,11 +4,12 @@
 
 import basilisp.lang.associative as lassoc
 import basilisp.lang.atom as atom
+from basilisp.lang.obj import LispObject
 
 __INTERN = atom.Atom(pmap())
 
 
-class Keyword:
+class Keyword(LispObject):
     __slots__ = ("_name", "_ns")
 
     def __init__(self, name: str, ns: Optional[str] = None) -> None:
@@ -23,14 +24,11 @@ def name(self) -> str:
     def ns(self) -> Optional[str]:
         return self._ns
 
-    def __str__(self):
+    def _lrepr(self, **kwargs) -> str:
         if self._ns is not None:
             return ":{ns}/{name}".format(ns=self._ns, name=self._name)
         return ":{name}".format(name=self._name)
 
-    def __repr__(self):
-        return str(self)
-
     def __eq__(self, other):
         return self is other
 

src/basilisp/lang/list.py

@@ -3,8 +3,8 @@
 
 from basilisp.lang.collection import Collection
 from basilisp.lang.meta import Meta
+from basilisp.lang.obj import LispObject
 from basilisp.lang.seq import Seq, EMPTY
-from basilisp.lang.util import lrepr
 
 
 class List(Collection, Meta, Seq):
@@ -19,9 +19,6 @@ def __init__(self, wrapped: PList, meta=None) -> None:
         self._inner = wrapped
         self._meta = meta
 
-    def __repr__(self):
-        return "({list})".format(list=" ".join(map(lrepr, self._inner)))
-
     def __eq__(self, other):
         return self._inner == other
 
@@ -36,6 +33,9 @@ def __hash__(self):
     def __len__(self):
         return len(self._inner)
 
+    def _lrepr(self, **kwargs) -> str:
+        return LispObject.seq_lrepr(self._inner, "(", ")", meta=self._meta, **kwargs)
+
     @property
     def meta(self):
         return self._meta

src/basilisp/lang/map.py

@@ -1,15 +1,16 @@
 from collections import Sequence
-from typing import Optional  # noqa: F401
+from typing import Optional  # noqa # pylint: disable=unused-import
 
 from functional import seq
 from pyrsistent import pmap, PMap
 
+import basilisp.lang.obj as lobj
 import basilisp.lang.vector as vec
 from basilisp.lang.associative import Associative
 from basilisp.lang.collection import Collection
 from basilisp.lang.meta import Meta
+from basilisp.lang.obj import LispObject, lrepr
 from basilisp.lang.seq import Seqable, sequence, Seq
-from basilisp.lang.util import lrepr
 from basilisp.util import partition
 
 
@@ -60,7 +61,7 @@ def from_vec(v: Sequence) -> "MapEntry":
         return MapEntry(vec.vector(v))
 
 
-class Map(Associative, Collection, Meta, Seqable):
+class Map(Associative, Collection, LispObject, Meta, Seqable):
     """Basilisp Map. Delegates internally to a pyrsistent.PMap object.
     Do not instantiate directly. Instead use the m() and map() factory
     methods below."""
@@ -71,12 +72,6 @@ def __init__(self, wrapped: PMap, meta=None) -> None:
         self._inner = wrapped
         self._meta = meta
 
-    def __repr__(self):
-        kvs = [
-            "{k} {v}".format(k=lrepr(k), v=lrepr(v)) for k, v in self._inner.iteritems()
-        ]
-        return "{{{kvs}}}".format(kvs=" ".join(kvs))
-
     def __call__(self, key, default=None):
         return self._inner.get(key, default)
 
@@ -102,6 +97,36 @@ def __iter__(self):
     def __len__(self):
         return len(self._inner)
 
+    def _lrepr(self, **kwargs):
+        print_level = kwargs["print_level"]
+        if isinstance(print_level, int) and print_level < 1:
+            return lobj.SURPASSED_PRINT_LEVEL
+
+        kwargs = LispObject._process_kwargs(**kwargs)
+
+        def entry_reprs():
+            for k, v in self._inner.iteritems():
+                yield "{k} {v}".format(k=lrepr(k, **kwargs), v=lrepr(v, **kwargs))
+
+        trailer = []
+        print_dup = kwargs["print_dup"]
+        print_length = kwargs["print_length"]
+        if not print_dup and isinstance(print_length, int):
+            items = seq(entry_reprs()).take(print_length + 1).to_list()
+            if len(items) > print_length:
+                items.pop()
+                trailer.append(lobj.SURPASSED_PRINT_LENGTH)
+        else:
+            items = list(entry_reprs())
+
+        seq_lrepr = lobj.PRINT_SEPARATOR.join(items + trailer)
+
+        print_meta = kwargs["print_meta"]
+        if print_meta and self._meta:
+            return f"^{lrepr(self._meta, **kwargs)} {{{seq_lrepr}}}"
+
+        return f"{{{seq_lrepr}}}"
+
     def items(self):
         return self._inner.items()
 

src/basilisp/lang/meta.py

@@ -2,7 +2,7 @@
 
 
 class Meta(ABC):
-    slots = ()
+    __slots__ = ()
 
     @property
     @abstractmethod

src/basilisp/lang/obj.py

@@ -0,0 +1,163 @@
+import datetime
+import uuid
+from abc import ABC, abstractmethod
+from decimal import Decimal
+from fractions import Fraction
+from typing import Union, Any, Pattern, Iterable
+
+from functional import seq
+from pyrsistent import pmap
+
+PrintCountSetting = Union[bool, int, None]
+
+SURPASSED_PRINT_LENGTH = "..."
+SURPASSED_PRINT_LEVEL = "#"
+
+PRINT_DUP = False
+PRINT_LENGTH: PrintCountSetting = 50
+PRINT_LEVEL: PrintCountSetting = None
+PRINT_META = False
+PRINT_READABLY = True
+PRINT_SEPARATOR = " "
+
+
+def _dec_print_level(lvl: PrintCountSetting):
+    """Decrement the print level if it is numeric."""
+    if isinstance(lvl, int):
+        return lvl - 1
+    return lvl
+
+
+class LispObject(ABC):
+    __slots__ = ()
+
+    def __repr__(self):
+        return self.lrepr()
+
+    def __str__(self):
+        return self.lrepr(human_readable=True)
+
+    @abstractmethod
+    def _lrepr(self, **kwargs) -> str:
+        """Private Lisp representation method. Callers (including object
+        internal callers) should not call this method directly, but instead
+        should use the module function .lrepr()."""
+        raise NotImplementedError()
+
+    def lrepr(self, **kwargs) -> str:
+        """Return a string representation of this Lisp object which can be
+        read by the reader."""
+        return lrepr(self, **kwargs)
+
+    @staticmethod
+    def seq_lrepr(
+        iterable: Iterable[Any], start: str, end: str, meta=None, **kwargs
+    ) -> str:
+        """Produce a Lisp representation of a sequential collection, bookended
+        with the start and end string supplied. The keyword arguments will be
+        passed along to lrepr for the sequence elements."""
+        print_level = kwargs["print_level"]
+        if isinstance(print_level, int) and print_level < 1:
+            return SURPASSED_PRINT_LEVEL
+
+        kwargs = LispObject._process_kwargs(**kwargs)
+
+        trailer = []
+        print_dup = kwargs["print_dup"]
+        print_length = kwargs["print_length"]
+        if not print_dup and isinstance(print_length, int):
+            items = seq(iterable).take(print_length + 1).to_list()
+            if len(items) > print_length:
+                items.pop()
+                trailer.append(SURPASSED_PRINT_LENGTH)
+        else:
+            items = iterable
+
+        items = seq(items).map(lambda o: lrepr(o, **kwargs)).to_list()
+        seq_lrepr = PRINT_SEPARATOR.join(items + trailer)
+
+        print_meta = kwargs["print_meta"]
+        if print_meta and meta:
+            return f"^{lrepr(meta, **kwargs)} {start}{seq_lrepr}{end}"
+
+        return f"{start}{seq_lrepr}{end}"
+
+    @staticmethod
+    def _process_kwargs(**kwargs):
+        """Process keyword arguments, decreasing the print-level. Should be called
+        after examining the print level for the current level."""
+        return pmap(initial=kwargs).transform(["print_level"], _dec_print_level)
+
+
+def lrepr(  # pylint: disable=too-many-arguments
+    o: Any,
+    human_readable: bool = False,
+    print_dup: bool = PRINT_DUP,
+    print_length: PrintCountSetting = PRINT_LENGTH,
+    print_level: PrintCountSetting = PRINT_LEVEL,
+    print_meta: bool = PRINT_META,
+    print_readably: bool = PRINT_READABLY,
+) -> str:
+    """Return a string representation of a Lisp object.
+
+    Permissible keyword arguments are:
+    - human_readable: if logical True, print strings without quotations or
+                      escape sequences (default: false)
+    - print_dup: if logical true, print objects in a way that preserves their
+                 types (default: false)
+    - print_length: the number of items in a collection which will be printed,
+                    or no limit if bound to a logical falsey value (default: 50)
+    - print_level: the depth of the object graph to print, starting with 0, or
+                   no limit if bound to a logical falsey value (default: nil)
+    - print_meta: if logical true, print objects meta in a way that can be
+                  read back by the reader (default: false)
+    - print_readably: if logical false, print strings and characters with
+                      non-alphanumeric characters converted to escape sequences
+                      (default: true)
+
+    Note that this function is not capable of capturing the values bound at
+    runtime to the basilisp.core dynamic variables which correspond to each
+    of the keyword arguments to this function. To use a version of lrepr
+    which does capture those values, call basilisp.lang.runtime.lrepr directly."""
+    kwargs = pmap(
+        {
+            "human_readable": human_readable,
+            "print_dup": print_dup,
+            "print_length": print_length,
+            "print_level": print_level,
+            "print_meta": print_meta,
+            "print_readably": print_readably,
+        }
+    )
+    if isinstance(o, LispObject):
+        return o._lrepr(**kwargs)
+    elif o is True:
+        return "true"
+    elif o is False:
+        return "false"
+    elif o is None:
+        return "nil"
+    elif isinstance(o, str):
+        if human_readable:
+            return o
+        if print_readably is None or print_readably is False:
+            return f'"{o}"'
+        return f'"{o.encode("unicode_escape").decode("utf-8")}"'
+    elif isinstance(o, complex):
+        return repr(o).upper()
+    elif isinstance(o, datetime.datetime):
+        inst_str = o.isoformat()
+        return f'#inst "{inst_str}"'
+    elif isinstance(o, Decimal):
+        if print_dup:
+            return f"{str(o)}M"
+        return str(o)
+    elif isinstance(o, Fraction):
+        return f"{o.numerator}/{o.denominator}"
+    elif isinstance(o, Pattern):
+        return f'#"{o.pattern}"'
+    elif isinstance(o, uuid.UUID):
+        uuid_str = str(o)
+        return f'#uuid "{uuid_str}"'
+    else:
+        return repr(o)