Style changes, moving inner function

Author: ejmount

src/k_smallest.rs

@@ -2,11 +2,43 @@ use alloc::vec::Vec;
 use core::cmp::{Ordering, Reverse};
 
 /// Consumes a given iterator, returning the minimum elements in **ascending** order.
-pub(crate) fn k_smallest_general<I: Iterator, F: FnMut(&I::Item, &I::Item) -> Ordering>(
-    mut iter: I,
-    k: usize,
-    mut comparator: F,
-) -> Vec<I::Item> {
+pub(crate) fn k_smallest_general<I, F>(mut iter: I, k: usize, mut comparator: F) -> Vec<I::Item>
+where
+    I: Iterator,
+    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)
+    where
+        F: FnMut(&T, &T) -> Ordering,
+    {
+        fn children_of(n: usize) -> (usize, usize) {
+            (2 * n + 1, 2 * n + 2)
+        }
+
+        while origin < heap.len() {
+            let (left_idx, right_idx) = children_of(origin);
+            if left_idx >= heap.len() {
+                return;
+            }
+
+            let replacement_idx = if right_idx < heap.len()
+                && Ordering::Less == comparator(&heap[left_idx], &heap[right_idx])
+            {
+                right_idx
+            } else {
+                left_idx
+            };
+
+            if Ordering::Less == comparator(&heap[origin], &heap[replacement_idx]) {
+                heap.swap(origin, replacement_idx);
+                origin = replacement_idx;
+            } else {
+                return;
+            }
+        }
+    }
+
     if k == 0 {
         return Vec::new();
     }
@@ -59,36 +91,3 @@ where
 {
     move |a| Reverse(f(a))
 }
-
-/// Sift the element currently at `origin` **away** from the root until it is properly ordered
-fn sift_down<T, F: FnMut(&T, &T) -> Ordering>(
-    heap: &mut [T],
-    comparator: &mut F,
-    mut origin: usize,
-) {
-    fn children_of(n: usize) -> (usize, usize) {
-        (2 * n + 1, 2 * n + 2)
-    }
-
-    while origin < heap.len() {
-        let (left_idx, right_idx) = children_of(origin);
-        if left_idx >= heap.len() {
-            return;
-        }
-
-        let replacement_idx = if right_idx < heap.len()
-            && Ordering::Less == comparator(&heap[left_idx], &heap[right_idx])
-        {
-            right_idx
-        } else {
-            left_idx
-        };
-
-        if Ordering::Less == comparator(&heap[origin], &heap[replacement_idx]) {
-            heap.swap(origin, replacement_idx);
-            origin = replacement_idx;
-        } else {
-            return;
-        }
-    }
-}