Fix repr and hy-repr for f-strings

NEWS.rst

@@ -42,6 +42,7 @@ Bug Fixes
 ------------------------------
 * REPL now properly displays SyntaxErrors.
 * Fixed a bug in `pprint` in which `width` was ignored.
+* Corrected `repr` and `hy-repr` for f-strings.
 
 .. _Toolz: https://toolz.readthedocs.io
 .. _CyToolz: https://github.com/pytoolz/cytoolz

docs/language/syntax.rst

@@ -78,8 +78,7 @@ format strings
 A format string (or "f-string", or "formatted string literal") is a string
 literal with embedded code, possibly accompanied by formatting commands. Hy
 f-strings work much like :ref:`Python f-strings <py:f-strings>` except that the
-embedded code is in Hy rather than Python, and they're supported on all
-versions of Python.
+embedded code is in Hy rather than Python.
 
 ::
 

hy/contrib/hy_repr.hy

@@ -167,6 +167,30 @@ To make the Hy REPL use it for output, invoke Hy like so::
 (hy-repr-register Fraction (fn [x]
   (.format "{}/{}" (hy-repr x.numerator) (hy-repr x.denominator))))
 
+(hy-repr-register
+  hy.models.FComponent
+  (fn [x] (+
+    "{"
+    (hy-repr (get x 0))
+    (if x.conversion f" !{x.conversion}" "")
+    (if (> (len x) 1)
+      (+ " :" (if (isinstance (get x 1) hy.models.String)
+        (get x 1)
+        (hy-repr (get x 1))))
+      "")
+    "}")))
+
+(hy-repr-register
+  hy.models.FString
+  (fn [fstring]
+    (+ "f\""
+       #* (lfor component fstring
+                :setv s (hy-repr component)
+                (if (isinstance component hy.models.String)
+                    (-> s (cut 1 -1) (.replace "{" "{{") (.replace "}" "}}"))
+                    s))
+       "\"")))
+
 (setv _matchobject-type (type (re.match "" "")))
 (hy-repr-register _matchobject-type (fn [x]
   (.format "<{}.{} object; :span {} :match {}>"

hy/models.py

@@ -8,6 +8,9 @@
 from hy import _initialize_env_var
 from hy.errors import HyWrapperError
 from fractions import Fraction
+import operator
+from itertools import groupby
+from functools import reduce
 from colorama import Fore
 
 PRETTY = True
@@ -339,13 +342,25 @@ def replace(self, other, recursive=True):
             self.conversion = other.conversion
         return self
 
+    def __repr__(self):
+        return 'hy.models.FComponent({})'.format(
+            super(Object, self).__repr__() +
+            ', conversion=' + repr(self.conversion))
+
 class FString(Sequence):
     """
     Generic Hy F-String object, for smarter f-string handling.
     Mimics ast.JoinedStr, but using String and FComponent.
     """
     def __new__(cls, s=None, brackets=None):
-        value = super().__new__(cls, s)
+        value = super().__new__(cls,
+          # Join adjacent string nodes for the sake of equality
+          # testing.
+              (node
+                  for is_string, components in groupby(s,
+                      lambda x: isinstance(x, String))
+                  for node in ([reduce(operator.add, components)]
+                      if is_string else components)))
         value.brackets = brackets
         return value
 

tests/native_tests/contrib/hy_repr.hy

@@ -30,7 +30,14 @@
     '[1 2 3] '(, 1 2 3) '#{1 2 3} '(frozenset #{1 2 3})
     {"a" 1  "b" 2  "a" 3} '{"a" 1  "b" 2  "a" 3}
     [1 [2 3] (, 4 (, 'mysymbol :mykeyword)) {"a" b"hello"} '(f #* a #** b)]
-    '[1 [2 3] (, 4 (, mysymbol :mykeyword)) {"a" b"hello"} (f #* a #** b)]])
+    '[1 [2 3] (, 4 (, mysymbol :mykeyword)) {"a" b"hello"} (f #* a #** b)]
+    'f"a{:a}"
+    'f"a{{{{(+ 1 1)}}}}"
+    'f"the answer is {(+ 2 2)}"
+    'f"the answer is {(+ 2 2) !r :4}"
+    'f"the answer is {(+ 2 2) = }"
+    'f"the answer is {(+ 2 2) = !r :4}"
+    'f"the answer is {(+ 2 2):{(+ 2 3)}}"])
   (for [original-val values]
     (setv evaled (hy.eval (read-str (hy-repr original-val))))
     (assert (= evaled original-val))

tests/native_tests/language.hy

@@ -1226,6 +1226,7 @@
   (assert (= f"hello world" "hello world"))
   (assert (= f"hello {(+ 1 1)} world" "hello 2 world"))
   (assert (= f"a{ (.upper (+ \"g\" \"k\")) }z" "aGKz"))
+  (assert (= f"a{1}{2}b" "a12b"))
 
   ; Referring to a variable
   (setv p "xyzzy")
@@ -1319,6 +1320,19 @@ cee\"} dee" "ey bee\ncee dee"))
     f"{pi =:{fill =}^{width =}.2f}"))
 
 
+(defn test-format-string-repr-roundtrip []
+  (for [orig [
+       'f"hello {(+ 1 1)} world"
+       'f"a{p !r:9}"
+       'f"{ foo = !s}"]]
+    (setv new (eval (repr orig)))
+    (assert (= (len new) (len orig)))
+    (for [[n o] (zip new orig)]
+      (when (hasattr o "conversion")
+        (assert (= n.conversion o.conversion)))
+      (assert (= n o)))))
+
+
 (defn test-import-syntax []
   "NATIVE: test the import syntax."
 

tests/native_tests/mangling.hy

@@ -193,14 +193,13 @@
   (assert (= (mangle "\r") "hyx_XUdX"))
   (assert (= (mangle "\r") "hyx_XUdX"))
 
-  (setv c (try unichr (except [NameError] chr)))
-  (assert (= (mangle (c 127)) "hyx_XU7fX"))
-  (assert (= (mangle (c 128)) "hyx_XU80X"))
-  (assert (= (mangle (c 0xa0)) "hyx_XnoHbreak_spaceX"))
-  (assert (= (mangle (c 0x378)) "hyx_XU378X"))
-  (assert (= (mangle (c 0x200a) "hyx_Xhair_spaceX")))
-  (assert (= (mangle (c 0x2065)) "hyx_XU2065X"))
-  (assert (= (mangle (c 0x1000c)) "hyx_XU1000cX")))
+  (assert (= (mangle (chr 127)) "hyx_XU7fX"))
+  (assert (= (mangle (chr 128)) "hyx_XU80X"))
+  (assert (= (mangle (chr 0xa0)) "hyx_XnoHbreak_spaceX"))
+  (assert (= (mangle (chr 0x378)) "hyx_XU378X"))
+  (assert (= (mangle (chr 0x200a) "hyx_Xhair_spaceX")))
+  (assert (= (mangle (chr 0x2065)) "hyx_XU2065X"))
+  (assert (= (mangle (chr 0x1000c)) "hyx_XU1000cX")))
 
 
 (defn test-mangle-bad-indent []