Homoiconic REPL

NEWS

@@ -22,6 +22,10 @@ Changes from 0.12.1
      returns.
    * `setv` no longer unnecessarily tries to get attributes
 
+   [ Misc. Improvements ]
+   * New contrib module `hy-repr`
+   * Added a command-line option --hy-repr
+
 Changes from 0.12.0
 
    [ Bug Fixes ]

docs/contrib/hy_repr.rst

@@ -0,0 +1,48 @@
+==================
+Hy representations
+==================
+
+.. versionadded:: 0.13.0
+
+``hy.contrib.hy-repr`` is a module containing a single function.
+To import it, say::
+
+  (import [hy.contrib.hy-repr [hy-repr]])
+
+To make the Hy REPL use it for output, invoke Hy like so::
+
+  $ hy --repl-output-fn=hy.contrib.hy-repr.hy-repr
+
+.. _hy-repr-fn:
+
+hy-repr
+-------
+
+Usage: ``(hy-repr x)``
+
+This function is Hy's equivalent of Python's built-in ``repr``.
+It returns a string representing the input object in Hy syntax.
+
+.. code-block:: hy
+
+   => (hy-repr [1 2 3])
+   '[1 2 3]'
+   => (repr [1 2 3])
+   '[1, 2, 3]'
+
+If the input object has a method ``__hy-repr__``, it will be called
+instead of doing anything else.
+
+.. code-block:: hy
+
+  => (defclass C [list] [__hy-repr__ (fn [self] "cuddles")])
+  => (hy-repr (C))
+  'cuddles'
+
+When ``hy-repr`` doesn't know how to handle its input, it falls back
+on ``repr``.
+
+Like ``repr`` in Python, ``hy-repr`` can round-trip many kinds of
+values. Round-tripping implies that given an object ``x``,
+``(eval (read-str (hy-repr x)))`` returns ``x``, or at least a value
+that's equal to ``x``.

docs/contrib/index.rst

@@ -16,3 +16,4 @@ Contents:
    profile
    sequences
    walk
+   hy_repr

docs/tutorial.rst

@@ -193,7 +193,6 @@ Hy.  Let's experiment with this in the hy interpreter::
   [1, 2, 3]
   => {"dog" "bark"
   ... "cat" "meow"}
-  ...
   {'dog': 'bark', 'cat': 'meow'}
   => (, 1 2 3)
   (1, 2, 3)
@@ -204,6 +203,20 @@ Hy.  Let's experiment with this in the hy interpreter::
 
 Notice the last two lines: Hy has a fraction literal like Clojure.
 
+If you start Hy like this (a shell alias might be helpful)::
+
+  $ hy --repl-output-fn=hy.contrib.hy-repr.hy-repr
+
+the interactive mode will use :ref:`_hy-repr-fn` instead of Python's
+native ``repr`` function to print out values, so you'll see values in
+Hy syntax rather than Python syntax::
+
+  => [1 2 3]
+  [1 2 3]
+  => {"dog" "bark"
+  ... "cat" "meow"}
+  {"dog" "bark" "cat" "meow"}
+
 If you are familiar with other Lisps, you may be interested that Hy
 supports the Common Lisp method of quoting:
 

hy/cmdline.py

@@ -32,14 +32,16 @@
 import ast
 import sys
 import os
+import importlib
 
 import astor.codegen
 
 import hy
 
 from hy.lex import LexException, PrematureEndOfInput, tokenize
-from hy.compiler import hy_compile, HyTypeError
-from hy.importer import (ast_compile, import_buffer_to_module,
+from hy.lex.parser import hy_symbol_mangle
+from hy.compiler import HyTypeError
+from hy.importer import (hy_eval, import_buffer_to_module,
                          import_file_to_ast, import_file_to_hst,
                          import_buffer_to_ast, import_buffer_to_hst)
 from hy.completer import completion
@@ -73,25 +75,37 @@ def __call__(self, code=None):
 builtins.exit = HyQuitter('exit')
 
 
-def print_python_code(_ast):
-    # astor cannot handle ast.Interactive, so disguise it as a module
-    _ast_for_print = ast.Module()
-    _ast_for_print.body = _ast.body
-    print(astor.codegen.to_source(_ast_for_print))
-
-
 class HyREPL(code.InteractiveConsole):
-    def __init__(self, spy=False, locals=None, filename="<input>"):
+    def __init__(self, spy=False, output_fn=None, locals=None,
+                 filename="<input>"):
+
         self.spy = spy
+
+        if output_fn is None:
+            self.output_fn = repr
+        elif callable(output_fn):
+            self.output_fn = output_fn
+        else:
+            f = hy_symbol_mangle(output_fn)
+            if "." in output_fn:
+                module, f = f.rsplit(".", 1)
+                self.output_fn = getattr(importlib.import_module(module), f)
+            else:
+                self.output_fn = __builtins__[f]
+
         code.InteractiveConsole.__init__(self, locals=locals,
                                          filename=filename)
 
     def runsource(self, source, filename='<input>', symbol='single'):
         global SIMPLE_TRACEBACKS
         try:
-            tokens = tokenize(source)
-        except PrematureEndOfInput:
-            return True
+            try:
+                tokens = tokenize(source)
+            except PrematureEndOfInput:
+                return True
+            do = HyExpression([HySymbol('do')] + tokens)
+            do.start_line = do.end_line = do.start_column = do.end_column = 1
+            do.replace(do)
         except LexException as e:
             if e.source is None:
                 e.source = source
@@ -100,10 +114,15 @@ def runsource(self, source, filename='<input>', symbol='single'):
             return False
 
         try:
-            _ast = hy_compile(tokens, "__console__", root=ast.Interactive)
-            if self.spy:
-                print_python_code(_ast)
-            code = ast_compile(_ast, filename, symbol)
+            def ast_callback(main_ast, expr_ast):
+                if self.spy:
+                    # Mush the two AST chunks into a single module for
+                    # conversion into Python.
+                    new_ast = ast.Module(main_ast.body +
+                                         [ast.Expr(expr_ast.body)])
+                    print(astor.to_source(new_ast))
+            value = hy_eval(do, self.locals, "__console__",
+                            ast_callback)
         except HyTypeError as e:
             if e.source is None:
                 e.source = source
@@ -117,7 +136,12 @@ def runsource(self, source, filename='<input>', symbol='single'):
             self.showtraceback()
             return False
 
-        self.runcode(code)
+        if value is not None:
+            # Make the last non-None value available to
+            # the user as `_`.
+            self.locals['_'] = value
+            # Print the value.
+            print(self.output_fn(value))
         return False
 
 
@@ -211,7 +235,7 @@ def run_file(filename):
     return 0
 
 
-def run_repl(hr=None, spy=False):
+def run_repl(hr=None, **kwargs):
     import platform
     sys.ps1 = "=> "
     sys.ps2 = "... "
@@ -221,7 +245,7 @@ def run_repl(hr=None, spy=False):
     with completion(Completer(namespace)):
 
         if not hr:
-            hr = HyREPL(spy, namespace)
+            hr = HyREPL(locals=namespace, **kwargs)
 
         hr.interact("{appname} {version} using "
                     "{py}({build}) {pyversion} on {os}".format(
@@ -236,8 +260,8 @@ def run_repl(hr=None, spy=False):
     return 0
 
 
-def run_icommand(source, spy=False):
-    hr = HyREPL(spy)
+def run_icommand(source, **kwargs):
+    hr = HyREPL(**kwargs)
     if os.path.exists(source):
         with open(source, "r") as f:
             source = f.read()
@@ -272,7 +296,9 @@ def cmdline_handler(scriptname, argv):
         help="program passed in as a string, then stay in REPL")
     parser.add_argument("--spy", action="store_true",
                         help="print equivalent Python code before executing")
-
+    parser.add_argument("--repl-output-fn",
+                        help="function for printing REPL output "
+                             "(e.g., hy.contrib.hy-repr.hy-repr)")
     parser.add_argument("-v", "--version", action="version", version=VERSION)
 
     parser.add_argument("--show-tracebacks", action="store_true",
@@ -315,7 +341,8 @@ def cmdline_handler(scriptname, argv):
 
     if options.icommand:
         # User did "hy -i ..."
-        return run_icommand(options.icommand, spy=options.spy)
+        return run_icommand(options.icommand, spy=options.spy,
+                            output_fn=options.repl_output_fn)
 
     if options.args:
         if options.args[0] == "-":
@@ -332,7 +359,7 @@ def cmdline_handler(scriptname, argv):
                 sys.exit(e.errno)
 
     # User did NOTHING!
-    return run_repl(spy=options.spy)
+    return run_repl(spy=options.spy, output_fn=options.repl_output_fn)
 
 
 # entry point for cmd line script "hy"

hy/contrib/hy_repr.hy

@@ -0,0 +1,77 @@
+(import [hy._compat [PY3 str-type bytes-type long-type]])
+(import [hy.models [HyObject HyExpression HySymbol HyKeyword HyInteger HyList HyDict HySet HyString HyBytes]])
+
+(defn hy-repr [obj]
+  (setv seen (set))
+    ; We keep track of objects we've already seen, and avoid
+    ; redisplaying their contents, so a self-referential object
+    ; doesn't send us into an infinite loop.
+  (defn f [x q]
+    ; `x` is the current object being stringified.
+    ; `q` is True if we're inside a single quote, False otherwise.
+    (setv old? (in (id x) seen))
+    (.add seen (id x))
+    (setv t (type x))
+    (defn catted []
+      (if old? "..." (.join " " (list-comp (f it q) [it x]))))
+    (setv prefix "")
+    (if (and (not q) (instance? HyObject x))
+      (setv prefix "'"  q True))
+    (+ prefix (if
+      (hasattr x "__hy_repr__")
+        (.__hy-repr__ x)
+      (is t HyExpression)
+        (if (and x (symbol? (first x)))
+          (if
+            (= (first x) 'quote)
+              (+ "'" (f (second x) True))
+            (= (first x) 'quasiquote)
+              (+ "`" (f (second x) q))
+            (= (first x) 'unquote)
+              (+ "~" (f (second x) q))
+            (= (first x) 'unquote_splice)
+              (+ "~@" (f (second x) q))
+            ; else
+              (+ "(" (catted) ")"))
+          (+ "(" (catted) ")"))
+      (is t tuple)
+        (+ "(," (if x " " "") (catted) ")")
+      (in t [list HyList])
+        (+ "[" (catted) "]")
+      (is t HyDict)
+        (+ "{" (catted) "}")
+      (is t dict)
+        (+
+          "{"
+          (if old? "..." (.join " " (list-comp
+            (+ (f k q) " " (f v q))
+            [[k v] (.items x)])))
+          "}")
+      (in t [set HySet])
+        (+ "#{" (catted) "}")
+      (is t frozenset)
+        (+ "(frozenset #{" (catted) "})")
+      (is t HySymbol)
+        x
+      (or (is t HyKeyword) (and (is t str-type) (.startswith x HyKeyword.PREFIX)))
+        (cut x 1)
+      (in t [str-type HyString bytes-type HyBytes]) (do
+        (setv r (.lstrip (repr x) "ub"))
+        (+ (if (in t [bytes-type HyBytes]) "b" "") (if (.startswith "\"" r)
+          ; If Python's built-in repr produced a double-quoted string, use
+          ; that.
+          r
+          ; Otherwise, we have a single-quoted string, which isn't valid Hy, so
+          ; convert it.
+          (+ "\"" (.replace (cut r 1 -1) "\"" "\\\"") "\""))))
+      (and (not PY3) (is t int))
+        (.format "(int {})" (repr x))
+      (and (not PY3) (in t [long_type HyInteger]))
+        (.rstrip (repr x) "L")
+      (is t complex)
+        (.strip (repr x) "()")
+      (is t fraction)
+        (.format "{}/{}" (f x.numerator q) (f x.denominator q))
+      ; else
+        (repr x))))
+  (f obj False))

hy/importer.py

@@ -111,7 +111,7 @@ def import_buffer_to_module(module_name, buf):
     return mod
 
 
-def hy_eval(hytree, namespace, module_name):
+def hy_eval(hytree, namespace, module_name, ast_callback=None):
     foo = HyObject()
     foo.start_line = 0
     foo.end_line = 0
@@ -133,6 +133,9 @@ def hy_eval(hytree, namespace, module_name):
         node.lineno = 1
         node.col_offset = 1
 
+    if ast_callback:
+        ast_callback(_ast, expr)
+
     if not isinstance(namespace, dict):
         raise HyTypeError(foo, "Globals must be a dictionary")
 

tests/__init__.py

@@ -19,6 +19,7 @@
 from .native_tests.contrib.walk import *  # noqa
 from .native_tests.contrib.multi import *  # noqa
 from .native_tests.contrib.sequences import *  # noqa
+from .native_tests.contrib.hy_repr import *  # noqa
 
 if PY3:
     from .native_tests.py3_only_tests import *  # noqa