Trying to clarify comparator

Author: ejmount

src/k_smallest.rs

@@ -8,9 +8,9 @@ where
     F: FnMut(&I::Item, &I::Item) -> Ordering,
 {
     /// Sift the element currently at `origin` **away** from the root until it is properly ordered
-    fn sift_down<T, F>(heap: &mut [T], comparator: &mut F, mut origin: usize)
+    fn sift_down<T, F>(heap: &mut [T], is_less_than: &mut F, mut origin: usize)
     where
-        F: FnMut(&T, &T) -> Ordering,
+        F: FnMut(&T, &T) -> bool,
     {
         fn children_of(n: usize) -> (usize, usize) {
             (2 * n + 1, 2 * n + 2)
@@ -22,15 +22,14 @@ where
                 return;
             }
 
-            let replacement_idx = if right_idx < heap.len()
-                && Ordering::Less == comparator(&heap[left_idx], &heap[right_idx])
-            {
-                right_idx
-            } else {
-                left_idx
-            };
+            let replacement_idx =
+                if right_idx < heap.len() && is_less_than(&heap[left_idx], &heap[right_idx]) {
+                    right_idx
+                } else {
+                    left_idx
+                };
 
-            if Ordering::Less == comparator(&heap[origin], &heap[replacement_idx]) {
+            if is_less_than(&heap[origin], &heap[replacement_idx]) {
                 heap.swap(origin, replacement_idx);
                 origin = replacement_idx;
             } else {
@@ -44,22 +43,24 @@ where
     }
     let mut storage: Vec<I::Item> = iter.by_ref().take(k).collect();
 
+    let mut is_less_than = move |a: &_, b: &_| comparator(a, b) == Ordering::Less;
+
     // Rearrange the into a valid heap by reordering from the second-bottom-most layer up
     // Slightly faster than ordering on each insert, but only by a factor of lg(k)
     for i in (0..=(storage.len() / 2)).rev() {
-        sift_down(&mut storage, &mut comparator, i);
+        sift_down(&mut storage, &mut is_less_than, i);
     }
 
     if k == storage.len() {
         // If we fill the storage, there may still be iterator elements left
         // So feed them into the heap
         // Also avoids unexpected behaviour with restartable iterators
         iter.for_each(|val| {
-            if comparator(&val, &mut storage[0]) == Ordering::Less {
+            if is_less_than(&val, &mut storage[0]) {
                 // Treating this as an push-and-pop saves having to write a sift-up implementation
                 // https://en.wikipedia.org/wiki/Binary_heap#Insert_then_extract
                 storage[0] = val;
-                sift_down(&mut storage, &mut comparator, 0);
+                sift_down(&mut storage, &mut is_less_than, 0);
             }
         });
     }
@@ -72,7 +73,7 @@ where
         // Leaves the length shorter than the number of elements
         // so that sifting does not disturb already popped elements
         heap = &mut heap[..last_idx];
-        sift_down(heap, &mut comparator, 0);
+        sift_down(heap, &mut is_less_than, 0);
     }
 
     storage