[Python-Dev] Adding Type[C] to PEP 484

[Guido van Rossum]

Right. I still have no good intuition for what Type[BasicUser, ProUser]
would mean so I think you should be required to use the Union, which is
clear. Type[] should only allow one parameter.

Most real uses of Type[] use a type variable anyway.

I really recommend that you read through
https://github.com/python/typing/issues/107 even though it's long and
meanders a bit; it comes to the right conclusion in the end.

On Sun, May 15, 2016 at 10:24 AM, Peter Ludemann <pludemann at google.com>
wrote:

>
>
> On 14 May 2016 at 13:28, Guido van Rossum <gvanrossum at gmail.com> wrote:
>
>> On Sat, May 14, 2016 at 11:47 AM, Peter Ludemann <pludemann at google.com>
>> wrote:
>>
>>> I think that Type[C,D] would mean Union[Type[C], Type[D]], but I'm not
>>> sure ... I should probably talk to a typing expert about this.
>>> (Sorry for thinking out loud; but if we decide that Type[C,D] doesn't
>>> make sense, we need to prohibit it)
>>>
>>
>> It sounds iffy enough to prohibit.
>>
>>
>>> I suppose I'm asking: do we allow new_user(Type[BasicUser, ProUser])?
>>>
>>
>> That looks like a call, but Type[] is something to use in the definition.
>>
>>
>>> Here's a trivial example that off the top of my head makes sense:
>>>
>>> BasicOrProUser = TypeVar('BasicOrProUser', BasicUser, ProUser)
>>> def new_user(name: str, user_factory: Type[BasicOrProuser]) ->
>>> BasicOrProUser:
>>>     return user_factory(name)
>>>
>>
>> That looks reasonable and only has one parameter to Type[].
>>
>
> So, should we allow this (by analogy to TypeVar allowing multiple types):
>
> ​  ​
> def new_user(name: str, user_factory: Type[BasicUser, ProUser]) ->
> Union[BasicUser, ProUser]:
>
> ​  ​
>   return user_factory(name)
>
> ?
> ​... ​
> ​or should it be:
>
> ​
> def new_user(name: str,
> ​              ​
> user_factory: Type[
> ​
> Union[
> BasicUser, ProUser
> ​]​
> ]) -> Union[BasicUser, ProUser]:
>       return user_factory(name)
> ​
> ?
>
> Although both of these lose the information that the output type is
> related to the input type; and hopefully the verbosity would encourage
> people to use TypeVar.
>
> (From these examples, my preference is for Type to be limited to a single
> choice and anything more complicated should be done with TypeVar, Union,
> etc.)
>
>
>
>>
>>
>>> Or must the Type[...] item have been defined with a TypeVar(...,
>>> bound=...), in which case multiple types aren't allowed with Type[...]?
>>>
>>
>> You can use whatever you want. If you want to write Type[int] go right
>> ahead. Even Type[Union[int, str]] should be allowed. There is *usually* a
>> good reason to use a type variable though -- without one the return type
>> would be the base class. (But then again maybe that could be what you want,
>> or you might not even have a return type, e.g. when the thing just gets
>> thrown into the database.)
>>
>> --Guido
>>
>>
>>>
>>>
>>> On 14 May 2016 at 11:30, Guido van Rossum <gvanrossum at gmail.com> wrote:
>>>
>>>> What would Type[C, D] mean?
>>>>
>>>> --Guido (mobile)
>>>> On May 14, 2016 11:21 AM, "Peter Ludemann via Python-Dev" <
>>>> python-dev at python.org> wrote:
>>>>
>>>>> Is Type[C,D] allowed? Or should multiple types be restricted to
>>>>> TypeVar?
>>>>>
>>>>> _______________________________________________
>>>>> Python-Dev mailing list
>>>>> Python-Dev at python.org
>>>>> https://mail.python.org/mailman/listinfo/python-dev
>>>>> Unsubscribe:
>>>>> https://mail.python.org/mailman/options/python-dev/guido%40python.org
>>>>>
>>>>>
>>>
>>
>>
>> --
>> --Guido van Rossum (python.org/~guido)
>>
>
>


-- 
--Guido van Rossum (python.org/~guido)
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-dev/attachments/20160515/9c8c75ea/attachment.html>