PEP 646: fix nits and typos.

Author: pradeep90

pep-0646.rst

@@ -315,13 +315,6 @@ As of this PEP, only a single type variable tuple may appear in a type parameter
 
     class Array(Generic[*Ts1, *Ts2]): ...  # Error
 
-Only one unpacking may appear in a tuple:
-
-::
-
-    x: Tuple[int, *Ts, str, *Ts2]  # Error
-    y: Tuple[int, *Tuple[int, ...], str, *Tuple[str, ...]]  # Error
-
 Type Concatenation
 ------------------
 
@@ -368,6 +361,15 @@ We mentioned that a ``TypeVarTuple`` simply stands for a tuple of
 types. Thus, we can cleanly replace any use of a ``TypeVarTuple`` in a
 function signature with a tuple type.
 
+
+As with ``TypeVarTuple``, only one unpacking may appear in a tuple:
+
+::
+
+    x: Tuple[int, *Ts, str, *Ts2]  # Error
+    y: Tuple[int, *Tuple[int, ...], str, *Tuple[str, ...]]  # Error
+
+
 Unpacking a Concrete Tuple Type
 '''''''''''''''''''''''''''''''
 
@@ -406,7 +408,7 @@ last element is guaranteed to be of type ``str``, and there may be
 zero or more elements of type ``str`` in between. Note that
 ``Tuple[*Tuple[int, ...]]`` is equivalent to ``Tuple[int, ...]``.
 
-Consider the following functions:
+Consider the following function:
 
 ::
 
@@ -425,7 +427,7 @@ tuple ``Tuple[str, ...]`` and substituted in the return type.
 
 
 Unpacking unbounded tuples is useful in function signatures where we
-don't care about the exact elements and do not want to define an
+don't care about the exact elements and don't want to define an
 unnecessary ``TypeVarTuple``:
 
 ::
@@ -446,23 +448,24 @@ unnecessary ``TypeVarTuple``:
 
 We can also pass a ``Tuple[int, ...]`` wherever a ``Tuple[*Ts]`` is
 expected. This is useful when we have particularly dynamic code and
-cannot infer the precise number of dimensions or the precise types for
+cannot state the precise number of dimensions or the precise types for
 each of the dimensions. In those cases, we can smoothly fall back to
 an unbounded tuple:
 
 ::
 
+    y: Array[*Tuple[Any, ...]] = read_from_file()
+
     def expect_variadic_array(
         x: Array[Batch, *Shape]
     ) -> None: ...
 
+    expect_variadic_array(y)  # OK
+
     def expect_precise_array(
         x: Array[Batch, Height, Width, Channels]
     ) -> None: ...
 
-    y: Array[*Tuple[Any, ...]] = read_from_file()
-
-    expect_variadic_array(y)  # OK
     expect_precise_array(y)  # OK
 
 ``Array[*Tuple[Any, ...]]`` stands for an array with an arbitrary
@@ -473,10 +476,10 @@ is bound to ``Tuple[Any, ...]``. In the call to
 ``Width``, and ``Channels`` are all bound to ``Any``.
 
 This allows users to handle dynamic code gracefully while still
-explicitly marking the code as unsafe (by using ``*Tuple[Any, ...]``).
-Otherwise, users would face noisy errors from the type checker every
-time they tried to use the variable ``y``, which would hinder them
-when migrating a legacy code base to use ``TypeVarTuple``.
+explicitly marking the code as unsafe (by using ``y: Array[*Tuple[Any,
+...]]``).  Otherwise, users would face noisy errors from the type
+checker every time they tried to use the variable ``y``, which would
+hinder them when migrating a legacy code base to use ``TypeVarTuple``.
 
 ``*args`` as a Type Variable Tuple
 ----------------------------------
@@ -508,18 +511,19 @@ or suffixes of the variadic argument list. For example:
 ::
 
     # os.execle takes arguments 'path, arg0, arg1, ..., env'
-    def execle(path: str, *args: *Tuple[*Ts, Mapping[str, str]]) -> None: ...
+    def execle(path: str, *args: *Tuple[*Ts, Env]) -> None: ...
 
 Note this this is different to
 
 ::
 
-    def execle(path: str, *args: *Ts, env: Mapping[str, str]) -> None: ...
+    def execle(path: str, *args: *Ts, env: Env) -> None: ...
 
 as this would make ``env`` a keyword-only argument.
 
-Unpacking an unbounded tuple is equivalent to the PEP 484 behavior of
-``*args: int``, which accepts zero or more values of type ``int``:
+Unpacking an unbounded tuple is equivalent to the PEP 484 behavior
+[#pep-484-args]_ of ``*args: int``, which accepts zero or more values
+of type ``int``:
 
 ::
 
@@ -587,10 +591,10 @@ Type variable tuples can also be used in the arguments section of a
       def __init__(
         self,
         target: Callable[[*Ts], None],
-        args: Tuple[*Ts]
-      ): ...
+        args: Tuple[*Ts],
+      ) -> None: ...
 
-    def func(arg1: int, arg2: str): ...
+    def func(arg1: int, arg2: str) -> None: ...
 
     Process(target=func, args=(0, 'foo'))  # Valid
     Process(target=func, args=('foo', 0))  # Error
@@ -729,7 +733,7 @@ Normal ``TypeVar`` instances can also be used in such aliases:
     Foo[str, int]
     # T bound to float, Ts to Tuple[()]
     Foo[float]
-    # T bound to Any, Ts to an arbitrary number of Any
+    # T bound to Any, Ts to an Tuple[Any, ...]
     Foo
 
 Overloads for Accessing Individual Types
@@ -1470,6 +1474,8 @@ References
 
 .. [#dan-endorsement] https://mail.python.org/archives/list/python-dev@python.org/message/HTCARTYYCHETAMHB6OVRNR5EW5T2CP4J/
 
+.. [#pep-484-args] https://www.python.org/dev/peps/pep-0484/#arbitrary-argument-lists-and-default-argument-values
+
 Copyright
 =========