I like this. I've been struggling with the repr() quite a bit (in Python 3.5.0 it was quite different). I don't know if I'll have time to merge today but I hope soon.

I just found a bug here, with very light QA.

from typing import Any, Dict

class C(Dict[Any, Any]):
    pass

print(C.__mro__)

Gives a traceback:

Traceback (most recent call last):
  File "y.py", line 6, in <module>
    print(C.__mro__)
  File "/Users/guido/src/typing/src/typing.py", line 1009, in __repr__
    return super().__repr__() + self._argrepr()
  File "/Users/guido/src/typing/src/typing.py", line 1017, in _argrepr
    for i in range(len(self.__args__)):  # replace free parameters with args
TypeError: object of type 'NoneType' has no len()

Oops! I played with this on top of #295 most of the time, so I didn't notice this. Thanks!
I just pushed a new commit where I carefully treat Generic[T] and _Protocol[T] (with more tests).

@gvanrossum I have a simple patch for http://bugs.python.org/issue27989 (better representation of function signatures by pydoc). I didn't submit it, because it works much better on top of this PR.

Are you going to merge this or you have some additional comments?

@gvanrossum

Sorry, just temporarily ran out of time. Will get to it soon.

Not a problem at all.
In the meantime I implemented the PEP 526 syntax for NamedTuple in mypy: python/mypy#2245 so that if mypy PR is merged, then you could also apply the patch in http://bugs.python.org/issue28107 (earlier we decided to postpone documenting new NamedTuple syntax until it is implemented in mypy).

@gvanrossum
Agreed, probably I am just being lazy here :-) Now there is no regexp and no recursion (except for the case one calls repr(List[List[List[T]]][int]), in this case there will be three recursive calls). It was necessary to add a _subs_repr method to some types that can contain type variables but are not instances of GenericMeta (this is similar to what you did with _get_type_vars). Note that no new types are created, all manipulations are done with lists of parameters/arguments.

While working on this, I have found three very minor bugs (I have fixed them right here) and three bigger things that I think are bugs, I will open issues on tracker soon.

@gvanrossum I forgot to add, I changed the repr for bare generics, now repr(List) == 'typing.List', not typing.List[~T] as before. There are two reasons for this:

• It is more consistent with other things in typing. For example repr(Optional) is simply 'typing.Optional', etc.
• By agreement, bare List means List[Any], so that if one wants a function that takes an arbitrary list and returns an arbitrary list, then it would be typed as def func(x: List) -> List. But then in pydoc and other doc-tools its signature will be displayed as func(x: List[~T]) -> List[~T], that looks like a generic function. I could imagine this causing a lot of confusion.

I'm giving you the benefit of the doubt here -- it looks fine but I'm out of time this week to really understand how this works. I trust it's easy enough to understand when someone finds a bug though.