Removing redundant internal functions

Author: ejmount

src/k_smallest.rs

@@ -1,8 +1,8 @@
 use alloc::vec::IntoIter;
-use core::cmp::{Ord, Ordering, Reverse};
+use core::cmp::{Ordering, Reverse};
 
 /// Consumes a given iterator, returning the minimum elements in **ascending** order.
-fn k_smallest_general<T, I: Iterator<Item = T>>(
+pub(crate) fn k_smallest_general<T, I: Iterator<Item = T>>(
     mut iter: I,
     k: usize,
     mut comparator: impl FnMut(&T, &T) -> Ordering,
@@ -57,36 +57,6 @@ where
     move |a| Reverse(f(a))
 }
 
-pub(crate) fn k_smallest<T, I>(iter: I, k: usize) -> IntoIter<T>
-where
-    T: Ord,
-    I: Iterator<Item = T>,
-{
-    k_smallest_general(iter, k, T::cmp)
-}
-
-pub(crate) fn k_smallest_by<T, I, F>(iter: I, k: usize, cmp: F) -> IntoIter<T>
-where
-    I: Iterator<Item = T>,
-    F: Fn(&T, &T) -> Ordering,
-{
-    k_smallest_general(iter, k, cmp)
-}
-
-pub(crate) fn k_smallest_by_key<T, I, F, K>(iter: I, k: usize, key: F) -> IntoIter<T>
-where
-    I: Iterator<Item = T>,
-    F: Fn(&T) -> K,
-    K: Ord,
-{
-    let iter = iter.map(|v| (key(&v), v));
-
-    let results: Vec<_> = k_smallest_general(iter, k, |(k, _), (l, _)| k.cmp(&l))
-        .map(|(_, t)| t)
-        .collect();
-    results.into_iter()
-}
-
 /// Sift the element currently at `origin` **away** from the root until it is properly ordered
 fn sift_down<T>(
     heap: &mut [T],

src/lib.rs

@@ -2737,7 +2737,7 @@ pub trait Itertools : Iterator {
         Self: Sized,
         Self::Item: Ord,
     {
-        crate::k_smallest::k_smallest(self, k)
+        crate::k_smallest::k_smallest_general(self, k, Self::Item::cmp)
     }
 
     /// Sort the k smallest elements into a new iterator using the provided comparison.
@@ -2751,7 +2751,7 @@ pub trait Itertools : Iterator {
         Self: Sized,
         F: Fn(&Self::Item, &Self::Item) -> Ordering,
     {
-        crate::k_smallest::k_smallest_by(self, k, cmp)
+        crate::k_smallest::k_smallest_general(self, k, cmp)
     }
 
     /// Return the elements producing the k smallest outputs of the provided function
@@ -2766,7 +2766,13 @@ pub trait Itertools : Iterator {
         F: Fn(&Self::Item) -> K,
         K: Ord,
     {
-        crate::k_smallest::k_smallest_by_key(self, k, key)
+        let iter = self.map(|v| (key(&v), v));
+
+        let results: Vec<_> =
+            crate::k_smallest::k_smallest_general(iter, k, |(k, _), (l, _)| k.cmp(&l))
+                .map(|(_, t)| t)
+                .collect();
+        results.into_iter()
     }
 
     /// Sort the k largest elements into a new iterator, in descending order.
@@ -2789,7 +2795,7 @@ pub trait Itertools : Iterator {
         Self: Sized,
         Self::Item: Ord,
     {
-        crate::k_smallest::k_smallest_by(self, k, k_smallest::reverse_cmp(Self::Item::cmp))
+        self.k_smallest_by(k, k_smallest::reverse_cmp(Self::Item::cmp))
     }
 
     /// Sort the k largest elements into a new iterator using the provided comparison.
@@ -2800,7 +2806,7 @@ pub trait Itertools : Iterator {
         Self: Sized,
         F: Fn(&Self::Item, &Self::Item) -> Ordering,
     {
-        crate::k_smallest::k_smallest_by(self, k, k_smallest::reverse_cmp(cmp))
+        self.k_smallest_by(k, k_smallest::reverse_cmp(cmp))
     }
 
     /// Return the elements producing the k largest outputs of the provided function
@@ -2812,7 +2818,7 @@ pub trait Itertools : Iterator {
         K: Ord,
     {
         let key = crate::k_smallest::reverse_key(key);
-        crate::k_smallest::k_smallest_by_key(self, k, key)
+        self.k_smallest_by_key(k, key)
     }
 
     /// Collect all iterator elements into one of two