Mailman 3 July 2021 - Typing-sig

Follow-up on Pyre implementation of Broadcast and Literal Arithmetic
by Alfonso L. Castaño 20 Jul '21

20 Jul '21

Thank you again Pradeep and Brandon for the presentation last Monday! It is great to see the progress of Pyre and I appreciate the effort that you make for implementing new features in Pyre. I wanted to make sure that I fully understand what was presented in case that we can provide additional feedback. Regarding the implementation in Pyre of the Broadcast operator, I was wondering if the implementation follows the proposal that I made in 14-09-2020 (https://docs.google.com/presentation/d/16VGNfVo6Kxk9lBhm1cx1-Jr19dqESyy10Wk…) or if you have made any change on its behavior or properties. For example, you mentioned that you were doing some normalization even if it was not in the slides, so I was curious if maybe you have spotted new equivalences of Broadcasting expressions. And as of literal arithmetic, I was wondering if it is available in Pyre. Although I said in (https://docs.google.com/presentation/d/16VGNfVo6Kxk9lBhm1cx1-Jr19dqESyy10Wk…) that it requires standardization to be ready (typeshed) but I was wondering if it is already supported by rewriting typeshed internally. Best, Alfonso.

2 1

Subtyping and Any
by Kevin Millikin 16 Jul '21

16 Jul '21

I'm trying to sort out the Python typing rules using PEP-483 as a starting point and the treatment of is-consistent-with and Any seems unclear. "The is-consistent-with relationship is defined by three rules: - A type t1 is consistent with a type t2 if t1 is a subtype of t2. (But not the other way around.) - Any is consistent with every type. (But Any is not a subtype of every type.) - Every type is consistent with Any. (But every type is not a subtype of Any.)" And then, for instance: "Tuple[u1, u2, ..., um] is a subtype of Tuple[t1, t2, ..., tn] if they have the same length n==m and each ui is a subtype of ti." From the above, I would expect type checkers to reject both of the assignments below: t0: Tuple[int, Any] = (0, object()) t1: Tuple[int, str] = (1, 't1') t0 = t1 t1 = t0 Neither of these types are Any so they are only consistent if they have a subtype relationship. Mypy and pytype accept both assignments. If we treat Any as a top type then the first assignment is OK and the second is not, and that's not what's going on. So there must be some notion of consistent subtyping that is what is actually implemented. Is this spelled out anywhere other than the code? -- [image: logo] Kevin Millikin Software Engineer kmillikin(a)deepmind.com If you received this email in error, please do not forward it to anyone else (it may contain confidential or privileged information), erase all copies and attachments, and let me know that it has gone to the wrong person.

3 7

Why is Type[Type] disallowed? (repost)
by Buck Evan 14 Jul '21

14 Jul '21

Now with improved legibility: PEP-0484 specifies that Any, classes, unions of classes, and type variables can be parameters of types, and "Any other special constructs like Tuple or Callable are not allowed as an argument to Type." I found the origin of this text: https://github.com/python/typing/pull/218#discussion-diff-63608361 It looks like the intent of this was to prohibit non-class values, but the improved wording was overly strict. mypy uses Type[Type[]] in its internal representation and error messages already: ``` list_str: List[str] = ["a", "b", "c"] type_list_str: Type[List[str]] = type(list_str) type_type_list_str = type(type_list_str) reveal_type(type_type_list_str) # note: Revealed type is 'Type[Type[builtins.list[builtins.str]]]' ``` and will typecheck such an annotation as expected: ``` list_str: List[str] = ["a", "b", "c"] type_list_str: Type[List[str]] = type(list_str) # error: Incompatible types in assignment (expression has type "Type[Type[List[str]]]", variable has type "Type[Type[List[int]]]") type_type_list_int: Type[Type[List[int]]] = type(type_list_str) ```

1 0

Why is Type[Type] disallowed?
by Buck Evan 14 Jul '21

14 Jul '21

PEP-0484 specifies that Any, classes, unions of classes, and type variables can be parameters of types, and "Any other special constructs like Tuple or Callable are not allowed as an argument to Type." I found the origin of this text: https://github.com/python/typing/pull/218#discussion-diff-63608361 It looks like the intent of this was to prohibit non-class values, but the improved wording was overly strict. mypy uses Type[Type[]] in its internal representation and error messages already: ``` list_str: List[str] = ["a", "b", "c"] type_list_str: Type[List[str]] = type(list_str) type_type_list_str = type(type_list_str) reveal_type(type_type_list_str) # note: Revealed type is 'Type[Type[builtins.list[builtins.str]]]' ``` and will typecheck such an annotation as expected: ``` list_str: List[str] = ["a", "b", "c"] type_list_str: Type[List[str]] = type(list_str) # error: Incompatible types in assignment (expression has type "Type[Type[List[str]]]", variable has type "Type[Type[List[int]]]") type_type_list_int: Type[Type[List[int]]] = type(type_list_str) ```

1 0

Next tensor typing meeting: Monday 12th July
by Matthew Rahtz 14 Jul '21

14 Jul '21

Hi everyone, Since I forgot to advertise this week's tensor typing meeting in advance, let's push it to next week to give folks sufficient notice and in case anyone else wants to present something. So the next meeting will be *Monday the 12th of July, at 6pm UK time/10am San Francisco time.* Our agenda will be: 1. Status update on PEP 646 (grammar changes, cpython implementation) 2. Feedback from presentations at NumPy community groups (backwards-compatibility, size of overloads) Anyone want to talk about anything else? Cheers, Matthew

1 2