Remove possible confusion in debug spec examples by using foo.

Author: davepeck

peps/pep-0750.rst

@@ -454,7 +454,7 @@ The debug specifier, ``=``, is supported in template strings and behaves similar
 to how it behaves in f-strings, though due to limitations of the implementation
 there is a slight difference.
 
-In particular, ``t'{expression=}'`` is treated as ``t'expression={expression!r}'``:
+In particular, ``t'{foo=}'`` is treated as ``t'foo={foo!r}'``:
 
 .. code-block:: python
 
@@ -464,11 +464,11 @@ In particular, ``t'{expression=}'`` is treated as ``t'expression={expression!r}'
     assert template.interpolations[0].value == "World"
     assert template.interpolations[0].conversion == "r"
 
-If a separate format string is also provided, ``t'{expression=:fmt}`` is treated
-instead as ``t'expression={expression!s:fmt}'``.
+If a separate format string is also provided, ``t'{foo=:fmt}`` is treated
+instead as ``t'foo={foo!s:fmt}'``.
 
-Whitespace is preserved in the debug specifier, so ``t'{expression = }'`` is
-treated as ``t'expression = {expression!r}'``.
+Whitespace is preserved in the debug specifier, so ``t'{foo = }'`` is
+treated as ``t'foo = {foo!r}'``.
 
 
 Raw Template Strings
@@ -1304,18 +1304,18 @@ First, ``Interpolation.format_spec`` defaults to ``""`` if not provided:
 
 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}"``:
+``t"{foo=}"`` from ``t"foo={foo!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"
+    foo = 42
+    template1 = t"{foo=}"
+    template2 = t"foo={foo!r}"
+    assert template1.strings[0] == "foo="
+    assert template1.interpolations[0].expression == "foo"
     assert template1.interpolations[0].conversion == "r"
-    assert template2.strings[0] == "value="
-    assert template2.interpolations[0].expression == "value"
+    assert template2.strings[0] == "foo="
+    assert template2.interpolations[0].expression == "foo"
     assert template2.interpolations[0].conversion == "r"
 
 Finally, format specifiers in f-strings allow arbitrary nesting. In this PEP