Introduce a Not type

[antonagestam]

This is a continuation of this discussion on the Intersection issue.

I have a different use case for the Not[...] type, but it is related to the original discussion. My usecase is to be able to tell the type checker that two types can never have an intersection. The specific case is for the phantom-types library where there are two types NonEmpty and Empty.

Currently there is no way to tell mypy that a variable can't both be NonEmpty and Empty, so this code passes without error:

from __future__ import annotations
from phantom.sized import NonEmpty, Empty

i: tuple[int, ...] = ()

assert isinstance(i, Empty)
assert isinstance(i, NonEmpty)

reveal_type(i)

The output shows that mypy interprets i as an intersection between tuple, Empty and NonEmpty:

intx.py:9: note: Revealed type is 'intx.<subclass of "tuple", "Empty", and "NonEmpty">'

Of course this code would error at runtime, but it would be preferable if this could be expressible so that type checkers can give an error here, similarly to how mypy gives errors for unreachable code.

A suggestion for how this could be expressed is to allow subclassing a Not type, so simplified the definitions of the two mentioned types would like this:

class NonEmpty:
    ...

class Empty(Not[NonEmpty]):
    ...

There are also other types in the library that would benefit from this like TZAware and TZNaive.

Edit: To clarify, I think that this type would be valuable even without an Intersection type which is why I opened a separate issue. This is because (as showed in the example) there already implicit intersections in mypy. I don't know how the other type checkers treats this.

[KotlinIsland]

In Kotlin the root type Any is split from null, and the union of those is denoted Any?

In TypeScript the root type unknown includes null and undefined, but those types are distinct from the other basal types object, number etc. {} can be used to refer to any type except null(and undefined)

Adding a Not type seems like a massive deal so I think a NotNone type should be added, which is just a shortcut for Not[None].

[mccolljr]

I think I also have a use case for a Not type:

I have a class, something like this:

class Field(Generic[T]):
    kind: FieldKind[T] # has many subclasses, like StringKind, ObjectKind[T], etc
    def __init__(kind_spec: Union[FieldKind[T], Type[FieldKind[T]], Callable[..., T]]):
        ...  

The intent is that T can be some primitive type, or some type that has schema annotations.
The goal is to do something like this:

def field_kind_from(
    spec: Union[FieldKind[T], Type[FieldKind[T]], Callable[..., T]]
) -> FieldKind[T]:
    if isinstance(spec, FieldKind):
        return spec
    if isinstance(spec, FieldKindMeta):
        return spec()
    if isinstance(spec, SchemaMeta):
        return ObjectKind[T](spec)
    raise TypeError(f"{type(spec)} cannot be used as a FieldKind")

...so that I can write all 3 of these and have the type inference work:

field_1 = Field(StringKind()) # Field[str], kind is StringKind()
field_2 = Field(StringKind)   # Field[str], kind is StringKind() 
field_3 = Field(SomeClass)   # Field[SomeClass], kind is ObjectKind[SomeClass]()

However, because Type[FieldKind[T]] can also be construed as Callable[..., T] where T=FieldKind[?], type annotations are required when using the version for field_2 (the most common case)

Right now, T is just TypeVar('T'), but I think this would work how I want if I could specify TypeVar('T', bound=Not[FieldKind]). In other words, tell the type checker that T can be any type that isn't FieldKind or one of its subclasses.

[harahu]

I have yet another use case for Not. Making the typing for Mapping.get more accurate.
If we had Not, we could express it like so:

class Mapping(Collection[_KT], Generic[_KT, _VT_co]):
    @overload
    def get(self, __key: Not[_KT]) -> None: ...
    @overload
    def get(self, __key: object) -> _VT_co | None: ...
    @overload
    def get(self, __key: Not[_KT], default: _T) -> _T: ...
    @overload
    def get(self, __key: object, default: _T) -> _VT_co | _T: ...

Meaning: any key type that for certain cannot contain _KT will result in the default return type. Everything else can result in a union.

This means you don't have to narrow your key type before using Mapping.get with a too broad type, like you must do today.

[ekalosak]

My usecase is much less theory-driven - I just want to be able to safely chain functions using an @maybe decorator:

def maybe(f: Callable) -> Callable:
  def g(...):
    return None if ... is None else f(...)
  return g

^ this has some nasty callback protocol for its type (https://mypy.readthedocs.io/en/stable/protocols.html#callback-protocols) but a NotNone type would make this much more readable.