Allow specifying a default for omitted type parameters

[refi64]

Take the following class:

class Base: pass
class Derived(Base): pass

T = TypeVar('T', bound=Base)
class MyType(Generic[T]):
 pass

myvar: MyType = None # type of `myvar` is `MyType[Any]`

My idea is to allow for some way to specify a default other than any when the parameters are omitted. For example:

class Base: pass
class Derived(Base): pass

T = TypeVar('T', bound=Base, default=Base)
class MyType(Generic[T]):
 pass

myvar: MyType = None # type of `myvar` is `MyType[Base]`

or (I know this is invalid syntax, but it's the idea that counts):

class Base: pass
class Derived(Base): pass

T = TypeVar('T', bound=Base)
class MyType(Generic[T, default=Base]):
 pass

myvar: MyType = None # type of `myvar` is `MyType[Base]`

[ilevkivskyi]

@kirbyfan64
Interesting idea. It would be easy to implement the first option in typing.py, but the difficult part would be to implement this in mypy.

(btw mypy will complain about you example with --strict-optional unless you remove None)

[refi64]

Another though: since classes can take arbitrary arguments:

class Base: pass
class Derived(Base): pass

T = TypeVar('T', bound=Base)
class MyType(Generic[T], T=Base):
 pass

myvar: MyType = None # type of `myvar` is `MyType[Base]`

Then, on the typing.py side, GenericMeta could just ignore any keyword arguments.

[ratijas]

+1

Would be so nice to have a Result[T, E] with default E=MyCommonlyUsedError if omitted, and some other domain-specific error type otherwise.

[ratijas]

As far as I remember, for now we can not do type aliases like this either:

IResult[T] = Result[T, IError]
UResult[T] = Result[T, UError]

because of a syntax error.

Is there any way around until the subject is implemented?

[JelleZijlstra]

You can just write IResult = Result[T, IError], and the alias will be generic (so you can write IResult[int]).

[ratijas]

@JelleZijlstra Brilliant! Thanks!

[srittau]

Another example where this could be beneficial, from typeshed:

_T = TypeVar("_T", default=None)
def nullcontext(enter_result: _T = ...) -> ContextManager[_T]: ...

At the moment this uses an overload.