On 03/31/2013 10:57 AM, Byron Ruth wrote:
I submitted this as bug last night: http://bugs.python.org/issue17584 and was
*honored* to be rejected by Raymond Hettinger. However, I would like feedback
on whether my concern (this bug) is justified and clarity if not.
Consider:
```python
class A(object):
def __init__(self):
self.r = iter(range(5))
def __iter__(self):
return self
@property
def next(self):
return next(self.r)
```
The `next` method is a property, however:
```python
from collections import Iterator
a = A()
isinstance(a, Iterator) # True
next(a) # TypeError: 'int' object is not callable
```
I am using `collections.Iterator` as the means to check if the object is an
iterator, however I am not sure if that is _root_ problem here. My
understanding of the iterator protocol is that is assumes the __iter__ and next
*methods* are implemented. In the example, `A.next` is defined as a property,
but is still identified as an iterator. To me, this is incorrect behavior since
it's not conforming to the iterator protocol requirements (i.e. a `next`
method, not a property).
The root problem is that whoever implemented A did so incorrectly.
Raymond stated: "The design of ABCs are to check for the existence to required
named; none of them verify the signature." I think I understand _why_ this is the
case.. but I downstream libraries use `collections.Iterator` to determine if an object
_is one_: see
https://github.com/django/django/blob/master/django/utils/itercompat.py#L22-L31
Who's job is it to check if `next` (and technically `__iter__`) are methods?
The programmer who wrote it, with good tests.
Technically, the issue is not that 'next' is a property, but that it is not returning a callable. If it did (and the
callable was appropriate for the iterator), that would also work.
--
~Ethan~
--
http://mail.python.org/mailman/listinfo/python-list
