Apply suggestions from code review

Co-authored-by: Hugo van Kemenade <[email protected]>

Author: methane

peps/pep-0822.rst

@@ -32,7 +32,7 @@ Example (spaces are visualized as ``_``):
     ____"""
 
 The closing triple quotes control how much indentation would be removed.
-In the above example, the returned string will contain three lines
+In the above example, the returned string will contain three lines:
 
 * ``"____<p>\n"`` (four leading spaces)
 * ``"______Hello, World!\n"`` (six leading spaces)
@@ -54,7 +54,7 @@ All of these options have drawbacks in terms of code readability and maintainabi
 * Left-aligned multiline strings look awkward and tend to be avoided.
   In practice, many places including Python's own test code choose other methods.
 * Concatenated single-line string literals are more verbose and harder to maintain.
-* ``textwrap.dedent()`` is implemented in Python so it require some runtime overhead.
+* ``textwrap.dedent()`` is implemented in Python so it requires some runtime overhead.
   It cannot be used in hot paths where performance is critical.
 
 This PEP aims to provide a built-in syntax for dedented multiline strings that
@@ -80,7 +80,7 @@ However, this approach has several drawbacks:
   they cannot be dedented.
 * f-strings may interpolate expressions as multiline string without indent.
   In such case, f-string + ``str.dedent()`` cannot dedent the whole string.
-* t-strings do not create str objects, so they cannot use the ``str.dedent()`` method.
+* t-strings do not create ``str`` objects, so they cannot use the ``str.dedent()`` method.
   While adding a ``dedent()`` method to ``string.templatelib.Template`` is an option,
   it would lead to inconsistency since t-strings and f-strings are very similar but
   would have different behaviors regarding dedentation.
@@ -106,10 +106,10 @@ This newline is not included in the resulting string.
 
 The amount of indentation to be removed is determined by the whitespace
 (``' '`` or ``'\t'``) preceding the closing triple quotes.
-Mixing spaces and tabs in indentation raises a TabError, similar to Python's
+Mixing spaces and tabs in indentation raises a ``TabError``, similar to Python's
 own indentation rules.
 
-The dedentation process removes the determined amount of leading whitespace from each line in the string.
+The dedentation process removes the determined amount of leading whitespace from every line in the string.
 Lines that are shorter than the determined indentation become just an empty line (e.g. ``"\n"``).
 Otherwise, if the line does not start with the determined indentation,
 Python raises an ``IndentationError``.
@@ -122,7 +122,7 @@ Examples:
 
 .. code-block:: python
 
-    # whiltespace is shown as _ and TAB is shown as ---> for clarity.
+    # Whitespace is shown as _ and tab is shown as ---> for clarity.
     # Error messages are just for explanation. Actual messages may differ.
 
     s = d""  # SyntaxError: d-string must be a multiline string
@@ -166,7 +166,7 @@ Examples:
     s = d"""
     --->--->__Hello
     --->--->__World!
-    --->--->"""  # TAB is allowed as indentation.
+    --->--->"""  # Tab is allowed as indentation.
                  # Spaces are just in the string, not indentation to be removed.
     print(repr(s))  # '__Hello\n__World!\n'
 
@@ -217,10 +217,10 @@ providing a link to the d-string section in the language reference or the releva
 Other Languages having Similar Features
 ========================================
 
-Java 15 introduced a feature called `Text Blocks <https://openjdk.org/jeps/378>`__.
+Java 15 introduced a feature called `text blocks <https://openjdk.org/jeps/378>`__.
 Since Java had not used triple qutes before, they introduced triple quotes for multiline string literals with automatic indent removal.
 
-C# 11 also introduced a similar feature called `Raw String Literals <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-11.0/raw-string-literal>`__.
+C# 11 also introduced a similar feature called `raw string literals <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-11.0/raw-string-literal>`__.
 
 `Julia <https://docs.julialang.org/en/v1/manual/strings/#Triple-Quoted-String-Literals>`__ and
 `Swift <https://docs.swift.org/swift-book/documentation/the-swift-programming-language/stringsandcharacters/#Multiline-String-Literals>`__
@@ -233,7 +233,7 @@ it removes indent from text too.
 Java and Julia uses the least-indented line to determine the amount of indentation to be removed.
 Swift, C#, and PHP uses the indentation of the closing triple quotes or closing marker.
 
-This PEP chose the Swift and C# approach because it is more simple and easy to explain.
+This PEP chose the Swift and C# approach because it is simpler and easier to explain.
 
 
 Reference Implementation
@@ -247,7 +247,7 @@ Rejected Ideas
 ==============
 
 ``str.dedent()`` method
-------------------------
+-----------------------
 
 As mentioned in the Rationale section, this PEP doesn't reject the idea of a ``str.dedent()`` method.
 A faster version of ``textwrap.dedent()`` implemented in C would be useful for runtime dedentation.
@@ -259,8 +259,8 @@ However, d-string is more suitable for multiline string literals because:
 * It can dedent continuation lines.
 
 
-triple-backquote
------------------
+Triple-backtick
+---------------
 
 It is considered that `using triple backquotes <https://discuss.python.org/t/40679>`__
 for dedented multiline strings could be an alternative syntax.
@@ -274,6 +274,7 @@ characters is not seen as a superior idea compared to adding a prefix to string
 
 ``__future__`` import
 ---------------------
+
 Instead of adding a prefix to string literals, the idea of using a ``__future__``
 import to change the default behavior of multiline string literals was also considered.
 This could help simplify Python's grammar in the future.