Think up a way to type list constructor

[KotlinIsland]

From #377

problem:

a: Iterable[int] | list[str]
b = list(a)
reveal_type(b) # list[int | str]

While this is typesafe, it should contain the same distinctions as a, i.e. it should be list[int] | list[str].

mypy in real life

a: list[int] | list[str]
a = sorted(a)  # error

sorted takes any Iterable and returns a list of that same type, so it's expected:

a: Iterable[int] | list[str]
reveal_type(sorted(a)) # list[int] | list[str]

This is almost achievable by using Any as the parameter to the bound:

from typing import Any, Iterable, TypeVar

I = TypeVar("I", bound=Iterable[Any])

def f(i: I) -> I: ...

a: Iterable[str] | list[int]
reveal_type(f(a))  # Revealed type is "typing.Iterable[str] | list[int]"

There are two issues with this though, sorted takes an Iterable of SupportsRichComparison, not object, so the Any will allow any type (e.g. Iterable[None]). And that this returns the input Iterable instead of converting it to a list.

Ruminations

• Is Support distributed unions on generics #365 nonsense?

in TS generic conditional types are distributes across arays:

type ToArray<T> = T extends unknown ? Array<T> : never
let a: ToArray<number | string>
//  ^?  let a: number[] | string[]

24/08/2022 Discovery of 'union math'

It appears that mypy already supports this functionality, although I think by accident (only works on overloads)
https://mypy-play.net/?mypy=latest&python=3.10&gist=d9dc9f0d0a4c3d2af48c4b28f526a705

So I think what we need to do is to add it to normal call analysis.