Take *two* entries in insert_sorted_by

Author: cuviper

src/map.rs

@@ -505,12 +505,12 @@ where
     /// pair is moved to or inserted at that position regardless.
     ///
     /// Computes in **O(n)** time (average).
-    pub fn insert_sorted_by<F>(&mut self, key: K, value: V, cmp: F) -> (usize, Option<V>)
+    pub fn insert_sorted_by<F>(&mut self, key: K, value: V, mut cmp: F) -> (usize, Option<V>)
     where
         K: Ord,
-        F: FnMut(&K, &V) -> Ordering,
+        F: FnMut(&K, &V, &K, &V) -> Ordering,
     {
-        let (Ok(i) | Err(i)) = self.binary_search_by(cmp);
+        let (Ok(i) | Err(i)) = self.binary_search_by(|k, v| cmp(k, v, &key, &value));
         self.insert_before(i, key, value)
     }
 

src/map/core/entry.rs

@@ -412,13 +412,13 @@ impl<'a, K, V> VacantEntry<'a, K, V> {
     /// pair is inserted at that position regardless.
     ///
     /// Computes in **O(n)** time (average).
-    pub fn insert_sorted_by<F>(self, value: V, cmp: F) -> (usize, &'a mut V)
+    pub fn insert_sorted_by<F>(self, value: V, mut cmp: F) -> (usize, &'a mut V)
     where
         K: Ord,
-        F: FnMut(&K, &V) -> Ordering,
+        F: FnMut(&K, &V, &K, &V) -> Ordering,
     {
         let slice = crate::map::Slice::from_slice(self.map.entries);
-        let (Ok(i) | Err(i)) = slice.binary_search_by(cmp);
+        let (Ok(i) | Err(i)) = slice.binary_search_by(|k, v| cmp(k, v, &self.key, &value));
         (i, self.shift_insert(i, value))
     }
 

src/map/tests.rs

@@ -1251,14 +1251,14 @@ fn insert_sorted_by() {
     let mut values = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)];
     let mut map: IndexMap<i32, i32> = IndexMap::new();
     for (key, value) in values {
-        let (_, old) = map.insert_sorted_by(key, value, |probe, _| key.cmp(probe));
+        let (_, old) = map.insert_sorted_by(key, value, |key1, _, key2, _| key2.cmp(key1));
         assert_eq!(old, None);
     }
     values.reverse();
     assert_eq!(values, *map.as_slice());
 
     for (key, value) in &mut values {
-        let (_, old) = map.insert_sorted_by(*key, -*value, |probe, _| (*key).cmp(probe));
+        let (_, old) = map.insert_sorted_by(*key, -*value, |key1, _, key2, _| key2.cmp(key1));
         assert_eq!(old, Some(*value));
         *value = -*value;
     }

src/set.rs

@@ -437,9 +437,11 @@ where
     pub fn insert_sorted_by<F>(&mut self, value: T, mut cmp: F) -> (usize, bool)
     where
         T: Ord,
-        F: FnMut(&T) -> Ordering,
+        F: FnMut(&T, &T) -> Ordering,
     {
-        let (index, existing) = self.map.insert_sorted_by(value, (), |k, _| cmp(k));
+        let (index, existing) = self
+            .map
+            .insert_sorted_by(value, (), |a, (), b, ()| cmp(a, b));
         (index, existing.is_none())
     }
 
@@ -938,7 +940,7 @@ impl<T, S> IndexSet<T, S> {
     where
         F: FnMut(&T, &T) -> Ordering,
     {
-        self.map.sort_by(move |a, _, b, _| cmp(a, b));
+        self.map.sort_by(move |a, (), b, ()| cmp(a, b));
     }
 
     /// Sort the values of the set and return a by-value iterator of

tests/quick.rs

@@ -136,11 +136,11 @@ quickcheck_limit! {
         let mut map2 = IndexMap::new();
         for &(key, value) in &insert {
             hmap.insert(key, value);
-            map.insert_sorted_by(key, value, |other, _| key.cmp(other));
+            map.insert_sorted_by(key, value, |key1, _, key2, _| key2.cmp(key1));
             match map2.entry(key) {
                 Entry::Occupied(e) => *e.into_mut() = value,
                 Entry::Vacant(e) => {
-                    e.insert_sorted_by(value, |other, _| key.cmp(other));
+                    e.insert_sorted_by(value, |key1, _, key2, _| key2.cmp(key1));
                 }
             }
         }