On Thu, May 12, 2016 at 2:51 PM, Pavol Lisy <pavol.lisy@gmail.com> wrote:

2016-05-12 20:49 GMT+02:00, Guido van Rossum <guido@python.org>:

> There are some subtleties, e.g. in the above example we would actually like
> to know that the return type varies with the argument type:
>
> joe = new_user(ProUser) # Really, joe is a ProUser, not just a User
>
> This can be done using a type variable, e.g.
>
> U = TypeVar('U', bound=User)
> def new_user(user_class: Type[U]) -> U: ...
> joe = new_user(ProUser)

It is very probably I dont understand. Is U here same type (=ProUser)
for parameter and for return?

Their status is different though. The return type is inferred from the argument type but (usually) not the other way around.

Because in PEP484 is written:

-> CT = TypeVar('CT', bound=Comparable)
->
-> def min(x: CT, y: CT) -> CT:
-> if x < y:
-> return x
-> else:
-> return y
->
-> min(1, 2) # ok, return type int
-> min('x', 'y') # ok, return type str
->
->(Note that this is not ideal -- for example ``min('x', 1)`` is invalid
->at runtime but a type checker would simply infer the return type
->``Comparable``. Unfortunately, addressing this would require
->introducing a much more powerful and also much more complicated
->vconcept, F-bounded polymorphism. We may revisit this in the future.)

which I understand that CT could be different type for x (=str) and y (=int).

No, *in a given call* CT will be the same for all. The example with Comparable is that for `min('x', 1)` there is a solution where CT *is* actually the same for both arguments -- both 'x' and 1 are instances of Comparable. In that example this is not ideal.

But in the new_user(UserPro) example there's only one occurrence of U in the argument list, and that will be inferred as the return type.

An example more similar to the CT example with users would be something like

def pair_accounts(personal_user_class: Type[U], business_use_class: Type[U]) -> List[U]: ...

Here the return type of pair_accounts(ProUser, ProUser) would be inferred as List[ProUser], but the return type of pair_accounts(ProUser, TeamUser) would be inferred as List[User], since User is the common base class of ProUser and TeamUser.

--Guido van Rossum (python.org/~guido)