Use FnMut in the Slice (and Vec) APIs

Author: danakj

subspace/containers/slice.h

@@ -23,7 +23,8 @@
 #include "subspace/assertions/check.h"
 #include "subspace/construct/into.h"
 #include "subspace/containers/__private/slice_iter.h"
-#include "subspace/fn/callable.h"
+#include "subspace/fn/fn_concepts.h"
+#include "subspace/fn/run_fn.h"
 #include "subspace/iter/iterator_defn.h"
 #include "subspace/macros/lifetimebound.h"
 #include "subspace/marker/unsafe.h"
@@ -236,16 +237,17 @@ class [[sus_trivial_abi]] Slice {
   /// unspecified.
   //
   // TODO: Rust's stable sort is O(n * log(n)), so this can be improved.
-  template <class F, int&...,
-            class R = std::invoke_result_t<F, const T&, const T&>>
+  template <::sus::fn::FnMut<::sus::fn::Anything(const T&, const T&)> F,
+            int&..., class R = std::invoke_result_t<F, const T&, const T&>>
     requires(::sus::ops::Ordering<R>)
   void sort_by(F compare) noexcept
     requires(!std::is_const_v<T>)
   {
     if (len_ > 0_usize) {
-      std::stable_sort(
-          data_, data_ + size_t{len_},
-          [&compare](const T& l, const T& r) { return compare(l, r) < 0; });
+      std::stable_sort(data_, data_ + size_t{len_},
+                       [&compare](const T& l, const T& r) {
+                         return ::sus::run_mut(compare, l, r) < 0;
+                       });
     }
   }
 
@@ -270,16 +272,17 @@ class [[sus_trivial_abi]] Slice {
   /// The comparator function must define a total ordering for the elements in
   /// the slice. If the ordering is not total, the order of the elements is
   /// unspecified.
-  template <class F, int&...,
-            class R = std::invoke_result_t<F, const T&, const T&>>
+  template <::sus::fn::FnMut<::sus::fn::Anything(const T&, const T&)> F,
+            int&..., class R = std::invoke_result_t<F, const T&, const T&>>
     requires(::sus::ops::Ordering<R>)
   void sort_unstable_by(F compare) noexcept
     requires(!std::is_const_v<T>)
   {
     if (len_ > 0_usize) {
-      std::sort(
-          data_, data_ + size_t{len_},
-          [&compare](const T& l, const T& r) { return compare(l, r) < 0; });
+      std::sort(data_, data_ + size_t{len_},
+                [&compare](const T& l, const T& r) {
+                  return ::sus::run_mut(compare, l, r) < 0;
+                });
     }
   }
 

subspace/containers/vec.h

@@ -446,21 +446,21 @@ class Vec {
   void sort() { as_mut_slice().sort(); }
 
   /// #[doc.inherit=[n]sus::[n]containers::[r]Slice::[f]sort_by]
-  template <::sus::fn::FnOnce<::sus::fn::NonVoid(const T&, const T&)> F,
+  template <::sus::fn::FnMut<::sus::fn::NonVoid(const T&, const T&)> F,
             int&..., class R = std::invoke_result_t<F, const T&, const T&>>
     requires(::sus::ops::Ordering<R>)
-  void sort_by(F&& compare) {
+  void sort_by(F compare) {
     as_mut_slice().sort_by(sus::move(compare));
   }
 
   /// #[doc.inherit=[n]sus::[n]containers::[r]Slice::[f]sort_unstable]
   void sort_unstable() { as_mut_slice().sort(); }
 
   /// #[doc.inherit=[n]sus::[n]containers::[r]Slice::[f]sort_unstable_by]
-  template <::sus::fn::FnOnce<::sus::fn::NonVoid(const T&, const T&)> F,
+  template <::sus::fn::FnMut<::sus::fn::NonVoid(const T&, const T&)> F,
             int&..., class R = std::invoke_result_t<F, const T&, const T&>>
     requires(::sus::ops::Ordering<R>)
-  void sort_unstable_by(F&& compare) {
+  void sort_unstable_by(F compare) {
     as_mut_slice().sort_by(sus::move(compare));
   }