Not sure this is the right place to ask, but here we go... 😬 I want to be able to annotate something that takes a function and creates a new one that alters the argument types it accepts. A quick example, using Ray https://github.com/ray-project/ray: import rayray.init() @ray.remotedef do_things(x: int, y: float): return x * y @ray.remotedef do_more_things(name: str, value: float): return f"{name}: {value}" pure_value = do_things(x=3, y=2.2) # pure_value is type: float ref_value = do_things.remote(x=3, y=2.2) # ref_value is type: ObjectRef[float] pure_second_value = do_more_things(name="Foo", value=pure_value) # this is fineref_second_value = do_more_things.remote(name="Foo", value=ref_value) # this should be fine So, do_things() and do_more_things() should keep their signature. But their remote counterparts should have a signature that allows the original types or a wrapper ObjectRef[OriginalType] for each argument: do_things.remote(x: int | ObjectRef[int], y: float | ObjectRef[float]) -> ObjectRef[float]: ...do_more_things.remote(name: str | ObjectRef[str], value: float | ObjectRef[float]) -> ObjectRef[str]: ... Now, I know type annotating this in this particular API design is probably difficult, and possibly not easily supported yet. I was thinking of an alternative API that could take advantage of ParamSpec, TypeVars with overloads and/or TypeVarTuple. But I still can't find a way to get all the desired features together. Longer discussion and ideas I tried: https://github.com/python/typing/discussions/1163 --- Assuming this is currently not possible, what would be needed to make it possible? Would some way of achieving this be acceptable? And if so, what would be the best approach to make it possible? I'm not sure what's the process, but maybe there could be a way to sponsor someone with the right expertise here to tackle it, I imagine it would require a PEP, work on mypy, not sure what else, but maybe I'm being naive in some way and it would require a different approach. Thanks for your help and ideas/feedback! Sebastián