Update PEP to conform to python/steering-council#289

Author: davepeck

peps/pep-0750.rst

@@ -404,30 +404,34 @@ supported for two ``Template`` instances via ``Template.__add__()``:
     assert (t"Hello " + t"{name}").strings == ("Hello ", "")
     assert (t"Hello " + t"{name}").values[0] == "World"
 
-Concatenation of a ``Template`` and a ``str`` is not supported. This is because
-it is ambiguous whether the ``str`` should be treated as a static string part
-or as an interpolation. Developers can effectively mark a ``str`` by directly
-constructing a ``Template`` instance:
+Implicit concatenation of two template string literals is also supported:
 
 .. code-block:: python
 
     name = "World"
+    assert isinstance(t"Hello " t"{name}", Template)
+    assert (t"Hello " t"{name}").strings == ("Hello ", "")
+    assert (t"Hello " t"{name}").values[0] == "World"
 
-    # Treat `name` as a static string part
-    template = t"Hello " + Template(name)
-
-    # Treat `name` as an interpolation
-    template = t"Hello " + Template(Interpolation(name, "name"))
+Both implicit and explicit concatenation between ``Template`` and ``str`` is
+prohibited. This is because it is ambiguous whether the ``str`` should be
+treated as a static string part or as an interpolation.
 
-Python's implicit concatenation syntax is supported between any combination
-of ``Template`` and ``str``:
+To combine a ``Template`` and a ``str``, developers must explicitly decide how
+to treat the ``str``. If the ``str`` is intended to be a static string part,
+it should be wrapped in a ``Template``. If the ``str`` is intended to be an
+interpolation value, it should be wrapped in an ``Interpolation`` and
+passed to the ``Template`` constructor. For example:
 
 .. code-block:: python
 
     name = "World"
-    assert (t"Hello " t"World").strings == ("Hello World",)
-    assert (t"Hello " "World").strings == ("Hello World",)
-    assert ("Hello " t"World").strings == ("Hello World",)
+
+    # Treat `name` as a static string part
+    template = t"Hello " + Template(name)
+
+    # Treat `name` as an interpolation
+    template = t"Hello " + Template(Interpolation(name, "name"))
 
 
 Template and Interpolation Equality
@@ -1374,10 +1378,10 @@ In the end, we decided that the surprise to developers of a new string type
 harm caused by supporting it.
 
 While concatenation of two ``Templates`` is supported by this PEP, concatenation
-via ``+`` of a ``Template`` and a ``str`` is not supported. This is because it
-is ambiguous whether  ``str`` should be treated as a static string or an
-interpolation. Developers must wrap the ``str`` in a ``Template`` instance before
-concatenating it with another ``Template``, as described above.
+of a ``Template`` and a ``str`` is not supported. This is because it is
+ambiguous whether  ``str`` should be treated as a static string or an
+interpolation. Developers must wrap the ``str`` in a ``Template`` instance
+before concatenating it with another ``Template``, as described above.
 
 We expect that code that uses template strings will more commonly build up
 larger templates through nesting and composition rather than concatenation.