Index: Doc/reference/simple_stmts.rst
===================================================================
--- Doc/reference/simple_stmts.rst	(revision 59312)
+++ Doc/reference/simple_stmts.rst	(working copy)
@@ -426,7 +426,7 @@
 If no expressions are present, :keyword:`raise` re-raises the last exception
 that was active in the current scope.  If no exception is active in the current
 scope, a :exc:`TypeError` exception is raised indicating that this is an error
-(if running under IDLE, a :exc:`Queue.Empty` exception is raised instead).
+(if running under IDLE, a :exc:`queue.Empty` exception is raised instead).
 
 Otherwise, :keyword:`raise` evaluates the first expression as the exception
 object.  It must be either a subclass or an instance of :class:`BaseException`.
@@ -773,4 +773,3 @@
 .. [#] It may occur within an :keyword:`except` or :keyword:`else` clause.  The
    restriction on occurring in the :keyword:`try` clause is implementor's laziness
    and will eventually be lifted.
-
Index: Doc/tutorial/stdlib2.rst
===================================================================
--- Doc/tutorial/stdlib2.rst	(revision 59312)
+++ Doc/tutorial/stdlib2.rst	(working copy)
@@ -196,7 +196,7 @@
 While those tools are powerful, minor design errors can result in problems that
 are difficult to reproduce.  So, the preferred approach to task coordination is
 to concentrate all access to a resource in a single thread and then use the
-:mod:`Queue` module to feed that thread with requests from other threads.
+:mod:`queue` module to feed that thread with requests from other threads.
 Applications using :class:`Queue` objects for inter-thread communication and
 coordination are easier to design, more readable, and more reliable.
 
Index: Doc/library/queue.rst
===================================================================
--- Doc/library/queue.rst	(revision 59312)
+++ Doc/library/queue.rst	(working copy)
@@ -1,19 +1,19 @@
 
-:mod:`Queue` --- A synchronized queue class
+:mod:`queue` --- A synchronized queue class
 ===========================================
 
-.. module:: Queue
+.. module:: queue
    :synopsis: A synchronized queue class.
 
 
-The :mod:`Queue` module implements a multi-producer, multi-consumer FIFO queue.
+The :mod:`queue` module implements a multi-producer, multi-consumer FIFO queue.
 It is especially useful in threaded programming when information must be
 exchanged safely between multiple threads.  The :class:`Queue` class in this
 module implements all the required locking semantics.  It depends on the
 availability of thread support in Python; see the :mod:`threading`
 module.
 
-The :mod:`Queue` module defines the following class and exception:
+The :mod:`queue` module defines the following class and exception:
 
 
 .. class:: Queue(maxsize)
Index: Doc/library/threading.rst
===================================================================
--- Doc/library/threading.rst	(revision 59312)
+++ Doc/library/threading.rst	(working copy)
@@ -8,7 +8,7 @@
 
 This module constructs higher-level threading interfaces on top of the  lower
 level :mod:`thread` module.
-See also the :mod:`mutex` and :mod:`Queue` modules.
+See also the :mod:`mutex` and :mod:`queue` modules.
 
 The :mod:`dummy_threading` module is provided for situations where
 :mod:`threading` cannot be used because :mod:`thread` is missing.