Remove the run* helpers, they're noisy.

We can use a tidy to check how Fn/FnMut/FnOnce concept types are called

Author: danakj

subspace/CMakeLists.txt

@@ -55,7 +55,6 @@ target_sources(subspace PUBLIC
     "fn/fn_box_defn.h"
     "fn/fn_box_impl.h"
     "fn/fn_ref.h"
-    "fn/run_fn.h"
     "iter/__private/into_iterator_archetype.h"
     "iter/__private/iterator_end.h"
     "iter/__private/iterator_loop.h"

subspace/containers/array.h

@@ -27,7 +27,6 @@
 #include "subspace/containers/__private/slice_iter.h"
 #include "subspace/containers/slice.h"
 #include "subspace/fn/fn_concepts.h"
-#include "subspace/fn/run_fn.h"
 #include "subspace/macros/lifetimebound.h"
 #include "subspace/marker/unsafe.h"
 #include "subspace/mem/clone.h"
@@ -85,8 +84,7 @@ class Array final {
   constexpr static Array with_initializer(::sus::fn::FnMut<T()> auto f) noexcept
     requires(::sus::mem::Move<T>)
   {
-    return Array(kWithInitializer, ::sus::move(f),
-                 std::make_index_sequence<N>());
+    return Array(kWithInitializer, f, std::make_index_sequence<N>());
   }
 
   // Uses convertible_to<T> to accept `sus::into()` values. But doesn't use
@@ -289,7 +287,7 @@ class Array final {
     requires(N > 0)
   Array<R, N> map(MapFn f) && noexcept {
     return Array<R, N>::with_initializer([this, &f, i = size_t{0}]() mutable {
-      return ::sus::run_mut(f, move(storage_.data_[i++]));
+      return f(::sus::move(storage_.data_[i++]));
     });
   }
 
@@ -305,9 +303,9 @@ class Array final {
  private:
   enum WithInitializer { kWithInitializer };
   template <size_t... Is>
-  constexpr Array(WithInitializer, ::sus::fn::FnMut<T()> auto&& f,
+  constexpr Array(WithInitializer, ::sus::fn::FnMut<T()> auto& f,
                   std::index_sequence<Is...>) noexcept
-      : storage_{((void)Is, ::sus::run_mut(f))...} {}
+      : storage_{((void)Is, f())...} {}
 
   enum WithValue { kWithValue };
   template <size_t... Is>

subspace/containers/slice.h

@@ -24,7 +24,6 @@
 #include "subspace/construct/into.h"
 #include "subspace/containers/__private/slice_iter.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"
@@ -239,10 +238,9 @@ class [[sus_trivial_abi]] Slice {
     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 ::sus::run_mut(compare, l, r) < 0;
-                       });
+      std::stable_sort(
+          data_, data_ + size_t{len_},
+          [&compare](const T& l, const T& r) { return compare(l, r) < 0; });
     }
   }
 
@@ -274,10 +272,9 @@ class [[sus_trivial_abi]] Slice {
     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 ::sus::run_mut(compare, l, r) < 0;
-                });
+      std::sort(
+          data_, data_ + size_t{len_},
+          [&compare](const T& l, const T& r) { return compare(l, r) < 0; });
     }
   }
 

subspace/containers/vec.h

@@ -24,7 +24,6 @@
 #include "subspace/containers/__private/vec_marker.h"
 #include "subspace/containers/slice.h"
 #include "subspace/fn/fn_concepts.h"
-#include "subspace/fn/run_fn.h"
 #include "subspace/iter/from_iterator.h"
 #include "subspace/iter/into_iterator.h"
 #include "subspace/macros/lifetimebound.h"

subspace/fn/fn.h

@@ -19,4 +19,3 @@
 #include "subspace/fn/fn_box_impl.h"
 #include "subspace/fn/fn_concepts.h"
 #include "subspace/fn/fn_ref.h"
-#include "subspace/fn/run_fn.h"

subspace/fn/fn_concepts.h

@@ -56,11 +56,11 @@ struct Anything {
 /// ```
 ///
 /// # Use of `FnOnce`
-/// The `sus::run_once()` helper ensures that FnOnce is called correctly.
+/// `FnOnce` should be received as an rvalue reference typically, to avoid an
+/// unnecessary copy or move operation, but may also be received by value.
 ///
 /// A `FnOnce` should only be called once, and should be moved with
-/// `sus::move()` when calling it.  It is typically received as an rvalue
-/// reference to avoid an unnecessary copy or move operation.
+/// `sus::move()` when calling it.
 ///
 /// Calling it multiple times may panic or cause Undefined Behaviour. Not moving
 /// the `FnOnce` when calling it may fail to compile, panic, or cause Undefined
@@ -130,11 +130,13 @@ concept FnOnce = requires(F&& f) {
 /// ```
 ///
 /// # Use of `FnMut`
-/// The `sus::run_mut()` helper ensures that `FnMut` is called correctly.
+/// `FnMut` should be received by value reference typically, which isolates any
+/// internal mutation to the current function. It may also be received as an
+/// lvalue reference if it's desired to have its internal mutations visible to
+/// the caller.
 ///
-/// A `FnMut` may be called any number of times, unlike `FnOnce`, and need not
-/// be moved when called. It is typically received as a function parameter by
-/// value, which isolates any internal mutation to the current function.
+/// A `FnMut` may be called any number of times, unlike `FnOnce`, and should not
+/// be moved when called.
 ///
 /// # Compatibility
 /// Any callable type that satisfies `Fn` or `FnMut` will also satisfy `FnOnce`.
@@ -203,11 +205,12 @@ concept FnMut = requires(F& f) {
 /// ```
 ///
 /// # Use of `Fn`
-/// The `sus::run()` helper ensures that `Fn` is called correctly.
+/// `Fn` should be received by const reference, so that calls to it can be sure
+/// to reach the intended const overload of operator() if there is more than
+/// one.
 ///
-/// A `Fn` may be called any number of times, unlike `FnOnce`, and need not
-/// be moved when called. It is typically received as a function parameter as a
-/// const reference, which ensures a non-mutating call operator will be used.
+/// A `Fn` may be called any number of times, unlike `FnOnce`, and should not
+/// be moved when called.
 ///
 /// # Compatibility
 /// Any callable type that satisfies `Fn` will also satisfy `FnMut` and

subspace/fn/run_fn.h

@@ -20,7 +20,6 @@
 #include "subspace/assertions/check.h"
 #include "subspace/fn/fn_concepts.h"
 #include "subspace/fn/fn_ref.h"
-#include "subspace/fn/run_fn.h"
 #include "subspace/macros/lifetimebound.h"
 #include "subspace/mem/forward.h"
 
@@ -111,8 +110,7 @@ constexpr T min_by(
     T a sus_lifetimebound, T b sus_lifetimebound,
     ::sus::fn::FnOnce<std::strong_ordering(const T&, const T&)> auto&&
         compare) noexcept {
-  return ::sus::run_once(::sus::move(compare), a, b) ==
-                 std::strong_ordering::greater
+  return ::sus::move(compare)(a, b) == std::strong_ordering::greater
              ? ::sus::forward<T>(b)
              : ::sus::forward<T>(a);
 }
@@ -133,8 +131,7 @@ template <class T, ::sus::fn::FnMut<::sus::fn::NonVoid(const T&)> KeyFn,
   requires(Ord<Key>)
 constexpr T min_by_key(T a sus_lifetimebound, T b sus_lifetimebound,
                        KeyFn f) noexcept {
-  return ::sus::run_mut(f, a) > ::sus::run_mut(f, b) ? ::sus::forward<T>(b)
-                                                     : ::sus::forward<T>(a);
+  return f(a) > f(b) ? ::sus::forward<T>(b) : ::sus::forward<T>(a);
 }
 
 /// Compares and returns the maximum of two values.
@@ -169,8 +166,7 @@ constexpr T max_by(
     T a sus_lifetimebound, T b sus_lifetimebound,
     ::sus::fn::FnOnce<std::strong_ordering(const T&, const T&)> auto&&
         compare) noexcept {
-  return ::sus::run_once(::sus::move(compare), a, b) ==
-                 std::strong_ordering::greater
+  return ::sus::move(compare)(a, b) == std::strong_ordering::greater
              ? ::sus::forward<T>(a)
              : ::sus::forward<T>(b);
 }
@@ -191,8 +187,7 @@ template <class T, ::sus::fn::FnMut<::sus::fn::NonVoid(const T&)> KeyFn,
   requires(Ord<Key>)
 constexpr T max_by_key(T a sus_lifetimebound, T b sus_lifetimebound,
                        KeyFn f) noexcept {
-  return ::sus::run_mut(f, a) > ::sus::run_mut(f, b) ? ::sus::forward<T>(a)
-                                                     : ::sus::forward<T>(b);
+  return f(a) > f(b) ? ::sus::forward<T>(a) : ::sus::forward<T>(b);
 }
 
 /// Restrict a value to a certain interval.

subspace/ops/ord.h

@@ -27,7 +27,6 @@
 #include "subspace/assertions/unreachable.h"
 #include "subspace/construct/default.h"
 #include "subspace/fn/fn_concepts.h"
-#include "subspace/fn/run_fn.h"
 #include "subspace/iter/from_iterator.h"
 #include "subspace/iter/into_iterator.h"
 #include "subspace/macros/always_inline.h"
@@ -452,7 +451,7 @@ class Option final {
     if (t_.state() == Some) {
       return t_.take_and_set_none();
     } else {
-      return ::sus::run_once(::sus::move(f));
+      return ::sus::move(f)();
     }
   }
 
@@ -522,7 +521,7 @@ class Option final {
   /// the Option, and instead it can not be called on rvalues.
   T& get_or_insert_with(::sus::fn::FnOnce<T()> auto&& f) & noexcept {
     if (t_.state() == None) {
-      t_.construct_from_none(move_to_storage(::sus::run_once(::sus::move(f))));
+      t_.construct_from_none(move_to_storage(::sus::move(f)()));
     }
     return t_.val_mut();
   }
@@ -551,7 +550,7 @@ class Option final {
             class R = std::invoke_result_t<MapFn&&, T&&>>
   constexpr auto map(MapFn&& m) && noexcept {
     if (t_.state() == Some) {
-      return Option<R>(::sus::run_once(::sus::move(m), t_.take_and_set_none()));
+      return Option<R>(::sus::move(m)(t_.take_and_set_none()));
     } else {
       return Option<R>::none();
     }
@@ -567,7 +566,7 @@ class Option final {
             class R = std::invoke_result_t<MapFn&&, T&&>>
   constexpr R map_or(R default_result, MapFn&& m) && noexcept {
     if (t_.state() == Some) {
-      return ::sus::run_once(::sus::move(m), t_.take_and_set_none());
+      return ::sus::move(m)(t_.take_and_set_none());
     } else {
       return default_result;
     }
@@ -582,9 +581,9 @@ class Option final {
     requires(std::is_same_v<D, R>)
   constexpr R map_or_else(DefaultFn&& default_fn, MapFn&& m) && noexcept {
     if (t_.state() == Some) {
-      return ::sus::run_once(::sus::move(m), t_.take_and_set_none());
+      return ::sus::move(m)(t_.take_and_set_none());
     } else {
-      return ::sus::run_once(::sus::move(default_fn));
+      return ::sus::move(default_fn)();
     }
   }
 
@@ -597,7 +596,7 @@ class Option final {
   constexpr Option<T> filter(
       ::sus::fn::FnOnce<bool(const T&)> auto&& p) && noexcept {
     if (t_.state() == Some) {
-      if (::sus::run_once(::sus::move(p), t_.val())) {
+      if (::sus::move(p)(t_.val())) {
         return Option(t_.take_and_set_none());
       } else {
         // The state has to become None, and we must destroy the inner T.
@@ -635,7 +634,7 @@ class Option final {
     requires(::sus::option::__private::IsOptionType<R>::value)
   constexpr Option<U> and_then(AndFn&& f) && noexcept {
     if (t_.state() == Some)
-      return ::sus::run_once(::sus::move(f), t_.take_and_set_none());
+      return ::sus::move(f)(t_.take_and_set_none());
     else
       return Option<U>::none();
   }
@@ -656,7 +655,7 @@ class Option final {
     if (t_.state() == Some)
       return Option(t_.take_and_set_none());
     else
-      return ::sus::run_once(::sus::move(f));
+      return ::sus::move(f)();
   }
 
   /// Consumes this Option and returns an Option, holding the value from either
@@ -710,7 +709,7 @@ class Option final {
     if (t_.state() == Some)
       return Result::with(t_.take_and_set_none());
     else
-      return Result::with_err(::sus::run_once(::sus::move(f)));
+      return Result::with_err(::sus::move(f)());
   }
 
   /// Transposes an #Option of a #Result into a #Result of an #Option.