Возможно ли типизированное неявное преобразование (приведение) в Python 3.x?

Вот реализация этой функции, которую я придумал. У нас есть словарь конвертеров single-dispatch для известных нам типов. «неявные» преобразования для. Мы добавляем к этому преобразователи с помощью декоратора @implicit.

Затем у нас есть декоратор @coerce, который может проверять аннотации функций во время выполнения, получать соответствующие преобразователи и применять преобразования. Ниже представлен каркас:

from functools import wraps, singledispatch
from inspect import signature
from collections import OrderedDict

converters = {}

def implicit(func):
    ret = func.__annotations__.get('return', None)
    if not ret or len(func.__annotations__) != 2:
        raise ValueError("Function not annotated properly or too many params")
    if ret not in converters:    
        @singledispatch
        def default(arg):
            raise ValueError("No such converter {} -> {}".format(type(arg).__name__, ret.__name__))    
        converters[ret] = default
    else:
        default = converters[ret]
    t = next(v for k, v in func.__annotations__.items() if k != 'return')
    default.register(t)(func)
    return wraps(func)(default)

def convert(val, t):
    if isinstance(val, t):
        return t
    else:
        return converters[t](val)


def coerce(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        sig = signature(func)
        bound = sig.bind(*args, **kwargs)
        bound.apply_defaults()
        bound.arguments = OrderedDict(
            (param, convert(val, sig.parameters[param].annotation)) 
            for param, val in bound.arguments.items())
        return func(*bound.args, **bound.kwargs)    
    return wrapper

И пример:

from typing import Tuple, Type


@implicit
def str_to_int(a: str) ->  int:
    return int(a)

@implicit
def float_to_int(a: float) -> int:
    return int(a)

@coerce
def make_ints(a: int, b: int) -> Tuple[Type, Type]:
    return (type(a), type(b))

print(make_ints("20", 5.0))
# (<class 'int'>, <class 'int'>)

Я не думаю, что это проблема конвертации. Но это похоже на проблему с аннотацией.

Во-первых, если foo может обрабатывать только A, как он может принять B? И если foo может обрабатывать и B, то почему он должен принимать только A?

Во-вторых, если вы хотите отметить, что foo принимает A или B, вы можете использовать def(foo: Union[A, B]).

Наконец, если вы имеете в виду, что B должен иметь некоторые методы, которые позволяют обрабатывать его функцией, которая может обрабатывать только A. Это все еще экземпляр B. Без правильной аннотации ваши статические анализаторы все равно будут предупреждать вас.

Похоже, вы ищете что-то вроде типов протоколов, предложенных в PEP 544. Этот PEP еще не утвержден (и, возможно, еще не имеет полной реализации), поэтому может пройти некоторое время, прежде чем вы получите нужную вам функцию (как минимум Python 3.8).

class A_Like(typing.Protocol):
    def to_A(self) -> A:
        ...