How to declare type variables about typing HOT 6 CLOSED

Also, should Var (or typevar) be added to collections.abc, or only to typing?

from typing.

Renamed Var to TypeVar in b7d16de to leave space for variable types in the future.

from typing.

As for the name not being PEP8-compliant, neither is Union, which is also a factory. That's minor.

As for accepting subclasses of constrained types for arguments but limiting return values to explicitly listed classes, that's reasonable but subtle and thus confusing. Seems like it's the covariance discussion in disguise. It's problematic because of this example in the PEP:

  X = TypeVar('X')
  Y = TypeVar('Y', Iterable[X])

  def filter(rule: Callable[[X], bool], input: Y) -> Y:
      ...

1. Since Iterable is abstract, both input and the return value need to be subclasses.
2. Do they have to be the same subclasses? IMHO no, as long as they're both subclassing Iterable.
3. More generally, does it have to be true that `issubclass(type(input), type(return_value))? IMHO no, your comment suggests otherwise.

from typing.

I explained the naming/syntax issue in #5 (I hope).

mypy currently doesn't like something like Iterable[X] as a typevar constraint (the 'values=' kwarg). This may be because it doesn't support parametrized types as type aliases; e.g. this fails:

X = typevar('X')
Y = Iterable[X]

I propose that in the first published draft of the PEP we use a simpler example that actually works when translated to mypy syntax, and think more deeply about constraints on type variables a bit later. E.g. this works as an example using Callable and generic types:

X = TypeVar('X')
def filter(pred: Callable[[X], bool], input: Iterable[X]) -> Iterable[X]:
      return [x for x in input if pred(x)]

For constrained types it would be better to discuss the AnyStr example in the PEP.

from typing.

TypeVar('X', Constraint1) is reducible to Constraint1 as Guido pointed out. A type variable with an upper bound makes sense only if the upper bound consists of several constraints: TypeVar('X', Constraint1, Constraint2, ..., ConstraintN).

FYI, we have bounded type variables in PyCharm. There are 46 bounded parameterized types out of 1186 typed parameters in our stubs. Most of them are our variant of AnyStr except for several parameters of the functions of the datetime module and the filter built-in function for Python 2.

from typing.

We're agreed on X = TypeVar('X'). For the constraints, see #2.

from typing.