NonNullable type

[sobolevn]

There is a use-case when you might explicitly annotate some types as NonNullable, consider this example:

def some(arg):
    if arg is None:
        return Error('Sorry!')
    return SomeClass(arg)

So, the stub for this file will be:

T = TypeVar('T')

@overload
def some(arg: None) -> Error[str]:
     ...

@overload 
def some(arg: T) -> SomeClass[T]:
     ...

It works fine, but the problem is with Optional[] type.

x: Optional[int]
reveal_type(some(x))  # => Some[Optional[int]]

And there's no way to express Union[Some[int], Error[str]] without NonNullable.
Here's how it can look like:

@overload
def some(arg: None) -> Error[str]:
     ...

@overload 
def some(arg: NonNullable[T]) -> SomeClass[T]:
     ...

@overload 
def some(arg: Optional[T]) -> Union[SomeClass[T], Error[str]]:
     ...

Real-life example: https://github.com/dry-python/returns/blob/edb8ae203df518393d9568c25e40e5e8413aaeb9/returns/maybe.pyi#L15-L24

After a conversation with @ilevkivskyi I have searched both typing and mypy repos and I have not found a similar proposal. So, I am opening it.

[srittau]

This would be useful from time to time. The (later) issue #801 suggests a general Not type, so I'm closing this issue as a specialized case of the other issue.