First stab at extra clarification in "round trip" section

Author: davepeck

peps/pep-0750.rst

@@ -1288,27 +1288,49 @@ Enable Full Reconstruction of Original Template Literal
 
 Earlier versions of this PEP attempted to make it possible to fully reconstruct
 the text of the original template string from a ``Template`` instance. This was
-rejected as being overly complex.
+rejected as being overly complex. The mapping between template literal source 
+and the underlying AST is not one-to-one and there are several limitations with 
+respect to round-tripping to the original source text.
 
-There are several limitations with respect to round-tripping to the original
-source text:
+First, ``Interpolation.format_spec`` defaults to ``""`` if not provided:
 
-- ``Interpolation.format_spec`` defaults to ``""`` if not provided. It is therefore
-  impossible to distinguish ``t"{expression}"`` from ``t"{expression:}"``.
-- The debug specifier, ``=``, is treated as a special case. It is therefore not
-  possible to distinguish ``t"{expression=}"`` from 
-  ``t"expression={expression}"``.
-- Finally, format specifiers in f-strings allow arbitrary nesting. In this PEP
-  and in the reference implementation, the specifier is eagerly evaluated
-  to set the ``format_spec`` in the ``Interpolation``, thereby losing
-  the original expressions. For example:
+.. code-block:: python
+
+    value = 42
+    template1 = t"{value}"
+    template2 = t"{value:}"
+    assert template1.interpolations[0].format_spec == ""
+    assert template2.interpolations[0].format_spec == ""
+
+Next, the debug specifier, ``=``, is treated as a special case and is processed
+before the AST is created. It is therefore not possible to distinguish 
+``t"{expression=}"`` from ``t"expression={expression!r}"``:
+
+.. code-block:: python
+
+    value = 42
+    template1 = t"{value=}"
+    template2 = t"value={value!r}"
+    assert template1.strings[0] == "value="
+    assert template1.interpolations[0].expression == "value"
+    assert template1.interpolations[0].conversion == "r"
+    assert template2.strings[0] == "value="
+    assert template2.interpolations[0].expression == "value"
+    assert template2.interpolations[0].conversion == "r"
+
+Finally, format specifiers in f-strings allow arbitrary nesting. In this PEP 
+and in the reference implementation, the specifier is eagerly evaluated to 
+set the ``format_spec`` in the ``Interpolation``, thereby losing the original 
+expressions. For example:
 
 .. code-block:: python
 
     value = 42
     precision = 2
-    template = t"Value: {value:.{precision}f}"
-    assert template.interpolations[0].format_spec == ".2f"
+    template1 = t"{value:.2f}"
+    template2 = t"{value:.{precision}f}"
+    assert template1.interpolations[0].format_spec == ".2f"
+    assert template2.interpolations[0].format_spec == ".2f"
 
 We do not anticipate that these limitations will be a significant issue in practice.
 Developers who need to obtain the original template string literal can always