René's URL Explorer Experiment

{"@context":"https://schema.org","@type":"DiscussionForumPosting","headline":"TypeVar to represent a Callable's arguments","articleBody":"This is an idea for a new type system feature that can help more accurately type some decorators and wrapper functions, like `@async()` from https://github.com/quora/asynq.\r\n\r\nI'd like to see something like this work:\r\n```python\r\nfrom mypy_extensions import ArgumentsVar\r\nfrom typing import TypeVar, Awaitable\r\n\r\n_ArgsT = ArgumentsVar('_ArgsT')\r\n_RetT = TypeVar('_RetT')\r\n\r\ndef make_awaitable(fn: Callable[_ArgsT, _RetT]) -\u003e Callable[_ArgsT, Awaitable[_RetT]]:\r\n    async def wrapper(**args: _ArgsT, **kwargs: _ArgsT) -\u003e Awaitable[_RetT]:\r\n        result = fn(*args, **kwargs)\r\n        return result\r\n    return wrapper\r\n\r\n@make_awaitable\r\ndef f(x: int, y: str) -\u003e int:\r\n    return 3\r\n\r\nreveal_type(f(1, 'x'))  # Awaitable[int]\r\nf(1, 1)  # error, second argument must be str\r\nf(1, z=3)  # error, z is not a valid kwarg\r\n```\r\nHaving a function's args and kwargs annotated with an `ArgumentsVar` would mean that it takes the arguments that the `ArgumentsVar` resolves to. As an extension, we could also make something like `def f(x: int, *args: _ArgsT, **kwargs: _ArgsT) -\u003e _T: ...` work to indicate that a function takes an argument called `x` plus the arguments specified in `_ArgsT`.\r\n\r\nThis could also improve some types in the standard library. For example, the annotations for `functools.singledispatch` currently don't check function arguments. With ArgumentsVar, it could be typed as follows:\r\n```python\r\n_T = TypeVar('_T')\r\n_ArgsT = ArgumentsVar('_ArgsT')\r\n\r\nclass _SingleDispatchCallable(Generic[_ArgsT, _T]):\r\n    registry = ...  # type: Mapping[Any, Callable[_ArgsT, _T]]\r\n    def dispatch(self, cls: Any) -\u003e Callable[_ArgsT, _T]: ...\r\n    @overload\r\n    def register(self, cls: Any) -\u003e Callable[[Callable[_ArgsT, _T]], Callable[_ArgsT, _T]]: ...\r\n    @overload\r\n    def register(self, cls: Any, func: Callable[_ArgsT, _T]) -\u003e Callable[_ArgsT, _T]: ...\r\n    def _clear_cache(self) -\u003e None: ...\r\n    def __call__(self, *args: _ArgsT, **kwargs: _ArgsT) -\u003e _T: ...\r\n\r\ndef singledispatch(func: Callable[_ArgsT, _T]) -\u003e _SingleDispatchCallable[_ArgsT, _T]: ...\r\n```\r\nThis kind of thing has come up before, but I'm not sure a concrete solution has been proposed. I'll try to implement this to see how well it works.","author":{"url":"https://github.com/JelleZijlstra","@type":"Person","name":"JelleZijlstra"},"datePublished":"2017-03-19T17:38:47.000Z","interactionStatistic":{"@type":"InteractionCounter","interactionType":"https://schema.org/CommentAction","userInteractionCount":12},"url":"https://github.com/3028/mypy/issues/3028"}