Add open question concerning ...

minor polish

Author: Daraan

peps/pep-0821.rst

@@ -131,7 +131,7 @@ Optional arguments
 
 Keys marked ``NotRequired`` in the ``TypedDict`` correspond to optional
 keyword arguments.
-Meaning the callable must accept them, but callers may omit them.
+This means that the callable must accept them, but callers may omit them.
 Functions that accept the keyword argument must also provide a default value
 that is compatible; functions that omit the parameter entirely are rejected::
 
@@ -195,7 +195,7 @@ arguments beyond those declared are expected::
 Interaction with ``extra_items`` (PEP 728)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-If a ``TypedDict`` specifies the ``extra_items`` parameter (with the exemption
+If a ``TypedDict`` specifies the ``extra_items`` parameter (with the exception
 of ``extra_items=Never``), the corresponding ``Callable``
 must accept additional keyword arguments of the specified type.
 
@@ -276,7 +276,7 @@ taught that with ::
   ``__call__(self, a: int, b: str = ..., **kwargs: object) -> R``.
 * Teachers might want to introduce the concept of ``TypedDict`` with
   ``Callable`` first before introducing ``Protocol``.
-* The implicit addition of ``**kwargs: object`` might come surprising to users,
+* The implicit addition of ``**kwargs: object`` might be surprising to users;
   using ``closed=True`` for definitions will create the more intuitive
   equivalence of ``__call__(self, a: int, b: str = ...) -> R``
 * Users should be made aware of the interaction with ``extra_items`` from
@@ -309,6 +309,29 @@ Open Questions
   should apply in such a case? Should the order matter?
 * Is there a necessity to differentiate between normal and ``ReadOnly`` keys?
 
+Allowing ``...`` in parameter list
+----------------------------------
+
+A further extension would be to allow ``...`` in combination with ``Unpack[TD]``,
+for example ``Callable[[int, ..., Unpack[TD]], R]``, to indicate that there may
+be additional positional parameters before the specified keyword-only
+parameters. This would be equivalent to
+``def func(a: int, *args: Any, **kwargs: Unpack[TD]) -> R: ...``.
+Currently, ``...`` is only allowed as the sole parameter in ``Callable`` or it
+must be the last argument in ``Concatenate``.
+
+The semantics are different: within ``Concatenate``, ``...`` indicates
+additional parameters of any kind, whereas in this proposed usage it would
+indicate only additional positional parameters.
+Should this behavior be part of this PEP, or would it introduce too much
+ambiguity about where ``...`` is allowed?
+As a follow-up or alternative, should ``...`` also be allowed before the end of
+the parameter list without ``Unpack[TD]``, with the same meaning it has in
+``Concatenate`` (i.e., ``Callable[[int, ...], R]`` being equivalent to
+``Callable[Concatenate[int, ...], R]``)?
+This would allow a more user-friendly syntax without requiring users to learn
+about ``Concatenate``.
+
 Acknowledgements
 ================