Proposed update: restrict support for Template + str addition.

Author: davepeck

peps/pep-0750.rst

@@ -419,13 +419,14 @@ constructing a ``Template`` instance:
     # Treat `name` as an interpolation
     template = t"Hello " + Template(Interpolation(name, "name"))
 
-Python's implicit concatenation syntax is also supported, both between two
-``Template`` instances and between a ``Template`` instance and a ``str``:
+Python's implicit concatenation syntax is supported between any combination
+of ``Template`` and ``str``:
 
 .. code-block:: python
 
     name = "World"
     assert (t"Hello " t"World").strings == ("Hello World",)
+    assert (t"Hello " "World").stings == ("Hello World",)
     assert ("Hello " t"World").strings == ("Hello World",)
 
 
@@ -1355,7 +1356,8 @@ Disallowing Template Concatenation
 ----------------------------------
 
 Earlier versions of this PEP proposed that ``Template`` instances should not
-support concatenation. This was rejected in favor of allowing concatenation.
+support concatenation. This was rejected in favor of allowing concatenating
+multiple ``Template`` instances.
 
 There are reasonable arguments in favor of rejecting one or all forms of
 concatenation: namely, that it cuts off a class of potential bugs, particularly
@@ -1369,14 +1371,16 @@ return a type that supported concatenation.
 
 In the end, we decided that the surprise to developers of a new string type
 *not* supporting concatenation was likely to be greater than the theoretical
-harm caused by supporting it. (Developers concatenate f-strings all the time,
-after all, and while we are sure there are cases where this introduces bugs,
-it's not clear that those bugs outweigh the benefits of supporting concatenation.)
+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. We expect that
-code that uses template strings will more commonly build up larger templates
-through nesting and composition rather than 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.
+
+We expect that code that uses template strings will more commonly build up
+larger templates through nesting and composition rather than concatenation.
 
 
 Arbitrary Conversion Values