diff --git a/Doc/lib/libcontextlib.tex b/Doc/lib/libcontextlib.tex
index 2a9eb0e..f212174 100644
--- a/Doc/lib/libcontextlib.tex
+++ b/Doc/lib/libcontextlib.tex
@@ -11,18 +11,19 @@
 
 Functions provided:
 
-\begin{funcdesc}{contextmanager}{func}
-This function is a decorator that can be used to define context managers
-for use with the \keyword{with} statement, without needing to create a
-class or separate \method{__enter__()} and \method{__exit__()} methods.
+\begin{funcdesc}{context}func}
+This function is a decorator that can be used to define a factory
+function for \keyword{with} statement context objects, without
+needing to create a class or separate \method{__enter__()} and
+\method{__exit__()} methods.
 
 A simple example:
 
 \begin{verbatim}
 from __future__ import with_statement
-from contextlib import contextmanager
+from contextlib import contextfactory
 
-@contextmanager
+@contextfactory
 def tag(name):
     print "<%s>" % name
     yield
@@ -36,9 +37,10 @@
 </h1>
 \end{verbatim}
 
-When called, the decorated function must return a generator-iterator.
-This iterator must yield exactly one value, which will be bound to the
-targets in the \keyword{with} statement's \keyword{as} clause, if any.
+The function being decorated must return a generator-iterator when
+called. This iterator must yield exactly one value, which will be
+bound to the targets in the \keyword{with} statement's \keyword{as}
+clause, if any.
 
 At the point where the generator yields, the block nested in the
 \keyword{with} statement is executed.  The generator is then resumed
@@ -53,20 +55,20 @@
 treat the exception as having been handled, and resume execution with
 the statement immediately following the \keyword{with} statement.
 
-Note that you can use \code{@contextmanager} to define a context
-specifier's \method{__context__} method.  This is usually more
+Note that you can use \code{@contextfactory} to define a context
+manager's \method{__context__} method.  This is usually more
 convenient than creating another class just to serve as a context
-manager. For example:
+object. For example:
 
 \begin{verbatim}
 from __future__ import with_statement
-from contextlib import contextmanager
+from contextlib import contextfactory
 
 class Tag:
     def __init__(self, name):
         self.name = name
         
-    @contextmanager
+    @contextfactory
     def __context__(self):
         print "<%s>" % self.name
         yield self
@@ -83,7 +85,7 @@
 \end{funcdesc}
 
 \begin{funcdesc}{nested}{ctx1\optional{, ctx2\optional{, ...}}}
-Combine multiple context specifiers into a single nested context manager.
+Combine multiple context managers into a single nested context manager.
 
 Code like this:
 
@@ -104,12 +106,12 @@
 \end{verbatim}
 
 Note that if the \method{__exit__()} method of one of the nested
-context managers indicates an exception should be suppressed, no
+context objects indicates an exception should be suppressed, no
 exception information will be passed to any remaining outer context
-managers. Similarly, if the \method{__exit__()} method of one of the
-nested context managers raises an exception, any previous exception
+objects. Similarly, if the \method{__exit__()} method of one of the
+nested context objects raises an exception, any previous exception
 state will be lost; the new exception will be passed to the
-\method{__exit__()} methods of any remaining outer context managers.
+\method{__exit__()} methods of any remaining outer context objects.
 In general, \method{__exit__()} methods should avoid raising
 exceptions, and in particular they should not re-raise a
 passed-in exception.
@@ -117,13 +119,13 @@
 
 \label{context-closing}
 \begin{funcdesc}{closing}{thing}
-Return a context manager that closes \var{thing} upon completion of the
+Return a context that closes \var{thing} upon completion of the
 block.  This is basically equivalent to:
 
 \begin{verbatim}
-from contextlib import contextmanager
+from contextlib import contextfactory
 
-@contextmanager
+@contextfactory
 def closing(thing):
     try:
         yield thing
@@ -137,14 +139,33 @@
 from contextlib import closing
 import codecs
 
-with closing(urllib.urlopen('http://www.python.org')) as f:
-    for line in f:
+with closing(urllib.urlopen('http://www.python.org')) as page:
+    for line in page:
         print line
 \end{verbatim}
 
-without needing to explicitly close \code{f}.  Even if an error occurs,
-\code{f.close()} will be called when the \keyword{with} block is exited.
+without needing to explicitly close \code{page}.  Even if an error
+occurs, \code{page.close()} will be called when the \keyword{with}
+block is exited.
 
+Context managers with a close method can use this context factory
+directly without needing to implement their own
+\method{__context__()} method.
+\begin{verbatim}
+from __future__ import with_statement
+from contextlib import closing
+
+class MyClass:
+    def close(self):
+        print "Closing", self
+    __context__ = closing
+
+>>> with MyClass() as x:
+...     print "Hello from", x
+...
+Hello from <__main__.MyClass instance at 0xb7df02ec>
+Closing <__main__.MyClass instance at 0xb7df02ec>
+\end{verbatim}
 \end{funcdesc}
 
 \begin{seealso}
diff --git a/Doc/lib/libstdtypes.tex b/Doc/lib/libstdtypes.tex
index ea950c8..50be0fa 100644
--- a/Doc/lib/libstdtypes.tex
+++ b/Doc/lib/libstdtypes.tex
@@ -1756,59 +1756,59 @@
 \subsection{Context Types \label{typecontext}}
 
 \versionadded{2.5}
-\index{context specification protocol}
+\index{with statement context protocol}
 \index{context management protocol}
-\index{protocol!context specification}
+\index{protocol!with statement context}
 \index{protocol!context management}
 
 Python's \keyword{with} statement supports the concept of a runtime
-context defined by a context specifier.  This is implemented using
+context defined by a context manager.  This is implemented using
 three distinct methods; these are used to allow user-defined
-classes to define a context.
+classes to define a runtime context.
 
-The \dfn{context specification protocol} consists of a single
-method that needs to be provided for a context specifier object to
+The \dfn{context management protocol} consists of a single
+method that needs to be provided for a context manager object to
 define a runtime context:
 
-\begin{methoddesc}[context specifier]{__context__}{}
-  Return a context manager object.  The object is required to support
-  the context management protocol described below.  If an object
-  supports different kinds of runtime context, additional methods can
-  be provided to specifically request context managers for those
-  kinds of context.  (An example of an object supporting multiple kinds
-  of context would be a synchronisation object which supported both
-  a locked context for normal thread synchronisation and an unlocked
-  context to temporarily release a held lock while performing a
-  potentially long running operation)
-\end{methoddesc}
-
-The context manager objects themselves are required to support the
-following three methods, which together form the
-\dfn{context management protocol}:
-
 \begin{methoddesc}[context manager]{__context__}{}
-  Return the context manager object itself.  This is required to
-  allow both context specifiers and context managers to be used with
-  the \keyword{with} statement.
+  Return a with statement context object.  The object is required to
+  support the with statement context protocol described below.  If an
+  object supports different kinds of runtime context, additional
+  methods can be provided to specifically request context objects for
+  those kinds of runtime context.  (An example of an object supporting
+  multiple kinds of context would be a synchronisation object which
+  supported both a locked context for normal thread synchronisation
+  and an unlocked context to temporarily release a held lock while
+  performing a potentially long running operation)
 \end{methoddesc}
 
-\begin{methoddesc}[context manager]{__enter__}{}
+The with statement context objects themselves are required to support the
+following three methods, which together form the
+\dfn{with statement context protocol}:
+
+\begin{methoddesc}[with statement context]{__context__}{}
+  Return the context object itself.  This is required to allow both
+  context objects and context managers to be used in a \keyword{with}
+  statement.
+\end{methoddesc}
+
+\begin{methoddesc}[with statement context]{__enter__}{}
   Enter the runtime context and return either the defining context
-  specifier or another object related to the runtime context. The value
+  manager or another object related to the runtime context. The value
   returned by this method is bound to the identifier in the
   \keyword{as} clause of \keyword{with} statements using this context.
-  (An example of a context with a context manager that returns the
-  original context specifier is file objects, which are returned from
-  __enter__() to allow \function{open()} to be used directly in a with
-  statement. An example of a context manager that returns a related
+  (An example of a context object that returns the original context
+  manager is file objects, which are returned from __enter__() to
+  allow \function{open()} to be used directly in a with
+  statement. An example of a context object that returns a related
   object is \code{decimal.Context} which sets the active decimal
-  context to a copy of the context specifier and then returns the copy
-  to allow changes to be made to the current decimal context in the
-  body of the \keyword{with} statement) without affecting code outside
+  context to a copy of the context manager and then returns the copy.
+  This allows changes to be made to the current decimal context in the
+  body of the \keyword{with} statement without affecting code outside
   the \keyword{with} statement).
 \end{methoddesc}
 
-\begin{methoddesc}[context manager]{__exit__}{exc_type, exc_val, exc_tb}
+\begin{methoddesc}[with statement context]{__exit__}{exc_type, exc_val, exc_tb}
   Exit the runtime context and return a Boolean flag indicating if any
   expection that occurred should be suppressed. If an exception
   occurred while executing the body of the \keyword{with} statement, the
@@ -1829,19 +1829,18 @@
   \method{__exit__()} method has actually failed.
 \end{methoddesc}
 
-Python defines several context specifiers and managers to support
+Python defines several context objects and managers to support
 easy thread synchronisation, prompt closure of files or other
 objects, and thread-safe manipulation of the decimal arithmetic
 context. The specific types are not important beyond their
-implementation of the context specification and context
-management protocols.
+implementation of the context management and with statement context
+protocols.
 
-Python's generators and the \code{contextlib.contextmanager}
-decorator provide a convenient way to implement the context
-specification and context management protocols.  If a context
-specifier's \method{__context__()} method is implemented as a
-generator decorated with the \code{contextlib.contextmanager}
-decorator, it will automatically return a context manager
+Python's generators and the \code{contextlib.contextfactory} decorator
+provide a convenient way to implement these protocols.  If a context
+manager's \method{__context__()} method is implemented as a
+generator decorated with the \code{contextlib.contextfactory}
+decorator, it will automatically return a with statement context
 object supplying the necessary \method{__context__()},
 \method{__enter__()} and \method{__exit__()} methods.