remove traces of .next
diff --git a/Doc/howto/functional.rst b/Doc/howto/functional.rst
index c71d038..3ba5e8b 100644
--- a/Doc/howto/functional.rst
+++ b/Doc/howto/functional.rst
@@ -184,11 +184,11 @@
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 @@
>>> 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 @@
``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 @@
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 @@
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 @@
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()