Using ParamSpec as an argument to a Generic type

[ciupakabra]

Is it possible to correctly type a map function for a pretty straightforward type?

from typing import Callable, TypeVar, Generic, ParamSpec

T = TypeVar("T")
P = ParamSpec("P")

class Container(Generic[T]):
    def __init__(self, x : T):
        self.x = x

def map(f : Callable[P, T]) -> Callable[[Container[P]], Container[T]]:

    def inner(*args: Container[P.args], **kwargs: Container[P.kwargs]) -> Container[T]:
        args = tuple(arg.x for arg in args)
        kwargs = {k: v.x for k, v in kwargs.items()}
        return Container(f(*args, **kwargs))

    return inner

Currently mypy prints

tmp.py:10: error: Invalid location for ParamSpec "P"  [misc]
tmp.py:15: error: Argument 1 has incompatible type "*Tuple[Container[Any], ...]"; expected "P.args"  [arg-type]
tmp.py:15: error: Argument 2 has incompatible type "**Dict[str, Container[Any]]"; expected "P.kwargs"  [arg-type]
Found 3 errors in 1 file (checked 1 source file)

Having seen the discussion #1163 , I'm assuming the answer is no, but I don't understand that discussion fully so would appreciate some help.

Thank you!

[erictraut]

There are a number of problems in this code. First, P.args and P.kwargs cannot be used as a type argument. They're only valid as "unadorned" type annotations for *args and **kwargs, respectively. Second, Container has a single type parameter that is a TypeVar, so P cannot be used as a type argument. That means Container[P] is invalid.

Is Container meant to contain the result of calling function f (i.e. a value of type T)? Or is it meant to contain the values of the parameters that are passed to f?

I'm not sure I fully understand what your intent is with this code, but perhaps this is what you're looking to do?

from typing import Callable, TypeVar, Generic, ParamSpec

T = TypeVar("T")
P = ParamSpec("P")

class Container(Generic[T]):
    def __init__(self, x: T):
        self.x = x

def map(f: Callable[P, T]) -> Callable[P, Container[T]]:
    def inner(*args: P.args, **kwargs: P.kwargs) -> Container[T]:
        return Container(f(*args, **kwargs))

    return inner

[ciupakabra]

Sorry, I didn't explain this very well. I want to keep the logic of the code as it is, but want to know if it is possible to type it correctly.

In particular, I am interested in defining a decorator map that would take a function f and lift the types of all of its positional arguments, keyword arguments and the return value to Container types. In particular, given a bunch of Container args and Container kwargs, we unpack the values in them, pass them through f and pack it up in a Container again. This is a common operation in functional programming, see e.g. applicative functors.

For example, if we make the assumption that the function f has a single positional argument, we can implement and type this as

from typing import Callable, TypeVar, Generic, ParamSpec

T = TypeVar("T")
U = TypeVar("U")

class Container(Generic[T]):
    def __init__(self, x : T):
        self.x = x

def map(f : Callable[[U], T]) -> Callable[[Container[U]], Container[T]]:

    def inner(arg : Container[U]) -> Container[T]:
        return Container(f(arg.x))

    return inner

in which case mypy doesn't complain. I was wondering if it would be possible to remove this assumption on the number of positional & keyword arguments of f. Given what you said, I assume it is not.

[erictraut]

This isn't possible to describe in Python's type system today.