Remove inefficient push and pop operations (and benchmarks for them).

Author: Andrei Constantinescu

bench/PriorityQueues.bench.mo

@@ -192,32 +192,6 @@ module {
             }
           }
         ),
-        (
-          "A2) PriorityQueue better push",
-          func(ops : [PriorityQueueUpdateOperation<Nat>]) {
-            let priorityQueue = PriorityQueue.empty<Nat>();
-            for (op in ops.values()) {
-              switch (op) {
-                case (#Push element) PriorityQueue.pushBetter(priorityQueue, Nat.compare, element);
-                case (#Pop) ignore PriorityQueue.pop(priorityQueue, Nat.compare);
-                case (#Clear) PriorityQueue.clear(priorityQueue)
-              }
-            }
-          }
-        ),
-        (
-          "A3) PriorityQueue better push, better pop",
-          func(ops : [PriorityQueueUpdateOperation<Nat>]) {
-            let priorityQueue = PriorityQueue.empty<Nat>();
-            for (op in ops.values()) {
-              switch (op) {
-                case (#Push element) PriorityQueue.pushBetter(priorityQueue, Nat.compare, element);
-                case (#Pop) ignore PriorityQueue.popBetter(priorityQueue, Nat.compare);
-                case (#Clear) PriorityQueue.clear(priorityQueue)
-              }
-            }
-          }
-        ),
         (
           "B) PriorityQueueSet",
           func(ops : [PriorityQueueUpdateOperation<Nat>]) {

src/PriorityQueue.mo

@@ -133,27 +133,6 @@ module {
     priorityQueue : PriorityQueue<T>,
     compare : (T, T) -> Order.Order,
     element : T
-  ) {
-    let heap = priorityQueue.heap;
-    List.add(heap, element);
-    var index = List.size(heap) - 1;
-    while (index > 0) {
-      switch (compare(List.at(heap, index), List.at(heap, (index - 1) / 2))) {
-        case (#greater) {
-          swapHeapElements(heap, index, (index - 1) / 2);
-          index := (index - 1) / 2
-        };
-        case _ return
-      }
-    }
-  };
-
-  // Optimized version.
-  // Main optimization is using the hole technique to avoid copies.
-  public func pushBetter<T>(
-    priorityQueue : PriorityQueue<T>,
-    compare : (T, T) -> Order.Order,
-    element : T
   ) {
     let heap = priorityQueue.heap;
     List.add(heap, element);
@@ -206,39 +185,6 @@ module {
   public func pop<T>(
     priorityQueue : PriorityQueue<T>,
     compare : (T, T) -> Order.Order
-  ) : ?T {
-    let heap = priorityQueue.heap;
-    if (List.isEmpty(heap)) {
-      return null
-    };
-    let lastIndex = List.size(heap) - 1;
-    swapHeapElements(heap, 0, lastIndex);
-    var index = 0;
-    loop {
-      var best = index;
-      let left = 2 * index + 1;
-      if (left < lastIndex and compare(List.at(heap, left), List.at(heap, best)) == #greater) {
-        best := left
-      };
-      let right = left + 1;
-      if (right < lastIndex and compare(List.at(heap, right), List.at(heap, best)) == #greater) {
-        best := right
-      };
-      if (best == index) {
-        return List.removeLast(heap)
-      };
-      swapHeapElements(heap, index, best);
-      index := best
-    }
-  };
-
-  // Optimized version.
-  // Main optimization is using the hole technique to avoid copies.
-  // N.B.: the control flow could be slightly optimized further, but the difference in speed
-  // is minimal while the impact on readability would be significant.
-  public func popBetter<T>(
-    priorityQueue : PriorityQueue<T>,
-    compare : (T, T) -> Order.Order
   ) : ?T {
     let heap = priorityQueue.heap;
     if (List.isEmpty(heap)) {
@@ -276,13 +222,5 @@ module {
       List.put(heap, index, bestElem);
       index := best
     }
-  };
-
-  /// Swaps two elements in the heap at the given indices.
-  /// Internal helper function.
-  func swapHeapElements<T>(heap : Types.List<T>, id1 : Nat, id2 : Nat) {
-    let aux = List.at(heap, id1);
-    List.put(heap, id1, List.at(heap, id2));
-    List.put(heap, id2, aux)
   }
 }

validation/api/api.lock.json

@@ -913,10 +913,8 @@
       "public func isEmpty<T>(priorityQueue : PriorityQueue<T>) : Bool",
       "public func peek<T>(priorityQueue : PriorityQueue<T>) : ?T",
       "public func pop<T>( priorityQueue : PriorityQueue<T>, compare : (T, T) -> Order.Order ) : ?T",
-      "public func popBetter<T>( priorityQueue : PriorityQueue<T>, compare : (T, T) -> Order.Order ) : ?T",
       "public type PriorityQueue<T>",
       "public func push<T>( priorityQueue : PriorityQueue<T>, compare : (T, T) -> Order.Order, element : T )",
-      "public func pushBetter<T>( priorityQueue : PriorityQueue<T>, compare : (T, T) -> Order.Order, element : T )",
       "public func singleton<T>(element : T) : PriorityQueue<T>",
       "public func size<T>(priorityQueue : PriorityQueue<T>) : Nat"
     ]