DOCS-671 min-max edits

Author: kay-kim

source/faq/indexes.txt

@@ -122,8 +122,6 @@ criterion is part of the query.
 Can I use index keys to constrain query matches?
 ------------------------------------------------
 
-The :method:`min() <cursor.min()>` and the :method:`max()
-<cursor.max()>` methods provide a way to constrain the results of the
-:method:`find() <db.collection.find()>` method using index keys.
-
-
+You can use the :method:`min() <cursor.min()>` and the :method:`max()
+<cursor.max()>` methods to constrain the results of the cursor returned
+from :method:`find() <db.collection.find()>` by using the index keys.

source/reference/method/cursor.max.txt

@@ -8,11 +8,11 @@ cursor.max()
 
    The :method:`max() <cursor.max()>` method specifies the *exclusive*
    upper bound for a specific index in order to constrain the results
-   of the :method:`find() <db.collection.find()>` method. The
-   :method:`max() <cursor.max()>` method provides a way to specify an
-   upper bound on compound key indexes.
+   of :method:`find() <db.collection.find()>`. :method:`max()
+   <cursor.max()>` provides a way to specify an upper bound on compound
+   key indexes.
 
-   The :method:`max() <cursor.max()>` method takes the following parameter:
+   :method:`max() <cursor.max()>` takes the following parameter:
 
    :param document indexbounds:
 
@@ -31,8 +31,7 @@ cursor.max()
           fields with different sort orders, the selection of the index
           may be ambiguous.
 
-   Consider the following example of the :method:`max() <cursor.max()>`
-   method:
+   Consider the following examples of :method:`max() <cursor.max()>`:
 
    The examples assume a collection ``products`` with the following documents:
 
@@ -58,10 +57,10 @@ cursor.max()
       { "item" : 1, "type" : -1 }
       { "price" : 1 }
 
-   - Using the ordering of ``{ item: 1, type: 1 }`` index, the :method:`max()
-     <cursor.max()>` method limits the query to the documents that are
-     below the bound of ``item`` equal to ``apple`` and ``type`` equal
-     to ``jonagold``:
+   - Using the ordering of ``{ item: 1, type: 1 }`` index,
+     :method:`max() <cursor.max()>` limits the query to the documents
+     that are below the bound of ``item`` equal to ``apple`` and
+     ``type`` equal to ``jonagold``:
 
      .. code-block:: javascript
 
@@ -80,12 +79,12 @@ cursor.max()
      whether :program:`mongod` would select the ``{ item: 1, type: 1
      }`` index ordering or the ``{ item: 1, type: -1 }`` index ordering.
 
-   - Using the ordering of the index ``{ price: 1 }``, the :method:`max()
-     <cursor.max()>` method limits the query to the documents that are
-     below the index key bound of ``price`` equal to ``1.99`` and the
-     :method:`min() <cursor.min()>` method limits the query to the
-     documents that are at or above the index key bound of ``price``
-     equal to ``1.39``:
+   - Using the ordering of the index ``{ price: 1 }``, :method:`max()
+     <cursor.max()>` limits the query to the documents that are below
+     the index key bound of ``price`` equal to ``1.99`` and
+     :method:`min() <cursor.min()>` limits the query to the documents
+     that are at or above the index key bound of ``price`` equal to
+     ``1.39``:
 
      .. code-block:: javascript
 
@@ -103,10 +102,10 @@ cursor.max()
 
    .. note::
 
-      - Because the :method:`max() <cursor.max()>` method requires a
-        corresponding index as well as enforces the use of that index,
-        it may be preferable to use the :operator:`$lt` operator in the
-        query if possible. Consider the following example:
+      - Because :method:`max() <cursor.max()>` requires a corresponding
+        index as well as enforces the use of that index, it may be
+        preferable to use the :operator:`$lt` operator in the query if
+        possible. Consider the following example:
 
         .. code-block:: javascript
 
@@ -115,15 +114,14 @@ cursor.max()
         The query will use the index on the ``price`` field, even if
         the index on ``_id`` may be better.
 
-      - The :method:`max() <cursor.max()>` method exists primarily to
-        support the :program:`mongos` (sharding) process.
+      - :method:`max() <cursor.max()>` exists primarily to support the
+        :program:`mongos` (sharding) process.
 
-      - If you use :method:`max() <cursor.max()>` method with the
-        :method:`min() <cursor.min()>` method to specify a range, the
-        index bounds specified in :method:`min() <cursor.min()>` method
-        and the :method:`max() <cursor.max()>` method must both refer
-        to the keys of the same index.
+      - If you use :method:`max() <cursor.max()>` with :method:`min()
+        <cursor.min()>` to specify a range, the index bounds specified
+        in :method:`min() <cursor.min()>` and :method:`max()
+        <cursor.max()>` must both refer to the keys of the same index.
 
-      - The :method:`max() <cursor.max()>` method is a shell wrapper
-        around the special operator :operator:`$max`.
+      - :method:`max() <cursor.max()>` is a shell wrapper around the
+        special operator :operator:`$max`.
 

source/reference/method/cursor.min.txt

@@ -8,11 +8,11 @@ cursor.min()
 
    The :method:`min() <cursor.min()>` method specifies the *inclusive*
    lower bound for a specific index in order to constrain the results
-   of the :method:`find() <db.collection.find()>` method. The
-   :method:`min() <cursor.min()>` method provides a way to specify
-   lower bounds on compound key indexes.
+   of :method:`find() <db.collection.find()>`. :method:`min()
+   <cursor.min()>` provides a way to specify lower bounds on compound
+   key indexes.
 
-   The :method:`min() <cursor.min()>` method takes the following parameter:
+   :method:`min() <cursor.min()>` takes the following parameter:
 
    :param document indexbounds:
 
@@ -31,8 +31,7 @@ cursor.min()
           fields with different sort orders, the selection of the index
           may be ambiguous.
 
-   Consider the following examples of the :method:`min() <cursor.min()>`
-   method:
+   Consider the following examples of :method:`min() <cursor.min()>`:
 
    The examples assume a collection ``products`` with the following documents:
 
@@ -58,10 +57,10 @@ cursor.min()
       { "item" : 1, "type" : -1 }
       { "price" : 1 }
 
-   - Using the ordering of ``{ item: 1, type: 1 }`` index, the
-     :method:`min() <cursor.min()>` method limits the query to the
-     documents that are at or above the index key bound of ``item``
-     equal to ``apple`` and ``type`` equal to ``jonagold``:
+   - Using the ordering of ``{ item: 1, type: 1 }`` index,
+     :method:`min() <cursor.min()>` limits the query to the documents
+     that are at or above the index key bound of ``item`` equal to
+     ``apple`` and ``type`` equal to ``jonagold``:
 
      .. code-block:: javascript
 
@@ -85,12 +84,11 @@ cursor.min()
      whether :program:`mongod` would select the ``{ item: 1, type: 1
      }`` index ordering or the ``{ item: 1, type: -1 }`` index ordering.
 
-   - Using the ordering of the index ``{ price: 1 }``, the :method:`min()
-     <cursor.min()>` method limits the query to the documents that are
-     at or above the index key bound of ``price`` equal to ``1.39`` and
-     the :method:`max() <cursor.max()>` method limits the query to the
-     documents that are below the index key bound of ``price`` equal to
-     ``1.99``:
+   - Using the ordering of the index ``{ price: 1 }``, :method:`min()
+     <cursor.min()>` limits the query to the documents that are at or
+     above the index key bound of ``price`` equal to ``1.39`` and
+     :method:`max() <cursor.max()>` limits the query to the documents
+     that are below the index key bound of ``price`` equal to ``1.99``:
 
      .. code-block:: javascript
 
@@ -108,10 +106,10 @@ cursor.min()
 
    .. note::
 
-      - Because the :method:`min() <cursor.min()>` method requires a
-        corresponding index as well as enforces the use of that index,
-        it may be preferable to use the :operator:`$gte` operator in
-        the query if possible.  Consider the following example:
+      - Because :method:`min() <cursor.min()>` requires a corresponding
+        index as well as enforces the use of that index, it may be
+        preferable to use the :operator:`$gte` operator in the query if
+        possible. Consider the following example:
 
         .. code-block:: javascript
 
@@ -120,14 +118,13 @@ cursor.min()
         The query will use the index on the ``price`` field, even if
         the index on ``_id`` may be better.
 
-      - The :method:`min() <cursor.min()>` method exists primarily to
-        support the :program:`mongos` (sharding) process.
+      - :method:`min() <cursor.min()>` exists primarily to support the
+        :program:`mongos` (sharding) process.
 
-      - If you use :method:`min() <cursor.min()>` method with the
-        :method:`max() <cursor.max()>` method to specify a range, the
-        index bounds specified in :method:`min() <cursor.min()>` method
-        and the :method:`max() <cursor.max()>` method must both refer
-        to the keys of the same index.
+      - If you use :method:`min() <cursor.min()>` with :method:`max()
+        <cursor.max()>` to specify a range, the index bounds specified
+        in :method:`min() <cursor.min()>` and :method:`max()
+        <cursor.max()>` must both refer to the keys of the same index.
 
-      - The :method:`min() <cursor.min()>` method is a shell wrapper
-        around the special operator :operator:`$min`.
+      - :method:`min() <cursor.min()>` is a shell wrapper around the
+        special operator :operator:`$min`.