Issue 44636: It is possible to create a 1-type union type

typing.Union always collapsed to a simple type if it contains a single type.

>>> import typing
>>> typing.Union[int, typing.T][int]
<class 'int'>

But the builtin union type can contain a single type:

>>> (int | typing.T)[int]
int
>>> type((int | typing.T)[int])
<class 'types.Union'>

Simple example (without indexing):

>>> import typing
>>> typing.Union[int, int]
<class 'int'>
>>> int | int
int

I feel that keeping the singleton is more consistent. This normalization seems to me an example of the typing module doing too much. Singleton tuples are different from scalar values too.

It is a difference with typing.Union which can cause confusion. If the union type is like a tuple and we leave a 1-type union, why do we bother with deduplication? Why int | str | int is collapsed into int | str?

Also it complicates the comparison implementation and produces surprising exceptions:

>>> int | str == {}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'

Also it breaks one of fundamental properties -- equal objects should have equal hashes.

>>> (int | int) == int
True
>>> hash(int | int) == hash(int)
False

Hm, you are right. Make it so, Mr. Spock! :-)

New changeset d9f923280f204204f8703756aef4f655b579b4b8 by Serhiy Storchaka in branch 'main':
bpo-44636: Collapse union of equal types (GH-27178)
https://github.com/python/cpython/commit/d9f923280f204204f8703756aef4f655b579b4b8

New changeset c3007ab3c6cb384203bac8aa64d89c4b42f671a1 by Serhiy Storchaka in branch '3.10':
[3.10] bpo-44636: Collapse union of equal types (GH-27178) (GH-27181)
https://github.com/python/cpython/commit/c3007ab3c6cb384203bac8aa64d89c4b42f671a1