#4206: fix 2.xisms in multiprocessing docs and docstrings.

diff --git a/Doc/library/multiprocessing.rst b/Doc/library/multiprocessing.rst
index 5cfd42e9ffea56ac496b16ad46eb539c47936b2b..e15ff4d4d6d617fab531acf36330f2292c65cec9 100644 (file)
--- a/Doc/library/multiprocessing.rst
+++ b/Doc/library/multiprocessing.rst
@@ -1447,8 +1447,8 @@ with the :class:`Pool` class.
 
    .. method:: map(func, iterable[, chunksize])
 
-      A parallel equivalent of the :func:`map` builtin function.  It blocks till
-      the result is ready.
+      A parallel equivalent of the :func:`map` builtin function, collecting the
+      result in a list.  It blocks till the whole result is ready.
 
       This method chops the iterable into a number of chunks which it submits to
       the process pool as separate tasks.  The (approximate) size of these
@@ -1465,7 +1465,7 @@ with the :class:`Pool` class.
 
    .. method:: imap(func, iterable[, chunksize])
 
-      An lazier version of :meth:`map`.
+      A lazier version of :meth:`map`.
 
       The *chunksize* argument is the same as the one used by the :meth:`.map`
       method.  For very long iterables using a large value for *chunksize* can

diff --git a/Lib/multiprocessing/pool.py b/Lib/multiprocessing/pool.py
index 90fd178e63b1a4d9465ecc5978b2f3f314c630f6..bf2608d127f5c5b46a6b8bd490b34c2d94df0d3f 100644 (file)
--- a/Lib/multiprocessing/pool.py
+++ b/Lib/multiprocessing/pool.py
@@ -76,7 +76,7 @@ def worker(inqueue, outqueue, initializer=None, initargs=()):
 
 class Pool(object):
     '''
-    Class which supports an async version of the `apply()` builtin
+    Class which supports an async version of applying functions to arguments.
     '''
     Process = Process
 
@@ -135,21 +135,22 @@ class Pool(object):
 
     def apply(self, func, args=(), kwds={}):
         '''
-        Equivalent of `apply()` builtin
+        Equivalent of `func(*args, **kwds)`.
         '''
         assert self._state == RUN
         return self.apply_async(func, args, kwds).get()
 
     def map(self, func, iterable, chunksize=None):
         '''
-        Equivalent of `map()` builtin
+        Apply `func` to each element in `iterable`, collecting the results
+        in a list that is returned.
         '''
         assert self._state == RUN
         return self.map_async(func, iterable, chunksize).get()
 
     def imap(self, func, iterable, chunksize=1):
         '''
-        Equivalent of `itertool.imap()` -- can be MUCH slower than `Pool.map()`
+        Equivalent of `map()` -- can be MUCH slower than `Pool.map()`.
         '''
         assert self._state == RUN
         if chunksize == 1:
@@ -167,7 +168,7 @@ class Pool(object):
 
     def imap_unordered(self, func, iterable, chunksize=1):
         '''
-        Like `imap()` method but ordering of results is arbitrary
+        Like `imap()` method but ordering of results is arbitrary.
         '''
         assert self._state == RUN
         if chunksize == 1:
@@ -185,7 +186,7 @@ class Pool(object):
 
     def apply_async(self, func, args=(), kwds={}, callback=None):
         '''
-        Asynchronous equivalent of `apply()` builtin
+        Asynchronous version of `apply()` method.
         '''
         assert self._state == RUN
         result = ApplyResult(self._cache, callback)
@@ -194,7 +195,7 @@ class Pool(object):
 
     def map_async(self, func, iterable, chunksize=None, callback=None):
         '''
-        Asynchronous equivalent of `map()` builtin
+        Asynchronous version of `map()` method.
         '''
         assert self._state == RUN
         if not hasattr(iterable, '__len__'):