What if duck types are unions of all the ducklings

If the duck typed types were actually unions of all the ducklings then it would fix a bunch of edge cases that arise.
And would make this feature more easily understood and discovered.

def func1(c: complex):
    reveal_type(c)  # float | int | complex

def func2(f: float):
    reveal_type(f)  # float | int

def func3(b: bytes):
    reveal_type(b)  # bytes | bytearray | memoryview

def func4(u: unicode):  # python 2 moment
    reveal_type(u)  # unicode | str

edge cases:

def func(f: float):
    f.is_integer()  # error: int has no member "is_integer"

def func(f: float):
    if not isinstance(f, float):
        print("hi")  # no 'unreachable code' error
        reveal_type(f)  # int | complex

It would also be useful to have type types for float and bytes, when you want exactly float and don't want any stinking ints.

Related #11511, #11145

Inizia con gli esempi di questa issue e confronta la semantica delle union proposta con le issue correlate #11511 e #11145. Risolvi come devono comportarsi i tipi con duck typing, inclusi i tipi esatti float e bytes e il restringimento tramite isinstance; il lavoro è completo quando sono stati concordati un design e il comportamento corrispondente del type-checker.