Support iteration on enums

[bbc2]

Iterating on enums makes mypy (0.4.5) raise errors even though it's OK:

import enum


class Colors(enum.Enum):
 RED = 0
 BLUE = 1


print([color.name for color in Colors])

> python3 color.py 
['RED', 'BLUE']

> mypy color.py 
color.py:9: error: Iterable expected
color.py:9: error: "Colors" has no attribute "__iter__"

(follow-up issue created as suggested in #529)

[elazarg]

At first sight, we only need #2193

class Enum:
 ...
 @classmethod
 def __iter__(cls: Type[T]) -> Iterator[T]: ...

And somehow making Enum itself iterable?

But it's not so simple, since Enum is a class appearing in the context of an expression, and therefore "coerce" to a callable somewhere in the code. Thus the above code still results in error: Iterable expected. At the point where the error is emitted, the information that it's enum does not seem to exist anymore - it is a simple callable.

[dokai]

In terms of making a class itself iterable it seems you have to use a metaclass instead of using just a @classmethod in the class definition.

In [7]: class A:
 ...: @classmethod
 ...: def __iter__(cls):
 ...: return iter(range(3))
 ...:

In [8]: list(A)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-8-ed10f13c6f39> in <module>()
----> 1 list(A)

TypeError: 'type' object is not iterable

In [9]: class MetaIter(type):
 ...: def __iter__(self):
 ...: return iter(range(3))
 ...:

In [10]: class B(metaclass=MetaIter): pass

In [11]: list(B)
Out[11]: [0, 1, 2]

[gvanrossum]

Yes, that's what I meant. But that's runtime. How to do it in mypy is probably quite different because it doesn't interpret the metaclass.

[gvanrossum]

Did you check the is_type_obj() method? It should still know... Also, I doubt that defining a classmethod is the same as having it on the metaclass. IIRC that doesn't even work in CPython.

[elazarg]

I didn't check yet.

As you said, it's not how mypy work. I think it should, but I guess it will require a big change.

(I wonder whether mypy should mimic Smalltalk's object model. It's very elegant, and perhaps we can think of Python as "hiding the theory" (e.g. that type(type) != type) for the convenience of the user. Similarly to the -type-in-type flag in COQ, which collapses the universe of types into a single one.
Yes, I know, I get carried away sometimes. Sorry)