remove traces of .next

benjaminp · benjaminp · commit e7c78b26c637 · 2008-07-03T20:28:26.000Z
diff --git a/Doc/glossary.rst b/Doc/glossary.rst
@@ -168,7 +168,7 @@ Glossary
       :keyword:`yield` elements back to the caller.  The function execution is
       stopped at the :keyword:`yield` keyword (returning the result) and is
       resumed there when the next element is requested by calling the
-      :meth:`next` method of the returned iterator.
+      :meth:`__next__` method of the returned iterator.
     
       .. index:: single: generator expression
     
@@ -266,11 +266,12 @@ Glossary
     
    iterator
       An object representing a stream of data.  Repeated calls to the iterator's
-      :meth:`next` method return successive items in the stream.  When no more
-      data is available a :exc:`StopIteration` exception is raised instead.  At
-      this point, the iterator object is exhausted and any further calls to its
-      :meth:`next` method just raise :exc:`StopIteration` again.  Iterators are
-      required to have an :meth:`__iter__` method that returns the iterator
+      :meth:`__next__` (or passing it to the builtin function) :func:`next`
+      method return successive items in the stream.  When no more data is
+      available a :exc:`StopIteration` exception is raised instead.  At this
+      point, the iterator object is exhausted and any further calls to its
+      :meth:`__next__` method just raise :exc:`StopIteration` again.  Iterators
+      are required to have an :meth:`__iter__` method that returns the iterator
       object itself so every iterator is also iterable and may be used in most
       places where other iterables are accepted.  One notable exception is code
       that attempts multiple iteration passes.  A container object (such as a
diff --git a/Doc/howto/functional.rst b/Doc/howto/functional.rst
@@ -184,11 +184,11 @@ foundation for writing functional-style programs: iterators.
 
 An iterator is an object representing a stream of data; this object returns the
 data one element at a time.  A Python iterator must support a method called
-``next()`` that takes no arguments and always returns the next element of the
-stream.  If there are no more elements in the stream, ``next()`` must raise the
-``StopIteration`` exception.  Iterators don't have to be finite, though; it's
-perfectly reasonable to write an iterator that produces an infinite stream of
-data.
+``__next__()`` that takes no arguments and always returns the next element of
+the stream.  If there are no more elements in the stream, ``__next__()`` must
+raise the ``StopIteration`` exception.  Iterators don't have to be finite,
+though; it's perfectly reasonable to write an iterator that produces an infinite
+stream of data.
 
 The built-in :func:`iter` function takes an arbitrary object and tries to return
 an iterator that will return the object's contents or elements, raising
@@ -203,13 +203,13 @@ You can experiment with the iteration interface manually:
     >>> it = iter(L)
     >>> it
     <...iterator object at ...>
-    >>> it.next()
+    >>> it.__next__()
     1
-    >>> it.next()
+    >>> next(it)
     2
-    >>> it.next()
+    >>> next(it)
     3
-    >>> it.next()
+    >>> next(it)
     Traceback (most recent call last):
       File "<stdin>", line 1, in ?
     StopIteration
@@ -467,20 +467,20 @@ the ``yield`` expression, the generator outputs the value of ``i``, similar to a
 ``return`` statement.  The big difference between ``yield`` and a ``return``
 statement is that on reaching a ``yield`` the generator's state of execution is
 suspended and local variables are preserved.  On the next call to the
-generator's ``.next()`` method, the function will resume executing.
+generator's ``.__next__()`` method, the function will resume executing.
 
 Here's a sample usage of the ``generate_ints()`` generator:
 
     >>> gen = generate_ints(3)
     >>> gen
     <generator object at ...>
-    >>> gen.next()
+    >>> next(gen)
     0
-    >>> gen.next()
+    >>> next(gen)
     1
-    >>> gen.next()
+    >>> next(gen)
     2
-    >>> gen.next()
+    >>> next(gen)
     Traceback (most recent call last):
       File "stdin", line 1, in ?
       File "stdin", line 2, in generate_ints
@@ -500,7 +500,7 @@ the bottom of the function.
 You could achieve the effect of generators manually by writing your own class
 and storing all the local variables of the generator as instance variables.  For
 example, returning a list of integers could be done by setting ``self.count`` to
-0, and having the ``next()`` method increment ``self.count`` and return it.
+0, and having the ``__next__()`` method increment ``self.count`` and return it.
 However, for a moderately complicated generator, writing a corresponding class
 can be much messier.
 
@@ -555,7 +555,7 @@ but have to use parentheses when there's an operation, as in ``val = (yield i)
 
 Values are sent into a generator by calling its ``send(value)`` method.  This
 method resumes the generator's code and the ``yield`` expression returns the
-specified value.  If the regular ``next()`` method is called, the ``yield``
+specified value.  If the regular ``__next__()`` method is called, the ``yield``
 returns ``None``.
 
 Here's a simple counter that increments by 1 and allows changing the value of
@@ -576,15 +576,15 @@ the internal counter.
 And here's an example of changing the counter:
 
     >>> it = counter(10)
-    >>> it.next()
+    >>> next(it)
     0
-    >>> it.next()
+    >>> next(it)
     1
     >>> it.send(8)
     8
-    >>> it.next()
+    >>> next(it)
     9
-    >>> it.next()
+    >>> next(it)
     Traceback (most recent call last):
       File ``t.py'', line 15, in ?
         it.next()
diff --git a/Doc/reference/expressions.rst b/Doc/reference/expressions.rst
@@ -375,8 +375,8 @@ generator function:
 
    Starts the execution of a generator function or resumes it at the last
    executed :keyword:`yield` expression.  When a generator function is resumed
-   with a :meth:`next` method, the current :keyword:`yield` expression always
-   evaluates to :const:`None`.  The execution then continues to the next
+   with a :meth:`__next__` method, the current :keyword:`yield` expression
+   always evaluates to :const:`None`.  The execution then continues to the next
    :keyword:`yield` expression, where the generator is suspended again, and the
    value of the :token:`expression_list` is returned to :meth:`next`'s caller.
    If the generator exits without yielding another value, a :exc:`StopIteration`
