Simplifying bounds/usings

Author: ejmount

src/k_smallest.rs

@@ -1,6 +1,7 @@
+use alloc::vec::IntoIter;
 use core::cmp::{Ord, Ordering, Reverse};
 use core::mem::{replace, transmute, MaybeUninit};
-use alloc::vec::IntoIter;
+
 
 fn k_smallest_dynamic<T, I: Iterator<Item = T>>(
     iter: I,
@@ -29,10 +30,11 @@ where
     move |a| Reverse(f(a))
 }
 
-pub(crate) fn k_smallest<T: Ord, I: Iterator<Item = T>>(
-    iter: I,
-    k: usize,
-) -> IntoIter<T> {
+pub(crate) fn k_smallest<T, I>(iter: I, k: usize) -> IntoIter<T>
+where
+    T: Ord,
+    I: Iterator<Item = T>,
+{
     k_smallest_dynamic(iter, k, T::cmp)
 }
 
@@ -87,9 +89,9 @@ struct MaxHeap<'a, T, C> {
     len: usize,
 }
 
-impl<'a, A, C> Extend<A> for MaxHeap<'a, A, C>
+impl<'a, T, C> MaxHeap<'a, T, C>
 where
-    C: Fn(&A, &A) -> Ordering,
+    C: Fn(&T, &T) -> Ordering,
 {
     fn extend<T: IntoIterator<Item = A>>(&mut self, iter: T) {
         let mut iter = iter.into_iter();
@@ -140,10 +142,7 @@ impl<'a, T, C> MaxHeap<'a, T, C> {
     }
 
     /// Sift the element currently at `origin` **away** from the root until it is properly ordered
-    fn sift_down(&mut self, origin: usize)
-    where
-        C: Fn(&T, &T) -> Ordering,
-    {
+    fn sift_down(&mut self, origin: usize) {
         fn children_of(n: usize) -> (usize, usize) {
             (2 * n, 2 * n + 1)
         }
@@ -172,13 +171,7 @@ impl<'a, T, C> MaxHeap<'a, T, C> {
 
     /// Insert the given element into the heap without changing its size
     /// The displaced element is returned, i.e. either the input or previous max
-    fn push_pop(&mut self, val: T) -> Option<T>
-    where
-        C: Fn(&T, &T) -> Ordering,
-    {
-        if self.storage.is_empty() {
-            Some(val)
-        } else if self.compare(self.get(0), Some(&val)) == Some(Ordering::Greater) {
+    fn push_pop(&mut self, val: T) -> Option<T> {
             let out = replace(&mut self.storage[0], MaybeUninit::new(val));
             self.sift_down(0);
             // SAFETY: This has been moved out of storage[0]
@@ -192,20 +185,14 @@ impl<'a, T, C> MaxHeap<'a, T, C> {
     }
 
     /// Establishes the heap property from an arbitrary order
-    fn heapify(&mut self)
-    where
-        C: Fn(&T, &T) -> Ordering,
-    {
+    fn heapify(&mut self) {
         for i in (0..(self.len / 2 + 1)).rev() {
             self.sift_down(i);
         }
     }
 
     /// Lift the comparator through Option so we don't need to do as much bounds checking inside `sift_down`
-    fn compare(&self, a: Option<&T>, b: Option<&T>) -> Option<Ordering>
-    where
-        C: Fn(&T, &T) -> Ordering,
-    {
+    fn compare(&self, a: Option<&T>, b: Option<&T>) -> Option<Ordering> {
         (self.comparator)(a?, b?).into()
     }