I think the subscriptable functions PEP and this PEP benefit a lot from each other. Maybe so much even that one could try to introduce them in the same PEP. At least in my mind, making functions subscriptable is a logical extension when having generic arguments available at runtime. I didn't think too much about it, but a use case would be a function that uses a generic class only internally (i.e. not as an argument or output). adding it as a generic would enable static checking that the passed parameter actually provides the methods / fields used in the function. ``` def fun[T](some_arg): return T(some_arg).some_method() ``` Basically generic parameters could be passed to the function just the same as normal parameters with `Any` as a default. If there is no dependency on a generic parameter it could be skipped (dunno if that is a sensible optimization). The only difference is how they are used by static tools.