Type expression is coerced to a list of parameter arguments in substitution of ParamSpec #88964

Activity

1. serhiy-storchaka commented on Aug 1, 2021

   

   serhiy-storchaka

   on Aug 1, 2021

   MemberAuthor

   More actions

   Type expression is coerced to a list of parameter arguments in substitution of ParamSpec. For example:

   >>> from typing import *
   >>> T = TypeVar('T')
   >>> P = ParamSpec('P')
   >>> C = Callable[P, T]
   >>> C[int, str]
   typing.Callable[[int], str]

   int becomes [int]. There is even a dedicated test for this.

   But it is not followed from PEP-612. Furthermore, it contradicts one of examples in the PEP:

   >>> class X(Generic[T, P]):
   ...     f: Callable[P, int]
   ...     x: T
   ... 
   >>> X[int, int]  # Should be rejected
   __main__.X[int, int]

   It makes the implementation (at least the code in bpo-44796) more complex and makes the user code more errorprone.
2. serhiy-storchaka

   added

   stdlibStandard Library Python modules in the Lib/ directoryStandard Library Python modules in the Lib/ directory

   3.10 (EOL)end of lifeend of life

   3.11only security fixesonly security fixes

   type-bugAn unexpected behavior, bug, or errorAn unexpected behavior, bug, or error

   on Aug 1, 2021
3. Fidget-Spinner commented on Aug 1, 2021

   

   Fidget-Spinner

   on Aug 1, 2021

   Member

   More actions

   Type expression is coerced to a list of parameter arguments in substitution of ParamSpec.

   It's not, only the repr is like that. Internally it's not coerced.

   >>> C[int, str]
   typing.Callable[[int], str]
   >>> C[int, str].__args__
   (<class 'int'>, <class 'str'>)

   Because Callable's correct form is Callable[[type], type] (where type is not ParamSpec or Concatenate) so the repr reflects that.

   Internally, Callable also flattens the list of args:

   >>> Callable[[int, str], int].__args__
   (<class 'int'>, <class 'str'>, <class 'int'>)

   Because __args__ *must* be hashable and immutable. Otherwise, it will not work with Union or Literal. Some time ago we tried converting to nested tuple. But that was too difficult (and backwards incompatible) because every other typing operation expected __args__ to contain types, not a tuple.
4. serhiy-storchaka commented on Aug 3, 2021

   

   serhiy-storchaka

   on Aug 3, 2021

   MemberAuthor

   More actions

   Thank you Ken Jin. So the problem is the __args__ (x, str) is interpreted differently depending on x, and after substituting x the interpretation can be changed. If x was ParamSpec, it was interpreted in one way, but if it becomes int, it is now interpreted in other way.

   The solution is to forbid substitution of P with wrong values (not parameters expression). Some normalization is also needed, before and after substitution.

   Other related example is:

   >>> from typing import *
   >>> P = ParamSpec("P")
   >>> class Z(Generic[P]): pass
   ... 
   >>> A = Z[[int]]
   >>> B = Z[int]
   >>> A
   __main__.Z[(<class 'int'>,)]
   >>> B
   __main__.Z[int]
   >>> A.__args__
   ((<class 'int'>,),)
   >>> B.__args__
   (<class 'int'>,)

   It is expected that A and B should the same.
5. ambv commented on Aug 4, 2021

   

   ambv

   on Aug 4, 2021

   Contributor

   More actions

   New changeset 3875a69 by Serhiy Storchaka in branch 'main':
   bpo-44801: Check arguments in substitution of ParamSpec in Callable (GH-27585)
   3875a69
6. miss-islington commented on Aug 4, 2021

   

   miss-islington

   on Aug 4, 2021

   Contributor

   More actions

   New changeset 536e35a by Miss Islington (bot) in branch '3.10':
   bpo-44801: Check arguments in substitution of ParamSpec in Callable (GH-27585)
   536e35a
7. ambv

   closed this as completedon Aug 4, 2021
8. ezio-melotti

   transferred this issue fromon Apr 10, 2022