Take care of @hugovk's suggestions.

Author: davepeck

Doc/glossary.rst

@@ -462,7 +462,7 @@ Glossary
       core and with user code.
 
    f-string
-      String literals prefixed with ``'f'`` or ``'F'`` are commonly called
+      String literals prefixed with ``f`` or ``F`` are commonly called
       "f-strings" which is short for
       :ref:`formatted string literals <f-strings>`.  See also :pep:`498`.
 
@@ -1318,7 +1318,7 @@ Glossary
       See also :term:`borrowed reference`.
 
    t-string
-      String literals prefixed with ``'t'`` or ``'T'`` are commonly called
+      String literals prefixed with ``t`` or ``T`` are commonly called
       "t-strings" which is short for
       :ref:`template string literals <t-strings>`.
 

Doc/library/ast.rst

@@ -291,7 +291,7 @@ Literals
      * -1: no formatting
      * 115: ``!s`` string formatting
      * 114: ``!r`` repr formatting
-     * 97: ``!a`` ascii formatting
+     * 97: ``!a`` ASCII formatting
 
    * ``format_spec`` is a :class:`JoinedStr` node representing the formatting
      of the value, or ``None`` if no format was specified. Both

Doc/library/dis.rst

@@ -1147,7 +1147,7 @@ iterations of the loop.
 
    If ``format >> 2`` is non-zero, it indicates that the interpolation
    contains a conversion. The value of ``format >> 2`` is the conversion type
-   (e.g. ``0`` for no conversion, ``1`` for ``!s``, ``2`` for ``!r``, and
+   (``0`` for no conversion, ``1`` for ``!s``, ``2`` for ``!r``, and
    ``3`` for ``!a``)::
 
       conversion = format >> 2

Doc/library/string.rst

@@ -799,7 +799,7 @@ Template strings ($-strings)
 
    The feature described here was introduced in Python 2.4.  It is unrelated
    to, and should not be confused with, the newer
-   :ref:`template strings <template-strings>` feature and
+   :ref:`template strings <template-strings>` and
    :ref:`t-string literal syntax <t-strings>` introduced in Python 3.14.
    T-string literals evaluate to instances of a different
    :class:`~string.templatelib.Template` class, found in the
@@ -983,9 +983,3 @@ Helper functions
    or ``None``, runs of whitespace characters are replaced by a single space
    and leading and trailing whitespace are removed, otherwise *sep* is used to
    split and join the words.
-
-
-
-.. toctree::
-
-   string.templatelib.rst

Doc/library/string.templatelib.rst

@@ -1,4 +1,4 @@
-:mod:`!string.templatelib` --- Templates and Interpolations for t-strings
+:mod:`!string.templatelib` --- Templates and interpolations for t-strings
 =========================================================================
 
 .. module:: string.templatelib
@@ -11,9 +11,9 @@
 
 .. seealso::
 
-   :ref:`T-strings tutorial <tut-t-strings>`
-   :ref:`Format strings <f-strings>`
-   :ref:`T-string literal syntax <t-strings>`
+   * :ref:`T-strings tutorial <tut-t-strings>`
+   * :ref:`Format strings <f-strings>`
+   * :ref:`T-string literal syntax <t-strings>`
 
 
 .. _template-strings:
@@ -109,6 +109,8 @@ reassigned.
 
        >>> t"".strings
        ('',)
+       >>> t"".values
+       ()
        >>> t"{'cheese'}".strings
        ('', '')
        >>> t"{'cheese'}".values
@@ -191,10 +193,10 @@ reassigned.
    :param value: The evaluated, in-scope result of the interpolation.
    :type value: object
 
-   :param expression: The text of a valid Python expression, or an empty string
+   :param expression: The text of a valid Python expression, or an empty string.
    :type expression: str
 
-   :param conversion: The optional :ref:`conversion <formatstrings>` to be used, one of r, s, and a,.
+   :param conversion: The optional :ref:`conversion <formatstrings>` to be used, one of r, s, and a.
    :type conversion: Literal["a", "r", "s"] | None
 
    :param format_spec: An optional, arbitrary string used as the :ref:`format specification <formatspec>` to present the value.
@@ -229,8 +231,8 @@ reassigned.
 
    .. property:: conversion
 
-       :returns: The conversion to apply to the value, or ``None``
-       :rtype: Literal["a", "r", "s"] | None
+       :returns: The conversion to apply to the value, or ``None``.
+       :rtype: ``Literal["a", "r", "s"] | None``
 
        The :attr:`!Interpolation.conversion` is the optional conversion to apply
        to the value:

Doc/library/text.rst

@@ -16,6 +16,7 @@ Python's built-in string type in :ref:`textseq`.
 .. toctree::
 
    string.rst
+   string.templatelib.rst
    re.rst
    difflib.rst
    textwrap.rst

Doc/reference/lexical_analysis.rst

@@ -561,9 +561,9 @@ escapes are not treated specially.
    single: f'; formatted string literal
    single: f"; formatted string literal
 
-A string literal with ``'f'`` or ``'F'`` in its prefix is a
-:dfn:`formatted string literal`; see :ref:`f-strings`.  The ``'f'`` may be
-combined with ``'r'``, but not with ``'b'`` or ``'u'``, therefore raw
+A string literal with ``f`` or ``F`` in its prefix is a
+:dfn:`formatted string literal`; see :ref:`f-strings`.  The ``f`` may be
+combined with ``r``, but not with ``b`` or ``u``, therefore raw
 formatted strings are possible, but formatted bytes literals are not.
 
 In triple-quoted literals, unescaped newlines and quotes are allowed (and are
@@ -756,7 +756,7 @@ f-strings
 .. versionadded:: 3.6
 
 A :dfn:`formatted string literal` or :dfn:`f-string` is a string literal
-that is prefixed with ``'f'`` or ``'F'``.  These strings may contain
+that is prefixed with ``f`` or ``F``.  These strings may contain
 replacement fields, which are expressions delimited by curly braces ``{}``.
 While other string literals always have a constant value, formatted strings
 are really expressions evaluated at run time.
@@ -922,7 +922,7 @@ t-strings
 .. versionadded:: 3.14
 
 A :dfn:`template string literal` or :dfn:`t-string` is a string literal
-that is prefixed with ``'t'`` or ``'T'``.  These strings follow the same
+that is prefixed with ``t`` or ``T``.  These strings follow the same
 syntax and evaluation rules as :ref:`formatted string literals <f-strings>`, with
 the following differences:
 
@@ -950,9 +950,9 @@ the following differences:
   :attr:`~string.templatelib.Template.interpolations` attribute will also
   contain an ``Interpolation`` instance for the expression. By default, the
   :attr:`~string.templatelib.Interpolation.conversion` attribute will be set to
-  ``'r'`` (i.e. :func:`repr`), unless there is a conversion explicitly specified
-  (in which case it overrides the default) or a format specifier is provided (in
-  which case, the ``conversion`` defaults to ``None``).
+  ``'r'`` (that is, :func:`repr`), unless there is a conversion explicitly
+  specified (in which case it overrides the default) or a format specifier is
+  provided (in which case, the ``conversion`` defaults to ``None``).
 
 
 .. _numbers:

Doc/sphinx-warnings.txt

@@ -343,11 +343,11 @@ representation of the HTML:
      ...
      >>> def parse_html(template: Template) -> Element:
      ...     """
-     ...     Uses python's built-in HTMLParser to parse the template,
+     ...     Uses Python's built-in HTMLParser to parse the template,
      ...     handle any interpolated values, and return a tree of
      ...     Element instances.
      ...     """
-     ...     pass
+     ...     ...
      ...
 
 A full implementation of this function would be quite complex and is not