Update from Brian.

pep-3148.txt

@@ -118,14 +118,14 @@ asynchronously.
 
 ``map(func, *iterables, timeout=None)``
 
-    Equivalent to ``map(func, *iterables)`` but executed
+    Equivalent to ``map(func, *iterables)`` but func is executed 
-    asynchronously and possibly out-of-order.  The returned iterator
+    asynchronously and several calls to func may be made concurrently.
-    raises a `TimeoutError` if `__next__()` is called and the result
+    The returned iterator raises a `TimeoutError` if `__next__()` is
-    isn't available after *timeout* seconds from the original call to
+    called and the result isn't available after *timeout* seconds from
-    `map()`.  If *timeout* is not specified or `None` then there is no
+    the original call to `map()`.  If *timeout* is not specified or
-    limit to the wait time.  If a call raises an exception then that
+    `None` then there is no limit to the wait time.  If a call raises
-    exception will be raised when its value is retrieved from the
+    an exception then that exception will be raised when its value is
-    iterator.
+    retrieved from the iterator.
 
 ``shutdown(wait=True)``
 
@@ -364,7 +364,7 @@ threads, processes or remote procedure call.
 
 Futures are created by concrete implementations of the Executor class
 (called ExecutorService in Java).  The reference implementation
-provides classes that use either a process a thread pool to eagerly
+provides classes that use either a process or a thread pool to eagerly
 evaluate computations.
 
 Futures have already been seen in Python as part of a popular Python