Implement Array::sort_unstable_by()

Author: Bromeon

godot-core/src/builtin/collections/array.rs

@@ -651,7 +651,7 @@ impl<T: ArrayElement> Array<T> {
         let ignored_value = <T as ParamType>::owned_to_arg(ignored_value);
 
         let godot_comparator = |args: &[&Variant]| {
-            let value = T::from_variant(&args[0]);
+            let value = T::from_variant(args[0]);
             let is_less = matches!(func(&value), cmp::Ordering::Less);
 
             Ok(is_less.to_variant())
@@ -697,20 +697,55 @@ impl<T: ArrayElement> Array<T> {
 
     /// Sorts the array.
     ///
-    /// Note: The sorting algorithm used is not [stable](https://en.wikipedia.org/wiki/Sorting_algorithm#Stability).
-    /// This means that values considered equal may have their order changed when using `sort_unstable`.
+    /// The sorting algorithm used is not [stable](https://en.wikipedia.org/wiki/Sorting_algorithm#Stability).
+    /// This means that values considered equal may have their order changed when using `sort_unstable`. For most variant types,
+    /// this distinction should not matter though.
+    ///
+    /// _Godot equivalent: `Array.sort()`_
     #[doc(alias = "sort")]
     pub fn sort_unstable(&mut self) {
         // SAFETY: We do not write any values that don't already exist in the array, so all values have the correct type.
         unsafe { self.as_inner_mut() }.sort();
     }
 
-    /// Sorts the array.
+    /// Sorts the array, using a type-safe comparator.
+    ///
+    /// The predicate expects two parameters `(a, b)` and should return an ordering relation. For example, simple ascending ordering of the
+    /// elements themselves would be achieved with `|a, b| a.cmp(b)`.
+    ///
+    /// The sorting algorithm used is not [stable](https://en.wikipedia.org/wiki/Sorting_algorithm#Stability).
+    /// This means that values considered equal may have their order changed when using `sort_unstable_by`. For most variant types,
+    /// this distinction should not matter though.
+    #[cfg(since_api = "4.2")]
+    pub fn sort_unstable_by<F>(&mut self, mut func: F)
+    where
+        F: FnMut(&T, &T) -> cmp::Ordering,
+    {
+        let godot_comparator = |args: &[&Variant]| {
+            let lhs = T::from_variant(args[0]);
+            let rhs = T::from_variant(args[1]);
+            let is_less = matches!(func(&lhs, &rhs), cmp::Ordering::Less);
+
+            Ok(is_less.to_variant())
+        };
+
+        let debug_name = std::any::type_name::<F>();
+        Callable::with_scoped_fn(debug_name, godot_comparator, |pred| {
+            self.sort_unstable_custom(pred)
+        });
+    }
+
+    /// Sorts the array, using type-unsafe `Callable` comparator.
+    ///
+    /// For a type-safe variant of this method, use [`sort_unstable_by()`][Self::sort_unstable_by].
+    ///
+    /// The callable expects two parameters `(lhs, rhs)` and should return a bool `lhs < rhs`.
     ///
-    /// Uses the provided `Callable` to determine ordering.
+    /// The sorting algorithm used is not [stable](https://en.wikipedia.org/wiki/Sorting_algorithm#Stability).
+    /// This means that values considered equal may have their order changed when using `sort_unstable_custom`.For most variant types,
+    /// this distinction should not matter though.
     ///
-    /// Note: The sorting algorithm used is not [stable](https://en.wikipedia.org/wiki/Sorting_algorithm#Stability).
-    /// This means that values considered equal may have their order changed when using `sort_unstable_custom`.
+    /// _Godot equivalent: `Array.sort_custom()`_
     #[doc(alias = "sort_custom")]
     pub fn sort_unstable_custom(&mut self, func: &Callable) {
         // SAFETY: We do not write any values that don't already exist in the array, so all values have the correct type.

itest/rust/src/builtin_tests/containers/array_test.rs

@@ -197,17 +197,6 @@ fn array_first_last() {
     assert_eq!(empty_array.back(), None);
 }
 
-#[itest]
-fn array_binary_search() {
-    let array = array![1, 3];
-
-    assert_eq!(array.bsearch(0), 0);
-    assert_eq!(array.bsearch(1), 0);
-    assert_eq!(array.bsearch(2), 1);
-    assert_eq!(array.bsearch(3), 1);
-    assert_eq!(array.bsearch(4), 2);
-}
-
 #[itest]
 fn array_find() {
     let array = array![1, 2, 1];
@@ -298,13 +287,6 @@ fn array_extend() {
     assert_eq!(array, array![1, 2, 3, 4]);
 }
 
-#[itest]
-fn array_sort() {
-    let mut array = array![2, 1];
-    array.sort_unstable();
-    assert_eq!(array, array![1, 2]);
-}
-
 #[itest]
 fn array_reverse() {
     let mut array = array![1, 2];
@@ -474,16 +456,42 @@ fn array_should_format_with_display() {
     assert_eq!(format!("{a}"), "[]");
 }
 
+#[itest]
+fn array_sort_unstable() {
+    let mut array = array![2, 1];
+    array.sort_unstable();
+    assert_eq!(array, array![1, 2]);
+}
+
+#[itest]
+#[cfg(since_api = "4.2")]
+fn array_sort_unstable_by() {
+    let mut array: Array<i32> = array![2, 1, 4, 3];
+    array.sort_unstable_by(|a, b| a.cmp(b));
+    assert_eq!(array, array![1, 2, 3, 4]);
+}
+
 #[itest]
 #[cfg(since_api = "4.2")]
-fn array_sort_custom() {
+fn array_sort_unstable_custom() {
     let mut a = array![1, 2, 3, 4];
     let func = backwards_sort_callable();
     a.sort_unstable_custom(&func);
     assert_eq!(a, array![4, 3, 2, 1]);
 }
 
-#[itest(focus)]
+#[itest]
+fn array_bsearch() {
+    let array = array![1, 3];
+
+    assert_eq!(array.bsearch(0), 0);
+    assert_eq!(array.bsearch(1), 0);
+    assert_eq!(array.bsearch(2), 1);
+    assert_eq!(array.bsearch(3), 1);
+    assert_eq!(array.bsearch(4), 2);
+}
+
+#[itest]
 #[cfg(since_api = "4.2")]
 fn array_bsearch_by() {
     let a: Array<i32> = array![1, 2, 4, 5];