I'm not a fan of this approach, especially if we'd also support the -> None return type as well. But it might be the least bad way to do it. Here are the things that I'm worried about:

Would a None return be still valid as well? If yes, would the new syntax be valid in non-generic classes as well? If that's the case, some users might prefer to use the -> C variant everywhere, while others would prefer to use -> None (as classes where this actually makes a difference will be very rare). I strongly think that we should recommend a single convention to be used as default in case there are multiple alternatives (perhaps mention this in PEP 8). If we deprecate the -> None return type, almost all existing code would have to be updated.
In subclasses the return type would be an instance of the subclass instead of the one given in the annotation, in case __init__ gets inherited. This would be subtly different form other methods, where this kind of variation does not happen. (We might want to support SelfType or similar to support this functionality. However, SelfType wouldn't work here as it wouldn't support indexing.) Example:

class A:
    def __init__(self) -> A: ...

class B(A): pass

b = B()  # type is B even though annotation says `A`

__init__ could have a return type even though it can't return a value of the given type using a return statement. This would be inconsistent with other functions (though __init__ special in other respects as well).

Another way to implement would be to provide a special syntax for just this construct. A function decorator would work, though it would still be ugly. However, this is a rare issue so it might be acceptable. Perhaps something like this (the name is not the greatest):

from typing import instance_type

def C(...):
    ...
    @instance_type(C[str, T])
    def __init__(self, **kwargs: T)

Uh oh!

Uh oh!

Subclass of dict doesn't inherit special signature #1010

Description

Activity

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions