Merge pull request #211 from bhgomes/add-sort-unstable-methods

feat: add unstable sorting methods

Author: cuviper

src/map.rs

@@ -669,18 +669,18 @@ where
 
     /// Sort the map’s key-value pairs by the default ordering of the keys.
     ///
-    /// See `sort_by` for details.
+    /// See [`sort_by`](Self::sort_by) for details.
     pub fn sort_keys(&mut self)
     where
         K: Ord,
     {
-        self.with_entries(|entries| {
-            entries.sort_by(|a, b| Ord::cmp(&a.key, &b.key));
+        self.with_entries(move |entries| {
+            entries.sort_by(move |a, b| K::cmp(&a.key, &b.key));
         });
     }
 
     /// Sort the map’s key-value pairs in place using the comparison
-    /// function `compare`.
+    /// function `cmp`.
     ///
     /// The comparison function receives two key and value pairs to compare (you
     /// can sort by keys or values or their combination as needed).
@@ -696,7 +696,7 @@ where
         });
     }
 
-    /// Sort the key-value pairs of the map and return a by value iterator of
+    /// Sort the key-value pairs of the map and return a by-value iterator of
     /// the key-value pairs with the result.
     ///
     /// The sort is stable.
@@ -711,6 +711,52 @@ where
         }
     }
 
+    /// Sort the map's key-value pairs by the default ordering of the keys, but
+    /// may not preserve the order of equal elements.
+    ///
+    /// See [`sort_unstable_by`](Self::sort_unstable_by) for details.
+    pub fn sort_unstable_keys(&mut self)
+    where
+        K: Ord,
+    {
+        self.with_entries(move |entries| {
+            entries.sort_unstable_by(move |a, b| K::cmp(&a.key, &b.key));
+        });
+    }
+
+    /// Sort the map's key-value pairs in place using the comparison function `cmp`, but
+    /// may not preserve the order of equal elements.
+    ///
+    /// The comparison function receives two key and value pairs to compare (you
+    /// can sort by keys or values or their combination as needed).
+    ///
+    /// Computes in **O(n log n + c)** time where *n* is
+    /// the length of the map and *c* is the capacity. The sort is unstable.
+    pub fn sort_unstable_by<F>(&mut self, mut cmp: F)
+    where
+        F: FnMut(&K, &V, &K, &V) -> Ordering,
+    {
+        self.with_entries(move |entries| {
+            entries.sort_unstable_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
+        });
+    }
+
+    /// Sort the key-value pairs of the map and return a by-value iterator of
+    /// the key-value pairs with the result.
+    ///
+    /// The sort is unstable.
+    #[inline]
+    pub fn sorted_unstable_by<F>(self, mut cmp: F) -> IntoIter<K, V>
+    where
+        F: FnMut(&K, &V, &K, &V) -> Ordering,
+    {
+        let mut entries = self.into_entries();
+        entries.sort_unstable_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
+        IntoIter {
+            iter: entries.into_iter(),
+        }
+    }
+
     /// Reverses the order of the map’s key-value pairs in place.
     ///
     /// Computes in **O(n)** time and **O(1)** space.

src/rayon/map.rs

@@ -348,7 +348,7 @@ where
     }
 
     /// Sort the map’s key-value pairs in place and in parallel, using the comparison
-    /// function `compare`.
+    /// function `cmp`.
     ///
     /// The comparison function receives two key and value pairs to compare (you
     /// can sort by keys or values or their combination as needed).
@@ -361,7 +361,7 @@ where
         });
     }
 
-    /// Sort the key-value pairs of the map in parallel and return a by value parallel
+    /// Sort the key-value pairs of the map in parallel and return a by-value parallel
     /// iterator of the key-value pairs with the result.
     pub fn par_sorted_by<F>(self, cmp: F) -> IntoParIter<K, V>
     where
@@ -371,6 +371,41 @@ where
         entries.par_sort_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
         IntoParIter { entries }
     }
+
+    /// Sort the map's key-value pairs in parallel, by the default ordering of the keys.
+    pub fn par_sort_unstable_keys(&mut self)
+    where
+        K: Ord,
+    {
+        self.with_entries(|entries| {
+            entries.par_sort_unstable_by(|a, b| K::cmp(&a.key, &b.key));
+        });
+    }
+
+    /// Sort the map's key-value pairs in place and in parallel, using the comparison
+    /// function `cmp`.
+    ///
+    /// The comparison function receives two key and value pairs to compare (you
+    /// can sort by keys or values or their combination as needed).
+    pub fn par_sort_unstable_by<F>(&mut self, cmp: F)
+    where
+        F: Fn(&K, &V, &K, &V) -> Ordering + Sync,
+    {
+        self.with_entries(|entries| {
+            entries.par_sort_unstable_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
+        });
+    }
+
+    /// Sort the key-value pairs of the map in parallel and return a by-value parallel
+    /// iterator of the key-value pairs with the result.
+    pub fn par_sorted_unstable_by<F>(self, cmp: F) -> IntoParIter<K, V>
+    where
+        F: Fn(&K, &V, &K, &V) -> Ordering + Sync,
+    {
+        let mut entries = self.into_entries();
+        entries.par_sort_unstable_by(move |a, b| cmp(&a.key, &a.value, &b.key, &b.value));
+        IntoParIter { entries }
+    }
 }
 
 /// A parallel mutable iterator over the values of a `IndexMap`.

src/rayon/set.rs

@@ -489,7 +489,7 @@ where
         });
     }
 
-    /// Sort the set’s values in place and in parallel, using the comparison function `compare`.
+    /// Sort the set’s values in place and in parallel, using the comparison function `cmp`.
     pub fn par_sort_by<F>(&mut self, cmp: F)
     where
         F: Fn(&T, &T) -> Ordering + Sync,
@@ -499,7 +499,7 @@ where
         });
     }
 
-    /// Sort the values of the set in parallel and return a by value parallel iterator of
+    /// Sort the values of the set in parallel and return a by-value parallel iterator of
     /// the values with the result.
     pub fn par_sorted_by<F>(self, cmp: F) -> IntoParIter<T>
     where
@@ -509,6 +509,37 @@ where
         entries.par_sort_by(move |a, b| cmp(&a.key, &b.key));
         IntoParIter { entries }
     }
+
+    /// Sort the set's values in parallel by their default ordering.
+    pub fn par_sort_unstable(&mut self)
+    where
+        T: Ord,
+    {
+        self.with_entries(|entries| {
+            entries.par_sort_unstable_by(|a, b| T::cmp(&a.key, &b.key));
+        });
+    }
+
+    /// Sort the set’s values in place and in parallel, using the comparison function `cmp`.
+    pub fn par_sort_unstable_by<F>(&mut self, cmp: F)
+    where
+        F: Fn(&T, &T) -> Ordering + Sync,
+    {
+        self.with_entries(|entries| {
+            entries.par_sort_unstable_by(move |a, b| cmp(&a.key, &b.key));
+        });
+    }
+
+    /// Sort the values of the set in parallel and return a by-value parallel iterator of
+    /// the values with the result.
+    pub fn par_sorted_unstable_by<F>(self, cmp: F) -> IntoParIter<T>
+    where
+        F: Fn(&T, &T) -> Ordering + Sync,
+    {
+        let mut entries = self.into_entries();
+        entries.par_sort_unstable_by(move |a, b| cmp(&a.key, &b.key));
+        IntoParIter { entries }
+    }
 }
 
 /// Requires crate feature `"rayon"`.

src/set.rs

@@ -558,25 +558,25 @@ where
 
     /// Sort the set’s values by their default ordering.
     ///
-    /// See `sort_by` for details.
+    /// See [`sort_by`](Self::sort_by) for details.
     pub fn sort(&mut self)
     where
         T: Ord,
     {
         self.map.sort_keys()
     }
 
-    /// Sort the set’s values in place using the comparison function `compare`.
+    /// Sort the set’s values in place using the comparison function `cmp`.
     ///
     /// Computes in **O(n log n)** time and **O(n)** space. The sort is stable.
-    pub fn sort_by<F>(&mut self, mut compare: F)
+    pub fn sort_by<F>(&mut self, mut cmp: F)
     where
         F: FnMut(&T, &T) -> Ordering,
     {
-        self.map.sort_by(move |a, _, b, _| compare(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
+    /// Sort the values of the set and return a by-value iterator of
     /// the values with the result.
     ///
     /// The sort is stable.
@@ -585,7 +585,41 @@ where
         F: FnMut(&T, &T) -> Ordering,
     {
         IntoIter {
-            iter: self.map.sorted_by(move |a, &(), b, &()| cmp(a, b)).iter,
+            iter: self.map.sorted_by(move |a, _, b, _| cmp(a, b)).iter,
+        }
+    }
+
+    /// Sort the set's values by their default ordering.
+    ///
+    /// See [`sort_unstable_by`](Self::sort_unstable_by) for details.
+    pub fn sort_unstable(&mut self)
+    where
+        T: Ord,
+    {
+        self.map.sort_unstable_keys()
+    }
+
+    /// Sort the set's values in place using the comparison funtion `cmp`.
+    ///
+    /// Computes in **O(n log n)** time. The sort is unstable.
+    pub fn sort_unstable_by<F>(&mut self, mut cmp: F)
+    where
+        F: FnMut(&T, &T) -> Ordering,
+    {
+        self.map.sort_unstable_by(move |a, _, b, _| cmp(a, b))
+    }
+
+    /// Sort the values of the set and return a by-value iterator of
+    /// the values with the result.
+    pub fn sorted_unstable_by<F>(self, mut cmp: F) -> IntoIter<T>
+    where
+        F: FnMut(&T, &T) -> Ordering,
+    {
+        IntoIter {
+            iter: self
+                .map
+                .sorted_unstable_by(move |a, _, b, _| cmp(a, b))
+                .iter,
         }
     }