Safe cast (upcast)

Sometimes I want to give a hint to mypy about a type of an expression. cast() works here, but it's inherently unsafe. If I make a mistake, my program may crash at runtime. If we had a "safe cast" operation instead that would only allow casts that can't introduce runtime failures, mypy could catch some additional errors, and the use of cast() could be reduced a bit.

Here's an example derived from an example in mypy of where it would be helpful:

from typing import List, Optional
from mypy_extensions import safe_cast

def f(x: List[Optional[int]], n: int) -> List[Optional[int]]:
    # Mypy doesn't allow + for List[None] and List[Optional[int]], so we need a cast
    return safe_cast(List[Optional[int]], [None]) * n + x

In this case an alternative would be to improve type checking or type inference in mypy, but there will likely always be cases where mypy won't get thing right, and being able to perform a cast would be helpful.

Semantics of safe_cast:

• Provides a type context for the expression (useful in the above example)
• Requires that the expression has a type that is a "proper subtype" (mypy terminology) of the target type

At runtime safe_cast just returns the second argument, similar to cast.

More generally, if we had safe_cast, we could plausibly use binder on initial assignment (#2008), since safe_cast would be a simple workaround for cases where using binder is not desirable. Example where this would make a difference:

x: Union[int, str] = 0
reveal_type(x)  # currently Union[int, str], but perhaps should be 'int'

Now if the revealed type was int, we could use safe_cast to get the original behavior without introducing type unsafety:

x = safe_cast(Union[int, str], 0)  # Type safe!
reveal_type(x)  # Union[int, str]

Safe cast has these benefits over cast():

• Prevents accidentally introducing an unsafe cast
• Helps catch issues where a previously safe cast silently becomes unsafe because some types have changed
• Makes things obvious for a reader or reviewer -- an unsafe cast always needs some care, as it could hide a real issue

Related issues: #5750 (example where this could be helpful), #5687 (safer downcasts)

Start by reviewing mypy's existing cast behavior and the related issues #5750, #5687, and #2008. Define the safe_cast API around the stated examples: it should provide a type context, require the expression to be a proper subtype of the target, and return the expression unchanged at runtime.