Benedikts suggestions

Author: StanFromIreland

Doc/library/heapq.rst

@@ -82,33 +82,40 @@ The following functions are provided:
    on the heap.
 
 
+.. function:: heapify_max(x)
+
+   Transform list *x* into a heap, in-place, in linear time.
+
+   .. versionadded:: next
+
+
 .. function:: heappush_max(heap, item)
 
    Push the value *item* onto the *heap*, maintaining the heap invariant.
 
+   .. versionadded:: next
 
 .. function:: heappop_max(heap)
 
    Pop and return the largest item from the *heap*, maintaining the heap
    invariant.  If the heap is empty, :exc:`IndexError` is raised.  To access the
    largest item without popping it, use ``heap[0]``.
 
+   .. versionadded:: next
+
 
 .. function:: heappushpop_max(heap, item)
 
    Push *item* on the heap, then pop and return the largest item from the
    *heap*.  The combined action runs more efficiently than :func:`heappush_max`
    followed by a separate call to :func:`heappop_max`.
 
-
-.. function:: heapify_max(x)
-
-   Transform list *x* into a max heap, in-place, in linear time.
+   .. versionadded:: next
 
 
-.. function:: heapreplace(heap, item)
+.. function:: heapreplace_max(heap, item)
 
-   Pop and return the smallest item from the *heap*, and also push the new *item*.
+   Pop and return the largest item from the *heap*, and also push the new *item*.
    The heap size doesn't change. If the heap is empty, :exc:`IndexError` is raised.
 
    This one step operation is more efficient than a :func:`heappop` followed by
@@ -121,6 +128,8 @@ The following functions are provided:
    combination returns the smaller of the two values, leaving the larger value
    on the heap.
 
+   .. versionadded:: next
+
 
 The module also offers three general purpose functions based on heaps.
 

Lib/heapq.py

@@ -213,6 +213,19 @@ def heapify_max(x):
     for i in reversed(range(n//2)):
         _siftup_max(x, i)
 
+# For backwards compadibility
+def _heappop_max(heap):
+    return heappop_max(heap)
+def _heapreplace_max(heap, item):
+    return heapreplace_max(heap, item)
+def _heappush_max(heap, item):
+    return _heappush_max(heap, item)
+def _heappushpop_max(heap, item):
+    return _heappushpop_max(heap, item)
+def _heapify_max(x):
+    return _heapify_max()
+
+
 # 'heap' is a heap at all indices >= startpos, except possibly for pos.  pos
 # is the index of a leaf with a possibly out-of-order value.  Restore the
 # heap invariant.