From 7a01a018ad735bad3f74961dace3e458af627709 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Fri, 8 Sep 2023 23:29:18 -0400
Subject: [PATCH 01/31] Remove use of FnMutRef in slice splitting

Use the Fn concepts instead and templatize the Split iterators. This
avoids holding a pointer to a possibly-temporary function object.
---
 sus/collections/__private/slice_methods.inc   |  58 +++---
 .../__private/slice_mut_methods.inc           |  48 +++--
 sus/collections/iterators/split.h             | 192 +++++++++---------
 sus/collections/slice_unittest.cc             |   4 +-
 4 files changed, 153 insertions(+), 149 deletions(-)

diff --git a/sus/collections/__private/slice_methods.inc b/sus/collections/__private/slice_methods.inc
index 8cba107ed..294428931 100644
--- a/sus/collections/__private/slice_methods.inc
+++ b/sus/collections/__private/slice_methods.inc
@@ -112,7 +112,7 @@ binary_search(const T& x) const& noexcept
 /// element could be inserted while maintaining sorted order.
 constexpr ::sus::result::Result<::sus::num::usize, ::sus::num::usize>
 binary_search_by(
-    ::sus::fn::FnMutRef<std::weak_ordering(const T&)> f) const& noexcept {
+    ::sus::fn::FnMut<std::weak_ordering(const T&)> auto f) const& noexcept {
   using Result = ::sus::result::Result<::sus::num::usize, ::sus::num::usize>;
 
   // INVARIANTS:
@@ -518,7 +518,7 @@ constexpr ::sus::Option<const T&> last() && = delete;
 /// See also `binary_search()`, `binary_search_by()`, and
 /// `binary_search_by_key()`.
 constexpr ::sus::num::usize partition_point(
-    ::sus::fn::FnMutRef<bool(const T&)> pred) const& noexcept {
+    ::sus::fn::FnMut<bool(const T&)> auto pred) const& noexcept {
   return binary_search_by([pred = ::sus::move(pred)](const T& x) {
            if (::sus::fn::call_mut(pred, x)) {
              return std::strong_ordering::less;
@@ -642,13 +642,15 @@ constexpr ::sus::collections::Vec<T> repeat(usize n) const& noexcept
 ///
 /// As with `split()`, if the first or last element is matched, an empty slice
 /// will be the first (or last) item returned by the iterator.
-constexpr RSplit<T> rsplit(
-    ::sus::fn::FnMutRef<bool(const T&)> pred) const& noexcept {
-  return RSplit<T>(Split<T>(_iter_refs_expr, *this, ::sus::move(pred)));
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr RSplit<T, Pred> rsplit(Pred pred) const& noexcept {
+  return RSplit<T, Pred>(
+      Split<T, Pred>(_iter_refs_expr, *this, ::sus::move(pred)));
 }
 
 #if _delete_rvalue
-constexpr Split<T> rsplit(::sus::fn::FnMutRef<bool(const T&)>) && = delete;
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr Split<T, Pred> rsplit(Pred) && = delete;
 #endif
 
 /// Returns an iterator over subslices separated by elements that match `pred`
@@ -656,15 +658,17 @@ constexpr Split<T> rsplit(::sus::fn::FnMutRef<bool(const T&)>) && = delete;
 /// and works backwards. The matched element is not contained in the subslices.
 ///
 /// The last element returned, if any, will contain the remainder of the slice.
-constexpr RSplitN<T> rsplitn(
-    usize n, ::sus::fn::FnMutRef<bool(const T&)> pred) const& noexcept {
-  return RSplitN<T>(
-      RSplit<T>(Split<T>(_iter_refs_expr, *this, ::sus::move(pred))), n);
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr RSplitN<T, Pred> rsplitn(usize n, Pred pred) const& noexcept {
+  return RSplitN<T, Pred>(  //
+      RSplit<T, Pred>(
+          Split<T, Pred>(_iter_refs_expr, *this, ::sus::move(pred))),
+      n);
 }
 
 #if _delete_rvalue
-constexpr RSplit<T> rsplitn(
-    usize n, ::sus::fn::FnMutRef<bool(const T&)> pred) && = delete;
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr RSplit<T, Pred> rsplitn(usize n, Pred pred) && = delete;
 #endif
 
 /// Returns an iterator over subslices separated by elements that match `pred`.
@@ -673,13 +677,14 @@ constexpr RSplit<T> rsplitn(
 /// If the first element is matched, an empty slice will be the first item
 /// returned by the iterator. Similarly, if the last element in the slice is
 /// matched, an empty slice will be the last item returned by the iterator.
-constexpr Split<T> split(
-    ::sus::fn::FnMutRef<bool(const T&)> pred) const& noexcept {
-  return Split<T>(_iter_refs_expr, *this, ::sus::move(pred));
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr Split<T, Pred> split(Pred pred) const& noexcept {
+  return Split<T, Pred>(_iter_refs_expr, *this, ::sus::move(pred));
 }
 
 #if _delete_rvalue
-constexpr Split<T> split(::sus::fn::FnMutRef<bool(const T&)>) && = delete;
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr Split<T, Pred> split(Pred) && = delete;
 #endif
 
 /// Divides one slice into two at an index.
@@ -756,14 +761,14 @@ constexpr ::sus::Option<::sus::Tuple<const T&, Slice<T>>> split_first() && =
 /// If the last element of the slice is matched, that element will be considered
 /// the terminator of the preceding slice. That slice will be the last item
 /// returned by the iterator.
-constexpr SplitInclusive<T> split_inclusive(
-    ::sus::fn::FnMutRef<bool(const T&)> pred) const& noexcept {
-  return SplitInclusive<T>(_iter_refs_expr, *this, ::sus::move(pred));
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr SplitInclusive<T, Pred> split_inclusive(Pred pred) const& noexcept {
+  return SplitInclusive<T, Pred>(_iter_refs_expr, *this, ::sus::move(pred));
 }
 
 #if _delete_rvalue
-constexpr SplitInclusive<T> split_inclusive(
-    ::sus::fn::FnMutRef<bool(const T&)>) && = delete;
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr SplitInclusive<T, Pred> split_inclusive(Pred) && = delete;
 #endif
 
 /// Returns the last and all the rest of the elements of the slice, or `None` if
@@ -786,14 +791,15 @@ constexpr ::sus::Option<::sus::Tuple<const T&, Slice<T>>> split_last() && =
 /// in the subslices.
 ///
 /// The last element returned, if any, will contain the remainder of the slice.
-constexpr SplitN<T> splitn(
-    usize n, ::sus::fn::FnMutRef<bool(const T&)> pred) const& noexcept {
-  return SplitN<T>(Split<T>(_iter_refs_expr, *this, ::sus::move(pred)), n);
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr SplitN<T, Pred> splitn(usize n, Pred pred) const& noexcept {
+  return SplitN<T, Pred>(
+      Split<T, Pred>(_iter_refs_expr, *this, ::sus::move(pred)), n);
 }
 
 #if _delete_rvalue
-constexpr Split<T> splitn(usize n,
-                          ::sus::fn::FnMutRef<bool(const T&)> pred) && = delete;
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr Split<T, Pred> splitn(usize n, Pred pred) && = delete;
 #endif
 
 /// Returns `true` if `needle` is a prefix of the slice.
diff --git a/sus/collections/__private/slice_mut_methods.inc b/sus/collections/__private/slice_mut_methods.inc
index f74097fd2..af60d4b88 100644
--- a/sus/collections/__private/slice_mut_methods.inc
+++ b/sus/collections/__private/slice_mut_methods.inc
@@ -233,7 +233,7 @@ constexpr void fill(T value) NO_RETURN_REF noexcept
 /// This method uses a closure to create new values. If you’d rather `Clone` a
 /// given value, use `fill()`. If you want to default-construct elements for a
 /// type that satisfies `sus::construct::Default`, use `fill_with_default()`.
-constexpr void fill_with(::sus::fn::FnMutRef<T()> f) NO_RETURN_REF noexcept {
+constexpr void fill_with(::sus::fn::FnMut<T()> auto f) NO_RETURN_REF noexcept {
   T* ptr = as_mut_ptr();
   T* const end_ptr = ptr + len();
   while (ptr != end_ptr) {
@@ -527,9 +527,10 @@ void rotate_right(::sus::num::usize k) NO_RETURN_REF noexcept
 ///
 /// As with `split_mut()`, if the first or last element is matched, an empty
 /// slice will be the first (or last) item returned by the iterator.
-constexpr RSplitMut<T> rsplit_mut(::sus::fn::FnMutRef<bool(const T&)> pred)
-    RETURN_REF noexcept {
-  return RSplitMut<T>(SplitMut<T>(_iter_refs_expr, *this, ::sus::move(pred)));
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr RSplitMut<T, Pred> rsplit_mut(Pred pred) RETURN_REF noexcept {
+  return RSplitMut<T, Pred>(
+      SplitMut<T, Pred>(_iter_refs_expr, *this, ::sus::move(pred)));
 }
 
 /// Returns an iterator over subslices separated by elements that match `pred`
@@ -537,10 +538,13 @@ constexpr RSplitMut<T> rsplit_mut(::sus::fn::FnMutRef<bool(const T&)> pred)
 /// and works backwards. The matched element is not contained in the subslices.
 ///
 /// The last element returned, if any, will contain the remainder of the slice.
-constexpr RSplitNMut<T> rsplitn_mut(
-    usize n, ::sus::fn::FnMutRef<bool(const T&)> pred) RETURN_REF noexcept {
-  return RSplitNMut<T>(
-      RSplitMut<T>(SplitMut<T>(_iter_refs_expr, *this, ::sus::move(pred))), n);
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr RSplitNMut<T, Pred> rsplitn_mut(usize n,
+                                          Pred pred) RETURN_REF noexcept {
+  return RSplitNMut<T, Pred>(  //
+      RSplitMut<T, Pred>(
+          SplitMut<T, Pred>(_iter_refs_expr, *this, ::sus::move(pred))),
+      n);
 }
 
 #if 0
@@ -587,7 +591,7 @@ constexpr RSplitNMut<T> rsplitn_mut(
 /// Panics when `index >= len()`, meaning it always panics on empty slices.
 ::sus::Tuple<SliceMut<T>, T&, SliceMut<T>> select_nth_unstable_by(
     usize index,
-    ::sus::fn::FnMutRef<std::weak_ordering(const T&, const T&)> compare)
+    ::sus::fn::FnMut<std::weak_ordering(const T&, const T&)> auto compare)
     RETURN_REF noexcept {
   ::sus::check_with_message(
       index < len(), "partition_at_index index greater than length of slice");
@@ -659,7 +663,7 @@ void sort() NO_RETURN_REF noexcept
 ///
 /// TODO: Rust's stable sort is O(n * log(n)), so this can be improved. It can
 /// also be constexpr?
-void sort_by(::sus::fn::FnMutRef<std::weak_ordering(const T&, const T&)>
+void sort_by(::sus::fn::FnMut<std::weak_ordering(const T&, const T&)> auto
                  compare) NO_RETURN_REF noexcept {
   if (len() > ::sus::num::usize(0u)) {
     std::stable_sort(as_mut_ptr(), as_mut_ptr() + len(),
@@ -760,7 +764,7 @@ constexpr void sort_unstable() NO_RETURN_REF noexcept
 /// TODO: Rust's sort is unstable (i.e., may reorder equal elements), in-place
 /// (i.e., does not allocate), and O(n * log(n)) worst-case.
 constexpr void sort_unstable_by(
-    ::sus::fn::FnMutRef<std::weak_ordering(const T&, const T&)> compare)
+    ::sus::fn::FnMut<std::weak_ordering(const T&, const T&)> auto compare)
     NO_RETURN_REF noexcept {
   if (len() > 0u) {
     std::sort(as_mut_ptr(), as_mut_ptr() + len(),
@@ -794,9 +798,9 @@ void sort_unstable_by_key(KeyFn f) NO_RETURN_REF noexcept {
 /// If the first element is matched, an empty slice will be the first item
 /// returned by the iterator. Similarly, if the last element in the slice is
 /// matched, an empty slice will be the last item returned by the iterator.
-constexpr SplitMut<T> split_mut(::sus::fn::FnMutRef<bool(const T&)> pred)
-    RETURN_REF noexcept {
-  return SplitMut<T>(_iter_refs_expr, *this, ::sus::move(pred));
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr SplitMut<T, Pred> split_mut(Pred pred) RETURN_REF noexcept {
+  return SplitMut<T, Pred>(_iter_refs_expr, *this, ::sus::move(pred));
 }
 
 /// Divides one mutable slice into two at an index.
@@ -865,9 +869,10 @@ split_first_mut() RETURN_REF noexcept {
 /// If the last element of the slice is matched, that element will be considered
 /// the terminator of the preceding slice. That slice will be the last item
 /// returned by the iterator.
-constexpr SplitInclusiveMut<T> split_inclusive_mut(
-    ::sus::fn::FnMutRef<bool(const T&)> pred) RETURN_REF noexcept {
-  return SplitInclusiveMut<T>(_iter_refs_expr, *this, ::sus::move(pred));
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr SplitInclusiveMut<T, Pred> split_inclusive_mut(Pred pred)
+    RETURN_REF noexcept {
+  return SplitInclusiveMut<T, Pred>(_iter_refs_expr, *this, ::sus::move(pred));
 }
 
 /// Returns the last and all the rest of the elements of the slice, or `None` if
@@ -889,10 +894,11 @@ sus_pure constexpr ::sus::Option<::sus::Tuple<T&, SliceMut<T>>> split_last_mut()
 /// contained in the subslices.
 ///
 /// The last element returned, if any, will contain the remainder of the slice.
-constexpr SplitNMut<T> splitn_mut(
-    usize n, ::sus::fn::FnMutRef<bool(const T&)> pred) RETURN_REF noexcept {
-  return SplitNMut<T>(SplitMut<T>(_iter_refs_expr, *this, ::sus::move(pred)),
-                      n);
+template <::sus::fn::FnMut<bool(const T&)> Pred>
+constexpr SplitNMut<T, Pred> splitn_mut(usize n,
+                                        Pred pred) RETURN_REF noexcept {
+  return SplitNMut<T, Pred>(
+      SplitMut<T, Pred>(_iter_refs_expr, *this, ::sus::move(pred)), n);
 }
 
 /// Returns a subslice with the `prefix` removed.
diff --git a/sus/collections/iterators/split.h b/sus/collections/iterators/split.h
index 1f7c5ed6e..22772db1e 100644
--- a/sus/collections/iterators/split.h
+++ b/sus/collections/iterators/split.h
@@ -32,7 +32,7 @@ namespace __private {
 /// match a predicate function, splitting at most a fixed number of
 /// times.
 template <class ItemT, ::sus::iter::Iterator<ItemT> I>
-class [[sus_trivial_abi]] GenericSplitN final
+class GenericSplitN final
     : public ::sus::iter::IteratorBase<GenericSplitN<ItemT, I>, ItemT> {
  public:
   using Item = ItemT;
@@ -66,8 +66,8 @@ class [[sus_trivial_abi]] GenericSplitN final
   I iter_;
   usize count_;
 
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(iter_),
-                                  decltype(count_));
+  sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
+                                           decltype(iter_), decltype(count_));
 };
 
 }  // namespace __private
@@ -76,9 +76,9 @@ class [[sus_trivial_abi]] GenericSplitN final
 /// function.
 ///
 /// This struct is created by the `split()` method on slices.
-template <class ItemT>
-class [[nodiscard]] [[sus_trivial_abi]] Split final
-    : public ::sus::iter::IteratorBase<Split<ItemT>,
+template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
+class [[nodiscard]] Split final
+    : public ::sus::iter::IteratorBase<Split<ItemT, Pred>,
                                        ::sus::collections::Slice<ItemT>> {
  public:
   // `Item` is a `Slice<T>`.
@@ -160,7 +160,7 @@ class [[nodiscard]] [[sus_trivial_abi]] Split final
   template <class A, ::sus::iter::Iterator<A> B>
   friend class __private::GenericSplitN;
   // Access to finish().
-  template <class A>
+  template <class A, ::sus::fn::FnMut<bool(const A&)> APred>
   friend class RSplit;
 
   constexpr Option<Item> finish() noexcept {
@@ -173,26 +173,27 @@ class [[nodiscard]] [[sus_trivial_abi]] Split final
   }
 
   constexpr Split(::sus::iter::IterRef ref, const Slice<ItemT>& values,
-                  ::sus::fn::FnMutRef<bool(const ItemT&)>&& pred) noexcept
+                  Pred&& pred) noexcept
       : ref_(::sus::move(ref)), v_(values), pred_(::sus::move(pred)) {}
 
   [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
   Slice<ItemT> v_;
-  ::sus::fn::FnMutRef<bool(const ItemT&)> pred_;
+  Pred pred_;
   bool finished_ = false;
 
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(ref_),
-                                  decltype(v_), decltype(pred_),
-                                  decltype(finished_));
+  sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
+                                           decltype(ref_), decltype(v_),
+                                           decltype(pred_),
+                                           decltype(finished_));
 };
 
 /// An iterator over subslices separated by elements that match a predicate
 /// function.
 ///
 /// This struct is created by the `split_mut()` method on slices.
-template <class ItemT>
-class [[nodiscard]] [[sus_trivial_abi]] SplitMut final
-    : public ::sus::iter::IteratorBase<SplitMut<ItemT>,
+template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
+class [[nodiscard]] SplitMut final
+    : public ::sus::iter::IteratorBase<SplitMut<ItemT, Pred>,
                                        ::sus::collections::SliceMut<ItemT>> {
  public:
   // `Item` is a `SliceMut<T>`.
@@ -274,7 +275,7 @@ class [[nodiscard]] [[sus_trivial_abi]] SplitMut final
   template <class A, ::sus::iter::Iterator<A> B>
   friend class __private::GenericSplitN;
   // Access to finish().
-  template <class A>
+  template <class A, ::sus::fn::FnMut<bool(const A&)>>
   friend class RSplitMut;
 
   constexpr Option<Item> finish() noexcept {
@@ -286,24 +287,19 @@ class [[nodiscard]] [[sus_trivial_abi]] SplitMut final
     }
   }
 
-  static constexpr auto with(
-      ::sus::iter::IterRef ref, const SliceMut<ItemT>& values,
-      ::sus::fn::FnMutRef<bool(const ItemT&)>&& pred) noexcept {
-    return SplitMut(::sus::move(ref), values, ::sus::move(pred));
-  }
-
   constexpr SplitMut(::sus::iter::IterRef ref, const SliceMut<ItemT>& values,
-                     ::sus::fn::FnMutRef<bool(const ItemT&)>&& pred) noexcept
+                     Pred&& pred) noexcept
       : ref_(::sus::move(ref)), v_(values), pred_(::sus::move(pred)) {}
 
   [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
   SliceMut<ItemT> v_;
-  ::sus::fn::FnMutRef<bool(const ItemT&)> pred_;
+  Pred pred_;
   bool finished_ = false;
 
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(ref_),
-                                  decltype(v_), decltype(pred_),
-                                  decltype(finished_));
+  sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
+                                           decltype(ref_), decltype(v_),
+                                           decltype(pred_),
+                                           decltype(finished_));
 };
 
 /// An iterator over subslices separated by elements that match a predicate
@@ -311,9 +307,9 @@ class [[nodiscard]] [[sus_trivial_abi]] SplitMut final
 /// of the subslice.
 ///
 /// This struct is created by the `split_inclusive()` method on slices.
-template <class ItemT>
-class [[nodiscard]] [[sus_trivial_abi]] SplitInclusive final
-    : public ::sus::iter::IteratorBase<SplitInclusive<ItemT>,
+template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
+class [[nodiscard]] SplitInclusive final
+    : public ::sus::iter::IteratorBase<SplitInclusive<ItemT, Pred>,
                                        ::sus::collections::Slice<ItemT>> {
  public:
   // `Item` is a `Slice<T>`.
@@ -398,9 +394,8 @@ class [[nodiscard]] [[sus_trivial_abi]] SplitInclusive final
   template <class ArrayItemT, size_t N>
   friend class Array;
 
-  constexpr SplitInclusive(
-      ::sus::iter::IterRef ref, const Slice<ItemT>& values,
-      ::sus::fn::FnMutRef<bool(const ItemT&)>&& pred) noexcept
+  constexpr SplitInclusive(::sus::iter::IterRef ref, const Slice<ItemT>& values,
+                           Pred&& pred) noexcept
       : ref_(::sus::move(ref)),
         v_(values),
         pred_(::sus::move(pred)),
@@ -408,12 +403,13 @@ class [[nodiscard]] [[sus_trivial_abi]] SplitInclusive final
 
   [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
   Slice<ItemT> v_;
-  ::sus::fn::FnMutRef<bool(const ItemT&)> pred_;
+  Pred pred_;
   bool finished_;
 
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(ref_),
-                                  decltype(v_), decltype(pred_),
-                                  decltype(finished_));
+  sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
+                                           decltype(ref_), decltype(v_),
+                                           decltype(pred_),
+                                           decltype(finished_));
 };
 
 /// An iterator over subslices separated by elements that match a predicate
@@ -421,9 +417,9 @@ class [[nodiscard]] [[sus_trivial_abi]] SplitInclusive final
 /// of the subslice.
 ///
 /// This struct is created by the `split_inclusive_mut()` method on slices.
-template <class ItemT>
-class [[nodiscard]] [[sus_trivial_abi]] SplitInclusiveMut final
-    : public ::sus::iter::IteratorBase<SplitInclusiveMut<ItemT>,
+template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
+class [[nodiscard]] SplitInclusiveMut final
+    : public ::sus::iter::IteratorBase<SplitInclusiveMut<ItemT, Pred>,
                                        ::sus::collections::SliceMut<ItemT>> {
  public:
   // `Item` is a `SliceMut<T>`.
@@ -509,15 +505,9 @@ class [[nodiscard]] [[sus_trivial_abi]] SplitInclusiveMut final
   template <class ArrayItemT, size_t N>
   friend class Array;
 
-  static constexpr auto with(
-      ::sus::iter::IterRef ref, const SliceMut<ItemT>& values,
-      ::sus::fn::FnMutRef<bool(const ItemT&)>&& pred) noexcept {
-    return SplitInclusiveMut(::sus::move(ref), values, ::sus::move(pred));
-  }
-
-  constexpr SplitInclusiveMut(
-      ::sus::iter::IterRef ref, const SliceMut<ItemT>& values,
-      ::sus::fn::FnMutRef<bool(const ItemT&)>&& pred) noexcept
+  constexpr SplitInclusiveMut(::sus::iter::IterRef ref,
+                              const SliceMut<ItemT>& values,
+                              Pred&& pred) noexcept
       : ref_(::sus::move(ref)),
         v_(values),
         pred_(::sus::move(pred)),
@@ -525,25 +515,25 @@ class [[nodiscard]] [[sus_trivial_abi]] SplitInclusiveMut final
 
   [[sus_no_unique_address]] ::sus::iter::IterRef ref_;
   SliceMut<ItemT> v_;
-  ::sus::fn::FnMutRef<bool(const ItemT&)> pred_;
+  Pred pred_;
   bool finished_;
 
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(ref_),
-                                  decltype(v_), decltype(pred_),
-                                  decltype(finished_));
+  sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
+                                           decltype(ref_), decltype(v_),
+                                           decltype(pred_),
+                                           decltype(finished_));
 };
 
 /// An iterator over subslices separated by elements that match a predicate
 /// function, starting from the end of the slice.
 ///
 /// This struct is created by the `rsplit()` method on slices.
-template <class ItemT>
-class [[nodiscard]] [[sus_trivial_abi]] RSplit final
-    : public ::sus::iter::IteratorBase<RSplit<ItemT>,
+template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
+class [[nodiscard]] RSplit final
+    : public ::sus::iter::IteratorBase<RSplit<ItemT, Pred>,
                                        ::sus::collections::Slice<ItemT>> {
  public:
-  // `Item` is a `Slice<T>`.
-  using Item = typename Split<ItemT>::Item;
+  using Item = ::sus::collections::Slice<ItemT>;
 
   // sus::iter::Iterator trait.
   constexpr Option<Item> next() noexcept { return inner_.next_back(); }
@@ -571,25 +561,25 @@ class [[nodiscard]] [[sus_trivial_abi]] RSplit final
 
   constexpr Option<Item> finish() noexcept { return inner_.finish(); }
 
-  constexpr RSplit(Split<ItemT>&& split) noexcept
+  constexpr RSplit(Split<ItemT, Pred>&& split) noexcept
       : inner_(::sus::move(split)) {}
 
-  Split<ItemT> inner_;
+  Split<ItemT, Pred> inner_;
 
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(inner_));
+  sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
+                                           decltype(inner_));
 };
 
 /// An iterator over the subslices of the vector which are separated by elements
 /// that match pred, starting from the end of the slice.
 ///
 /// This struct is created by the `rsplit_mut()` method on slices.
-template <class ItemT>
-class [[nodiscard]] [[sus_trivial_abi]] RSplitMut final
-    : public ::sus::iter::IteratorBase<RSplitMut<ItemT>,
+template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
+class [[nodiscard]] RSplitMut final
+    : public ::sus::iter::IteratorBase<RSplitMut<ItemT, Pred>,
                                        ::sus::collections::SliceMut<ItemT>> {
  public:
-  // `Item` is a `SliceMut<T>`.
-  using Item = typename SplitMut<ItemT>::Item;
+  using Item = ::sus::collections::SliceMut<ItemT>;
 
   // sus::iter::Iterator trait.
   constexpr Option<Item> next() noexcept { return inner_.next_back(); }
@@ -617,25 +607,25 @@ class [[nodiscard]] [[sus_trivial_abi]] RSplitMut final
 
   Option<Item> finish() noexcept { return inner_.finish(); }
 
-  constexpr RSplitMut(SplitMut<ItemT>&& split) noexcept
+  constexpr RSplitMut(SplitMut<ItemT, Pred>&& split) noexcept
       : inner_(::sus::move(split)) {}
 
-  SplitMut<ItemT> inner_;
+  SplitMut<ItemT, Pred> inner_;
 
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(inner_));
+  sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
+                                           decltype(inner_));
 };
 
 /// An iterator over subslices separated by elements that match a predicate
 /// function, limited to a given number of splits.
 ///
 /// This struct is created by the `splitn()` method on slices.
-template <class ItemT>
-class [[nodiscard]] [[sus_trivial_abi]] SplitN final
-    : public ::sus::iter::IteratorBase<SplitN<ItemT>,
+template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
+class [[nodiscard]] SplitN final
+    : public ::sus::iter::IteratorBase<SplitN<ItemT, Pred>,
                                        ::sus::collections::Slice<ItemT>> {
  public:
-  // `Item` is a `Slice<T>`.
-  using Item = typename Split<ItemT>::Item;
+  using Item = ::sus::collections::Slice<ItemT>;
 
   // sus::iter::Iterator trait.
   constexpr Option<Item> next() noexcept { return inner_.next(); }
@@ -654,25 +644,25 @@ class [[nodiscard]] [[sus_trivial_abi]] SplitN final
   template <class ArrayItemT, size_t N>
   friend class Array;
 
-  constexpr SplitN(Split<ItemT> split, usize n) noexcept
+  constexpr SplitN(Split<ItemT, Pred> split, usize n) noexcept
       : inner_(::sus::move(split), n) {}
 
-  __private::GenericSplitN<Slice<ItemT>, Split<ItemT>> inner_;
+  __private::GenericSplitN<Slice<ItemT>, Split<ItemT, Pred>> inner_;
 
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(inner_));
+  sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
+                                           decltype(inner_));
 };
 
 /// An iterator over mutable subslices separated by elements that match a
 /// predicate function, limited to a given number of splits.
 ///
 /// This struct is created by the `splitn_mut()` method on slices.
-template <class ItemT>
-class [[nodiscard]] [[sus_trivial_abi]] SplitNMut final
-    : public ::sus::iter::IteratorBase<SplitNMut<ItemT>,
+template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
+class [[nodiscard]] SplitNMut final
+    : public ::sus::iter::IteratorBase<SplitNMut<ItemT, Pred>,
                                        ::sus::collections::SliceMut<ItemT>> {
  public:
-  // `Item` is a `SliceMut<T>`.
-  using Item = typename SplitMut<ItemT>::Item;
+  using Item = ::sus::collections::SliceMut<ItemT>;
 
   // sus::iter::Iterator trait.
   constexpr Option<Item> next() noexcept { return inner_.next(); }
@@ -691,12 +681,13 @@ class [[nodiscard]] [[sus_trivial_abi]] SplitNMut final
   template <class ArrayItemT, size_t N>
   friend class Array;
 
-  constexpr SplitNMut(SplitMut<ItemT> split, usize n) noexcept
+  constexpr SplitNMut(SplitMut<ItemT, Pred> split, usize n) noexcept
       : inner_(::sus::move(split), n) {}
 
-  __private::GenericSplitN<SliceMut<ItemT>, SplitMut<ItemT>> inner_;
+  __private::GenericSplitN<SliceMut<ItemT>, SplitMut<ItemT, Pred>> inner_;
 
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(inner_));
+  sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
+                                           decltype(inner_));
 };
 
 /// An iterator over subslices separated by elements that match a predicate
@@ -704,13 +695,12 @@ class [[nodiscard]] [[sus_trivial_abi]] SplitNMut final
 /// slice.
 ///
 /// This struct is created by the `rsplitn()` method on slices.
-template <class ItemT>
-class [[nodiscard]] [[sus_trivial_abi]] RSplitN final
-    : public ::sus::iter::IteratorBase<RSplitN<ItemT>,
+template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
+class [[nodiscard]] RSplitN final
+    : public ::sus::iter::IteratorBase<RSplitN<ItemT, Pred>,
                                        ::sus::collections::Slice<ItemT>> {
  public:
-  // `Item` is a `Slice<T>`.
-  using Item = typename RSplit<ItemT>::Item;
+  using Item = ::sus::collections::Slice<ItemT>;
 
   // sus::iter::Iterator trait.
   constexpr Option<Item> next() noexcept { return inner_.next(); }
@@ -729,12 +719,13 @@ class [[nodiscard]] [[sus_trivial_abi]] RSplitN final
   template <class ArrayItemT, size_t N>
   friend class Array;
 
-  constexpr RSplitN(RSplit<ItemT> split, usize n) noexcept
+  constexpr RSplitN(RSplit<ItemT, Pred> split, usize n) noexcept
       : inner_(::sus::move(split), n) {}
 
-  __private::GenericSplitN<Slice<ItemT>, RSplit<ItemT>> inner_;
+  __private::GenericSplitN<Slice<ItemT>, RSplit<ItemT, Pred>> inner_;
 
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(inner_));
+  sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
+                                           decltype(inner_));
 };
 
 /// An iterator over subslices separated by elements that match a predicate
@@ -742,13 +733,13 @@ class [[nodiscard]] [[sus_trivial_abi]] RSplitN final
 /// slice.
 ///
 /// This struct is created by the rsplitn_mut method on slices.
-template <class ItemT>
-class [[nodiscard]] [[sus_trivial_abi]] RSplitNMut final
-    : public ::sus::iter::IteratorBase<RSplitNMut<ItemT>,
+template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
+class [[nodiscard]] RSplitNMut final
+    : public ::sus::iter::IteratorBase<RSplitNMut<ItemT, Pred>,
                                        ::sus::collections::SliceMut<ItemT>> {
  public:
   // `Item` is a `SliceMut<T>`.
-  using Item = typename RSplitMut<ItemT>::Item;
+  using Item = ::sus::collections::SliceMut<ItemT>;
 
   // sus::iter::Iterator trait.
   constexpr Option<Item> next() noexcept { return inner_.next(); }
@@ -767,12 +758,13 @@ class [[nodiscard]] [[sus_trivial_abi]] RSplitNMut final
   template <class ArrayItemT, size_t N>
   friend class Array;
 
-  constexpr RSplitNMut(RSplitMut<ItemT> split, usize n) noexcept
+  constexpr RSplitNMut(RSplitMut<ItemT, Pred> split, usize n) noexcept
       : inner_(::sus::move(split), n) {}
 
-  __private::GenericSplitN<SliceMut<ItemT>, RSplitMut<ItemT>> inner_;
+  __private::GenericSplitN<SliceMut<ItemT>, RSplitMut<ItemT, Pred>> inner_;
 
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(inner_));
+  sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
+                                           decltype(inner_));
 };
 
 }  // namespace sus::collections
diff --git a/sus/collections/slice_unittest.cc b/sus/collections/slice_unittest.cc
index 6f291c761..5e0fa3524 100644
--- a/sus/collections/slice_unittest.cc
+++ b/sus/collections/slice_unittest.cc
@@ -2563,8 +2563,8 @@ TEST(SliceMut, FillWith) {
   v1["2..4"_r].fill_with(f);
   EXPECT_EQ(v1[0u], 6);
   EXPECT_EQ(v1[1u], 7);
-  EXPECT_EQ(v1[2u], 10);
-  EXPECT_EQ(v1[3u], 11);
+  EXPECT_EQ(v1[2u], 6);
+  EXPECT_EQ(v1[3u], 7);
 }
 
 TEST(SliceMut, FillWithDefault) {

From c44fb021f0abeb542c76ebbc89d711549c885ae6 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sat, 9 Sep 2023 03:43:22 -0400
Subject: [PATCH 02/31] Lots of docs improvements for numerics and into

---
 sus/construct/__private/into_ref.h   |  9 +--
 sus/construct/into.h                 | 46 ++++++++-------
 sus/construct/transmogrify.h         | 70 ++++++++++++++---------
 sus/mem/forward.h                    | 12 ++--
 sus/num/overflow_integer.h           | 49 ++++++++++++----
 sus/num/overflow_integer_unittest.cc | 64 +++++++++++----------
 sus/num/types.h                      | 84 +++++++++++++++++++++-------
 sus/tuple/tuple.h                    |  2 +-
 8 files changed, 218 insertions(+), 118 deletions(-)

diff --git a/sus/construct/__private/into_ref.h b/sus/construct/__private/into_ref.h
index aeec43836..df267e22b 100644
--- a/sus/construct/__private/into_ref.h
+++ b/sus/construct/__private/into_ref.h
@@ -17,23 +17,24 @@
 #pragma once
 
 #include "sus/construct/from.h"
+#include "sus/mem/forward.h"
 
 namespace sus::construct ::__private {
 
 template <class FromType>
 struct IntoRef final {
   [[nodiscard]] constexpr IntoRef(FromType&& from) noexcept
-      : from_(static_cast<FromType&&>(from)) {}
+      : from_(::sus::forward<FromType>(from)) {}
 
-  template <std::same_as<std::decay_t<FromType>> ToType>
+  template <std::same_as<std::remove_reference_t<FromType>> ToType>
   constexpr operator ToType() && noexcept {
     return static_cast<ToType&&>(from_);
   }
 
   template <::sus::construct::From<FromType> ToType>
-    requires(!std::same_as<std::decay_t<FromType>, ToType>)
+    requires(!std::same_as<std::remove_reference_t<FromType>, ToType>)
   constexpr operator ToType() && noexcept {
-    return ToType::from(static_cast<FromType&&>(from_));
+    return ToType::from(::sus::forward<FromType>(from_));
   }
 
   // Doesn't copy or move. `IntoRef` should only be used as a temporary.
diff --git a/sus/construct/into.h b/sus/construct/into.h
index eb8d882d7..5789844df 100644
--- a/sus/construct/into.h
+++ b/sus/construct/into.h
@@ -29,38 +29,44 @@
 
 namespace sus::construct {
 
-/// A concept that declares `FromType` can be converted to `ToType` through the
-/// [`From`]($sus::construct::From) concept or through an identity
-/// transformation.
+/// A concept that declares `FromType` can be converted to `ToType`.
 ///
-/// When true, `ToType::from(FromType)` can be used to construct `ToType`,
-/// or `ToType` is the same as `FromType`.
+/// When true, the conversion can be done in one of three ways:
+/// * `ToType::from(FromType)` can be used to construct `ToType`, which is the
+///   preferred way to write conversions. It avoids any accidental conversions
+///   as it does not have an ambiguous appearance with a copy or move.
+/// * `ToType` is the same as `FromType`, in which case a reference to the
+///   object is passed along, and no construction or conversion happens.
 ///
-/// This is the inverse of the [`From`]($sus::construct::From) concept, meant to
-/// be used on methods that want to receive any type and which will explicitly
-/// convert what they are given type.
+/// This is the inverse direction from the [`From`]($sus::construct::From)
+/// concept, while also a broader generalization. It is meant to
+/// be used on methods that want to receive any type that can explicitly be
+/// converted to a specific type.
 ///
 /// This concept is not implementable directly, as it's satisfied for `T` by
 /// implementing the [`From<T>`]($sus::construct::From) concept on a different
-/// type. It is only possible to satisfy this concept for `ToType` that is not a
+/// type.
+/// It is only possible to satisfy this concept for a `ToType` that is not a
 /// reference, as it needs to be able to construct `ToType`.
 ///
 /// # Templates
 ///
 /// To receive [`into()`]($sus::construct::into) correctly for a templated
 /// function argument:
-/// * Avoid
-/// [`std::same_as<T>`](https://en.cppreference.com/w/cpp/concepts/same_as), use
-/// [`std::convertible_to<T>`](https://en.cppreference.com/w/cpp/concepts/convertible_to)
-/// instead, as this will
-///   accept the marker type returned from [into]($sus::construct::into).
+/// * Avoid [`std::same_as<T>`](
+///   https://en.cppreference.com/w/cpp/concepts/same_as), use
+///   [`std::convertible_to<T>`](
+///   https://en.cppreference.com/w/cpp/concepts/convertible_to) instead, as
+///   this will accept the marker type returned from
+///   [into]($sus::construct::into).
 /// * If the argument is a fixed dependent type, like the following:
 ///   ```
 ///   template <class T, class In = Foo<T>>
 ///   void f(In i) {}
 ///   ```
 ///   Insert an extra template parameter that uses
-///   [`std::convertible_to`](https://en.cppreference.com/w/cpp/concepts/convertible_to)
+///   [`std::convertible_to`](
+///   https://en.cppreference.com/w/cpp/concepts/convertible_to)
 ///   and the template type, such as:
 ///   ```
 ///   template <class T, class Exact = Foo<T>, std::convertible_to<Exact> In>
@@ -141,12 +147,14 @@ concept TryInto = ::sus::construct::TryFrom<ToType, FromType> ||
 
 /// Attempts to convert from the given value to a `ToType`.
 ///
-/// Unlike `into()`, this function can not use type deduction to determine the
-/// receiving type as it needs to determine the Result type and allow the caller
-/// the chance to handle the error condition.
+/// Unlike [`into()`]($sus::construct::into), this function can not use type
+/// deduction to determine the
+/// receiving type as it needs to determine the [`Result`]($sus::result::Result)
+/// type and allow the caller the chance to handle the error condition.
 ///
 /// The `TryFrom` concept requires a `try_from()` method that returns a
-/// `Result`. That `Result` will be the return type of this function.
+/// [`Result`]($sus::result::Result). That [`Result`]($sus::result::Result)
+/// will be the return type of this function.
 ///
 /// # Example
 /// ```
diff --git a/sus/construct/transmogrify.h b/sus/construct/transmogrify.h
index 2d74f7c15..802330ed4 100644
--- a/sus/construct/transmogrify.h
+++ b/sus/construct/transmogrify.h
@@ -61,13 +61,18 @@ struct TransmogrifyImpl<T, T> {
 /// conversion may truncate or extend `F` in order to do the conversion to `T`.
 ///
 /// This operation is also commonly known as type casting, or type coercion. The
-/// conversion to `T` can be done by calling `sus::mog<T>(from)`.
+/// conversion to `T` can be done by calling
+/// [`sus::mog<T>(from)`]($sus::construct::mog).
 ///
 /// The conversion is defined for the identity conversion where both the input
-/// and output are the same type, if the type is `Copy`, in which case the input
-/// is copied and returned. As Transmogrification is meant to be a cheap
-/// conversion, primarily for primitive types, it does not support `Clone`
-/// types, and `sus::construct::Into` should be used in more complex cases.
+/// and output are the same type, if the type is [`Copy`]($sus::mem::Copy), in
+//  which case the input is copied and returned.
+/// As Transmogrification is meant to be a cheap
+/// conversion, primarily for primitive types, it does not support
+/// [`Clone`]($sus::mem::Clone) types, and [`Into`]($sus::construct::Into)
+/// should be used in more complex cases.
+///
+/// # Casting numeric types
 ///
 /// For numeric and primitive types, `Transmogrify` is defined to provide a
 /// mechanism like `static_cast<T>` but it is much safer than `static_cast<T>`
@@ -76,33 +81,34 @@ struct TransmogrifyImpl<T, T> {
 /// * Casting from a float to an integer will perform a static_cast, which
 ///   rounds the float towards zero, except:
 ///   * `NAN` will return 0.
-///   * Values larger than the maximum integer value, including `f32::INFINITY`,
+///   * Values larger than the maximum integer value, including
+///     [`f32::INFINITY`]($sus::num::f32::INFINITY),
 ///     will saturate to the maximum value of the integer type.
 ///   * Values smaller than the minimum integer value, including
-///     `f32::NEG_INFINITY`, will saturate to the minimum value of the integer
-///     type.
+///     [`f32::NEG_INFINITY`]($sus::num::f32::NEG_INFINITY), will saturate to
+///     the minimum value of the integer type.
 /// * Casting from an integer to a float will perform a static_cast, which
 ///   converts to the nearest floating point value. The rounding direction for
 ///   values that land between representable floating point values is
 ///   implementation defined (per C++20 Section 7.3.10).
-/// * Casting from an `f32` (or `float`) to an `f64` (or `double`) preserves the
+/// * Casting from an [`f32`]($sus::num::f32) (or `float`) to an
+///   [`f64`]($sus::num::f64) (or `double`) preserves the
 ///   value unchanged.
-/// * Casting from an `f64` (or `double`) to an `f32` (or float) performs the
-///   same action as a static_cast if the value is in range for f32, otherwise:
+/// * Casting from an [`f64`]($sus::num::f64) (or `double`) to an
+///   [`f32`]($sus::num::f32) (or float) performs the same action as a
+///   `static_cast` if the value is in range for [`f32`]($sus::num::f32),
+///   otherwise:
 ///   * `NAN` will return a `NAN`.
-///   * Values outside of f32's range will return `f32::INFINITY` or
-///     `f32::NEG_INFINITY` for positive and negative values respectively.
-/// * Casting to and from `std::byte` produces the same values as casting to and
-///   from `u8`.
+///   * Values outside of [`f32`]($sus::num::f32)'s range will return
+///     [`f32::INFINITY`]($sus::num::f32::INFINITY) or
+///     [`f32::NEG_INFINITY`]($sus::num::f32::NEG_INFINITY) for positive and
+///     negative values respectively.
+/// * Casting to and from [`std::byte`](
+///   https://en.cppreference.com/w/cpp/types/byte) produces the same values
+///   as casting to and from [`u8`]($sus::num::u8).
 ///
 /// These conversions are all defined in `sus/num/types.h`.
 ///
-/// The transmogrifier is one of three of the most complicated inventions. The
-/// other two are the [Cerebral
-/// Enhance-O-Tron](https://calvinandhobbes.fandom.com/wiki/Cerebral_Enhance-O-Tron),
-/// and the [Transmogrifier
-/// Gun](https://calvinandhobbes.fandom.com/wiki/Transmogrifier_Gun).
-///
 /// # Extending to other types
 ///
 /// Types can participate in defining their transmogrification strategy by
@@ -112,6 +118,14 @@ struct TransmogrifyImpl<T, T> {
 ///
 /// The `Transmogrify` specialization needs a static method `mog_from()` that
 /// receives `const From&` and returns `To`.
+///
+/// # Lore
+///
+/// The transmogrifier is one of three of the most complicated inventions. The
+/// other two are the [Cerebral
+/// Enhance-O-Tron](https://calvinandhobbes.fandom.com/wiki/Cerebral_Enhance-O-Tron),
+/// and the [Transmogrifier
+/// Gun](https://calvinandhobbes.fandom.com/wiki/Transmogrifier_Gun).
 template <class To, class From>
 concept Transmogrify = requires(const From& from) {
   {
@@ -126,15 +140,19 @@ concept Transmogrify = requires(const From& from) {
 /// memory unsafety if used incorrectly. This behaves like `static_cast<To>()`
 /// but without Undefined Behaviour.
 ///
-/// The `mog` operation is supported for types `To` and `From` that satisfy
-/// `Transmogrify<To, From>`.
+/// The [`mog`]($sus::construct::mog) operation is supported for types `To` and
+/// `From` that satisfy [`Transmogrify<To, From>`](
+/// $sus::construct::Transmogrify).
 ///
 /// To convert between types while ensuring the values are preserved, use
-/// `sus::construct::Into` or `sus::construct::TryInto`. Usually prefer using
-/// `sus::into(x)` or `sus::try_into(x)` over `sus::mog<Y>(x)` as most code
+/// [`Into`]($sus::construct::Into) or [`TryInto`]($sus::construct::TryInto).
+/// Usually prefer using [`sus::into(x)`]($sus::construct::into) or
+/// [`sus::try_into(x)`]($sus::construct::try_into) over
+/// [`sus::mog<Y>(x)`]($sus::construct::mog) as most code
 /// should preserve values across type transitions.
 ///
-/// See `Transmogrify` for how numeric and primitive values are converted.
+/// See [`Transmogrify`]($sus::construct::Transmogrify) for how numeric and
+/// primitive values are converted.
 ///
 /// # Examples
 ///
diff --git a/sus/mem/forward.h b/sus/mem/forward.h
index 1e957a4a4..e4c4ff887 100644
--- a/sus/mem/forward.h
+++ b/sus/mem/forward.h
@@ -21,7 +21,7 @@
 
 namespace sus::mem {
 
-/// Passes a reference as an argument while preserving the reference type.
+/// Move from non-reference values but pass through and preserve references.
 ///
 /// Typically, passing an rvalue reference will convert it to an lvalue. Using
 /// `sus::forward<T>(t)` on an rvalue reference `T&& t` will preserve the rvalue
@@ -35,11 +35,13 @@ namespace sus::mem {
 ///
 /// In the common case, when you want to receive a parameter that will be moved,
 /// it should be received by value. However, library implementors sometimes with
-/// to receive an *rvalue reference*. If you find yourself needing to `move()`
-/// from a universal reference instead of `forward()`, such as to construct a
+/// to receive an *rvalue reference*. If you find yourself needing to
+/// [`move()`]($sus::mem::move) from a universal reference instead of
+/// [`forward()`]($sus::mem::forward), such as to construct a
 /// value type `T` from a universal reference `T&&` without introducing a copy,
-/// use `IsMoveRef` to constrain the universal reference to be an rvalue, and
-/// use `move()` instead of `forward()`.
+/// use [`IsMoveRef`]($sus::mem::IsMoveRef) to constrain the universal reference
+/// to be an rvalue, and use [`move()`]($sus::mem::move) instead of
+/// [`forward()`]($sus::mem::forward).
 template <class T>
 sus_pure_const sus_always_inline constexpr T&& forward(
     std::remove_reference_t<T>& t) noexcept {
diff --git a/sus/num/overflow_integer.h b/sus/num/overflow_integer.h
index 6a8152e24..7d53d2c15 100644
--- a/sus/num/overflow_integer.h
+++ b/sus/num/overflow_integer.h
@@ -28,28 +28,53 @@ namespace sus::num {
 /// An integer type that handles overflow instead of panicing.
 ///
 /// The value inside the integer can be accessed or unwrapped like with an
-/// `Option`, which will panic if the integer has overflowed. Or it can be
-/// converted into an `Option` that will represent the overflow state as `None`.
+/// [`Option`]($sus::option::Option), which will panic if the integer has
+/// overflowed. Or it can be converted into an [`Option`]($sus::option::Option)
+/// that will represent the overflow state as `None`.
+///
+/// This type is useful for performing a series of operations as a unit, and
+/// then checking for overflow after. It satisfies the
+/// [`Sum`]($sus::iter::Sum) and [`Product`]($sus::iter::Product) concepts
+/// so can be used with [`sum`]($sus::iter::IteratorBase::sum) and
+/// [`product`]($sus::iter::IteratorBase::product) for iterators over integers.
+///
+/// # Examples
+/// Using OverflowInteger to sum an iterator of integers and look for overflow
+/// after without panicking.
+/// ```
+/// auto a = sus::Array<i32, 2>(2, i32::MAX);
+/// auto maybe_answer =
+///     a.iter().copied().product<sus::num::OverflowInteger<i32>>();
+/// sus::check(maybe_answer.is_overflow());
+/// ```
 template <::sus::num::Integer I>
 class OverflowInteger {
  public:
-  // Default constructs OverflowInteger with the default value of the inner
+  // Default constructs `OverflowInteger` with the default value of the inner
   // integer type `I`.
   explicit constexpr OverflowInteger() noexcept
     requires(::sus::construct::Default<I>)
       : v_(Option<I>(I())) {}
 
-  /// Constructs an OverflowInteger from the same subspace integer type.
-  template <std::convertible_to<I> U>
-  explicit constexpr OverflowInteger(U u) noexcept
-      : v_(Option<I>(::sus::move(u))) {}
+  /// Constructs an `OverflowInteger` from the same subspace integer type.
+  ///
+  /// # Implementation note
+  ///
+  /// Because `OverflowInteger` is constructible from a smaller integer, but
+  /// `I` is also constructible from a smaller integer, which can then be used
+  /// to construct `OverflowInteger`, on MSVC this conversion becomes ambiguous.
+  /// So we use `convertible_to` to make the constructor a template,
+  /// which allows the compiler to choose one.
+  /// https://developercommunity.visualstudio.com/t/Ambiguous-conversion-with-two-paths-of-d/10461863
+  explicit constexpr OverflowInteger(std::convertible_to<I> auto u) noexcept
+      : v_(Option<I>(sus::move(u))) {}
 
-  /// Satisfies `sus::construct::From<OverflowInteger<I>, U>` if the inner
-  /// integer type `I` satisfies `sus::construct::From<I, U>`.
+  /// Satisfies `sus::construct::From<OverflowInteger<I>, U>` if the
+  /// `OverflowInteger` is constructible from `U`.
   template <class U>
-    requires(::sus::construct::From<I, U>)
+    requires(std::constructible_from<OverflowInteger, U>)
   sus_pure static constexpr OverflowInteger from(U u) noexcept {
-    return OverflowInteger(::sus::move_into(u));
+    return OverflowInteger(u);
   }
 
   /// Satisfies `sus::construct::TryFrom<OverflowInteger<I>, U>` if the inner
@@ -80,7 +105,7 @@ class OverflowInteger {
   /// If an iterator yields a subspace integer type, `iter.product()` would
   /// panic on overflow. So instead `iter.product<OverflowInteger<T>>()` can be
   /// used (for integer type `T`) which will perform the product computation and
-  /// return an OverflowInteger without ever panicking.
+  /// return an `OverflowInteger` without ever panicking.
   static constexpr OverflowInteger from_product(
       ::sus::iter::Iterator<I> auto&& it) noexcept
     requires(::sus::mem::IsMoveRef<decltype(it)>)
diff --git a/sus/num/overflow_integer_unittest.cc b/sus/num/overflow_integer_unittest.cc
index ba4951bd6..490ac02df 100644
--- a/sus/num/overflow_integer_unittest.cc
+++ b/sus/num/overflow_integer_unittest.cc
@@ -18,6 +18,7 @@
 
 #include "googletest/include/gtest/gtest.h"
 #include "sus/collections/array.h"
+#include "sus/iter/iterator.h"
 #include "sus/num/signed_integer.h"
 #include "sus/num/unsigned_integer.h"
 #include "sus/prelude.h"
@@ -101,6 +102,13 @@ TEST(OverflowInteger, TryFrom) {
             sus::num::TryFromIntError::with_out_of_bounds());
 }
 
+TEST(OverflowInteger, Example_Iterator) {
+  auto a = sus::Array<i32, 2>(2, i32::MAX);
+  auto maybe_answer =
+      a.iter().copied().product<sus::num::OverflowInteger<i32>>();
+  sus::check(maybe_answer.is_overflow());  // Overflow happened.
+}
+
 TEST(OverflowInteger, FromProduct) {
   static_assert(::sus::iter::Product<OverflowInteger<i32>, i32>);
   static_assert(::sus::iter::Product<OverflowInteger<i32>>);
@@ -113,6 +121,14 @@ TEST(OverflowInteger, FromProduct) {
     static_assert(std::same_as<decltype(o), sus::num::OverflowInteger<i32>>);
     EXPECT_EQ(o.to_option(), sus::None);
   }
+  // Reference iterator.
+  {
+    auto a = sus::Array<i32, 2>(2, i32::MAX);
+    decltype(auto) o =
+        a.iter().copied().product<sus::num::OverflowInteger<i32>>();
+    static_assert(std::same_as<decltype(o), sus::num::OverflowInteger<i32>>);
+    EXPECT_EQ(o.to_option(), sus::None);
+  }
   // To OverflowInteger without overflow.
   {
     auto a = sus::Array<i32, 2>(2, 4);
@@ -131,8 +147,8 @@ TEST(OverflowInteger, FromProduct) {
   }
   // Iterating OverflowInteger types without overflow.
   {
-    auto a = sus::Array<OverflowInteger<i32>, 2>(
-        OverflowInteger<i32>(2), OverflowInteger<i32>(4));
+    auto a = sus::Array<OverflowInteger<i32>, 2>(OverflowInteger<i32>(2),
+                                                 OverflowInteger<i32>(4));
     decltype(auto) o = sus::move(a).into_iter().product();
     static_assert(std::same_as<decltype(o), sus::num::OverflowInteger<i32>>);
     EXPECT_EQ(o.to_option().unwrap(), 2 * 4);
@@ -164,9 +180,8 @@ TEST(OverflowInteger, AsValue) {
     auto lvalue = OverflowInteger<i32>(i32::MAX);
     EXPECT_EQ(lvalue.as_value_unchecked(unsafe_fn), i32::MAX);
     EXPECT_EQ(OverflowInteger<i32>(i32::MAX).as_value(), i32::MAX);
-    EXPECT_EQ(
-        OverflowInteger<i32>(i32::MAX).as_value_unchecked(unsafe_fn),
-        i32::MAX);
+    EXPECT_EQ(OverflowInteger<i32>(i32::MAX).as_value_unchecked(unsafe_fn),
+              i32::MAX);
   }
 }
 
@@ -213,8 +228,7 @@ TEST(OverflowIntegerDeathTest, AsValueMutOverflow) {
 TEST(OverflowInteger, Unwrap) {
   EXPECT_EQ(OverflowInteger<i32>(i32::MAX).unwrap(), i32::MAX);
   static_assert(
-      std::same_as<decltype(OverflowInteger<i32>(i32::MAX).unwrap()),
-                   i32>);
+      std::same_as<decltype(OverflowInteger<i32>(i32::MAX).unwrap()), i32>);
   EXPECT_EQ(OverflowInteger<i32>(i32::MAX).unwrap_unchecked(unsafe_fn),
             i32::MAX);
 }
@@ -225,10 +239,8 @@ TEST(OverflowInteger, ToOption) {
   lvalue += 1;
   EXPECT_EQ(lvalue.to_option(), sus::none());
 
-  EXPECT_EQ(OverflowInteger<i32>(i32::MAX).to_option(),
-            sus::some(i32::MAX));
-  EXPECT_EQ((OverflowInteger<i32>(i32::MAX) + 1).to_option(),
-            sus::none());
+  EXPECT_EQ(OverflowInteger<i32>(i32::MAX).to_option(), sus::some(i32::MAX));
+  EXPECT_EQ((OverflowInteger<i32>(i32::MAX) + 1).to_option(), sus::none());
 }
 
 TEST(OverflowInteger, MathAssignFromInt) {
@@ -445,10 +457,8 @@ TEST(OverflowInteger, Eq) {
 
   EXPECT_EQ(OverflowInteger<i32>(1) + i32::MAX,
             OverflowInteger<i32>(1) + i32::MAX);
-  EXPECT_NE(OverflowInteger<i32>(5),
-            OverflowInteger<i32>(1) + i32::MAX);
-  EXPECT_NE(OverflowInteger<i32>(1) + i32::MAX,
-            OverflowInteger<i32>(5));
+  EXPECT_NE(OverflowInteger<i32>(5), OverflowInteger<i32>(1) + i32::MAX);
+  EXPECT_NE(OverflowInteger<i32>(1) + i32::MAX, OverflowInteger<i32>(5));
 }
 
 TEST(OverflowInteger, StrongOrd) {
@@ -456,17 +466,13 @@ TEST(OverflowInteger, StrongOrd) {
   static_assert(::sus::ops::StrongOrd<OverflowInteger<i32>, i32>);
   static_assert(::sus::ops::StrongOrd<i32, OverflowInteger<i32>>);
 
-  EXPECT_EQ(OverflowInteger<i32>(5) <=> 4_i32,
-            std::strong_ordering::greater);
-  EXPECT_EQ(OverflowInteger<i32>(5) <=> 6_i32,
-            std::strong_ordering::less);
+  EXPECT_EQ(OverflowInteger<i32>(5) <=> 4_i32, std::strong_ordering::greater);
+  EXPECT_EQ(OverflowInteger<i32>(5) <=> 6_i32, std::strong_ordering::less);
   EXPECT_EQ(OverflowInteger<i32>(5) <=> 5_i32,
             std::strong_ordering::equivalent);
 
-  EXPECT_EQ(6_i32 <=> OverflowInteger<i32>(5),
-            std::strong_ordering::greater);
-  EXPECT_EQ(4_i32 <=> OverflowInteger<i32>(5),
-            std::strong_ordering::less);
+  EXPECT_EQ(6_i32 <=> OverflowInteger<i32>(5), std::strong_ordering::greater);
+  EXPECT_EQ(4_i32 <=> OverflowInteger<i32>(5), std::strong_ordering::less);
   EXPECT_EQ(5_i32 <=> OverflowInteger<i32>(5),
             std::strong_ordering::equivalent);
 
@@ -477,18 +483,16 @@ TEST(OverflowInteger, StrongOrd) {
   EXPECT_EQ(OverflowInteger<i32>(5) <=> OverflowInteger<i32>(5),
             std::strong_ordering::equivalent);
 
-  EXPECT_EQ(OverflowInteger<i32>(1) + i32::MAX <=>
-                OverflowInteger<i32>(1) + i32::MAX,
-            std::strong_ordering::equivalent);
+  EXPECT_EQ(
+      OverflowInteger<i32>(1) + i32::MAX <=> OverflowInteger<i32>(1) + i32::MAX,
+      std::strong_ordering::equivalent);
   EXPECT_EQ(OverflowInteger<i32>(1) + i32::MAX <=> 0_i32,
             std::strong_ordering::greater);
   EXPECT_EQ(0_i32 <=> OverflowInteger<i32>(1) + i32::MAX,
             std::strong_ordering::less);
-  EXPECT_EQ(OverflowInteger<i32>(1) + i32::MAX <=>
-                OverflowInteger<i32>(0),
+  EXPECT_EQ(OverflowInteger<i32>(1) + i32::MAX <=> OverflowInteger<i32>(0),
             std::strong_ordering::greater);
-  EXPECT_EQ(OverflowInteger<i32>(0) <=>
-                OverflowInteger<i32>(1) + i32::MAX,
+  EXPECT_EQ(OverflowInteger<i32>(0) <=> OverflowInteger<i32>(1) + i32::MAX,
             std::strong_ordering::less);
 }
 
diff --git a/sus/num/types.h b/sus/num/types.h
index 73cb27e56..00c72f49b 100644
--- a/sus/num/types.h
+++ b/sus/num/types.h
@@ -18,34 +18,76 @@
 
 namespace sus {
 
-/// Safe integer and floating point numerics, and numeric concepts.
+/// Safe integer (e.g. [`i32`]($sus::num::i32)) and floating point
+/// (e.g. [`f32`]($sus::num::f32)) numerics, and numeric concepts.
 ///
-/// This namespace contains safe integer types (i8, i16, u32, usize, etc.) and
-/// floating point types (f32, f64).
+/// This namespace contains safe integer types and floating point types.
+///
+/// Safe numeric types:
+/// * Signed integers: [`i8`]($sus::num::i8), [`i16`]($sus::num::i16),
+///   [`i32`]($sus::num::i32), [`i64`]($sus::num::i64),
+///   [`isize`]($sus::num::isize).
+/// * Unsigned integers: [`u8`]($sus::num::u8), [`u16`]($sus::num::u16),
+///   [`u32`]($sus::num::u32), [`u64`]($sus::num::u64),
+///   [`usize`]($sus::num::usize), [`uptr`]($sus::num::uptr).
+/// * Floating point: [`f32`]($sus::num::f32), [`f64`]($sus::num::f64).
+/// * Portability helper: [`CInt`]
 ///
 /// Additionally, there are Concepts that match against safe numerics, C++
 /// primitive types, and operations with numeric types.
 ///
+/// The Subspace library numeric types can interoperate with primitive C++
+/// types, but are safer than primitive C++ types and eliminate many classes of
+/// bugs that often lead to security vulnerabilities:
+/// * Integer overflow is not allowed by default, and will
+///   [`panic`]($sus::assertions::panic) to terminate the
+///   program. Intentional overflow can be achieved through methods like
+///   [`wrapping_add`]($sus::num::i32::wrapping_add) or
+///   [`saturating_mul`]($sus::num::i32::saturating_mul). The
+///   [`OverflowInteger`]($sus::num::OverflowInteger) type can be used for a
+///   series of potentially-overflowing operations and unwraps to an integer
+///   value if-and-only-if no overflow has occured.
+/// * Integers and floats convert implicitly into each other or into primitive
+///   types *only* when no data can be lost, otherwise conversions do not
+///   compile. To convert fallibly and observe data loss, use the
+///   [`TryFrom`]($sus::construct::TryFrom) concept methods, such as
+///   `u32::try_from(3_i32)`. To do casting conversions with truncation, use
+///   [`Transmogrify`]($sus::construct::Transmogrify).
+/// * No integer promotion. Math on 8-bit and 16-bit integers will not change
+///   their type, unlike primitive types which convert to (signed) int on any
+///   math operation.
+/// * No Undefined Behaviour in conversions. Conversions between all numeric
+///   types, and between them and primitive types is well-defined for all
+///   possible values, unlike conversions between primitive integer and
+///   floating point types which can result in Undefined Behaviour.
+///
+/// The numeric types also come with builtin methods to perform common
+/// operations, such as [`abs`]($sus::num::i32::abs),
+/// [`pow`]($sus::num::i32::pow), [`log10`]($sus::num::i32::log10), or
+/// [`leading_ones`]($sus::num::i32::leading_ones).
+///
 /// # Conversions
 ///
-/// To convert to and from integer values, use
-/// [`sus::into`]($sus::construct::into) when
-/// [`Into<From, To>`]($sus::construct::Into) is satisfied between the two
-/// types for lossless conversion. Otherwise use
-/// [`sus::try_into`]($sus::construct::try_into) when
-/// [`TryInto<From, To>`]($sus::construct::TryInto) is satisfied to convert
-/// and handle cases where the value can not be represented in the target type.
-///
-/// To convert between floating point types, use
-/// [`sus::into(x)`]($sus::construct::into) to losslessly promote `x` to a
-/// larger type ([`f32`]($sus::num::f32) to [`f64`]($sus::num::f64)) or
-/// `sus::try_into(x)` to convert `x` to a smaller type
-/// ([`f64`]($sus::num::f64) to [`f32`]($sus::num::f32)).
-///
-/// Use [`sus::mog<T>()`]($sus::construct::mog) to do a lossy type coercion
-/// (like `static_cast<T>()`) between integer and floating point types, or C++
-/// primitive integers, floating point, or enums. When converting to a larger
-/// signed integer type, the value will be sign-extended.
+/// To explicitly invoke a lossless conversion, use
+/// [`From`]($sus::construct::From). Use [`Into`]($sus::construct::Into) to
+/// constain inputs in generic code, and [`sus::into()`]($sus::construct::into)
+/// to type-deduce for conversions. Some lossless conversions are also allowed
+/// to happen implicitly, though explicit conversion is better.
+///
+/// To convert and handle the case where data is lost, use
+/// [`TryFrom`]($sus::construct::TryFrom), or
+/// [`TryInto`]($sus::construct::TryInto) in generic code. Using
+/// `T::try_from(U).unwrap()` is a quick way to convert and find out if there
+/// are values out of range, or to terminate on malicious inputs. Or
+/// `T::try_from(U).unwrap_or_default()` to convert to the input value or else
+/// to zero.
+///
+/// To convert with truncation/loss of data, like `static_cast`, use
+/// [`sus::mog<T>()`]($sus::construct::mog). It can convert between
+/// integers, floats, and enums, for both safe numerics and primitives. See
+/// [Casting numeric types](
+/// $sus::construct::Transmogrify#casting-numeric-types) for the rules of
+/// conversion through [`mog`]($sus::construct::mog).
 namespace num {}
 
 }  // namespace sus
diff --git a/sus/tuple/tuple.h b/sus/tuple/tuple.h
index c46df7f2f..89ef670a9 100644
--- a/sus/tuple/tuple.h
+++ b/sus/tuple/tuple.h
@@ -44,7 +44,7 @@
 
 namespace sus {
 /// The [`Tuple`]($sus::tuple_type::Tuple) type, and the
-/// [`tuple`]($sus::tuple_type::tuple) type-deduction function.
+/// [`tuple`]($sus::tuple_type::tuple) type-deduction constructor function.
 namespace tuple_type {}
 }  // namespace sus
 

From 98335010d549aa940d2699029b94e139eba66e08 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sat, 9 Sep 2023 14:17:52 -0400
Subject: [PATCH 03/31] codify static_cast in comment

---
 sus/construct/transmogrify.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sus/construct/transmogrify.h b/sus/construct/transmogrify.h
index 802330ed4..20ae16ac4 100644
--- a/sus/construct/transmogrify.h
+++ b/sus/construct/transmogrify.h
@@ -87,7 +87,7 @@ struct TransmogrifyImpl<T, T> {
 ///   * Values smaller than the minimum integer value, including
 ///     [`f32::NEG_INFINITY`]($sus::num::f32::NEG_INFINITY), will saturate to
 ///     the minimum value of the integer type.
-/// * Casting from an integer to a float will perform a static_cast, which
+/// * Casting from an integer to a float will perform a `static_cast`, which
 ///   converts to the nearest floating point value. The rounding direction for
 ///   values that land between representable floating point values is
 ///   implementation defined (per C++20 Section 7.3.10).

From a588a975b43ff166324b8e14a237d07494aac1b0 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sat, 9 Sep 2023 14:18:04 -0400
Subject: [PATCH 04/31] Call static ctor methods "type-deduction constructor
 funtions" in docs

---
 sus/result/result.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sus/result/result.h b/sus/result/result.h
index 510cd4c9c..c795c805e 100644
--- a/sus/result/result.h
+++ b/sus/result/result.h
@@ -47,7 +47,7 @@
 namespace sus {
 /// The [`Result`]($sus::result::Result) type, and the
 /// [`ok`]($sus::result::ok) and [`err`]($sus::result::err)
-/// type-deduction functions.
+/// type-deduction constructor functions.
 namespace result {}
 }  // namespace sus
 

From a12c38a52931213dca81e19fa71d785283689463 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sat, 9 Sep 2023 14:18:34 -0400
Subject: [PATCH 05/31] Replace use of FnOnceRef with FnOnce in Peekable

---
 sus/iter/adaptors/peekable.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sus/iter/adaptors/peekable.h b/sus/iter/adaptors/peekable.h
index 0b7270ed2..eb664c65f 100644
--- a/sus/iter/adaptors/peekable.h
+++ b/sus/iter/adaptors/peekable.h
@@ -74,7 +74,7 @@ class [[nodiscard]] Peekable final
   /// If `func` returns `true` for the next value of this iterator, consume and
   /// return it. Otherwise, return `None`.
   constexpr Option<Item> next_if(
-      ::sus::fn::FnOnceRef<bool(const std::remove_reference_t<Item>&)>
+      ::sus::fn::FnOnce<bool(const std::remove_reference_t<Item>&)> auto
           pred) noexcept {
     Option<Item> o = next();
     if (o.is_some() && ::sus::fn::call_once(::sus::move(pred), o.as_value())) {

From a0244c3720db0cb7eaa2ff239796bf8cfe3f595c Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sat, 9 Sep 2023 14:41:46 -0400
Subject: [PATCH 06/31] Link to fn concepts from the call functions

---
 sus/fn/fn_concepts.h | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/sus/fn/fn_concepts.h b/sus/fn/fn_concepts.h
index fdd7aed80..e47969a9d 100644
--- a/sus/fn/fn_concepts.h
+++ b/sus/fn/fn_concepts.h
@@ -380,11 +380,11 @@ concept Fn = requires {
   requires FnOnce<F, S...>;
 };
 
-/// Invokes the `FnOnce`, passing any given arguments along, and returning the
-/// result.
+/// Invokes the [`FnOnce`]($sus::fn::FnOnce), passing any given arguments along,
+/// and returning the result.
 ///
 /// This function is like
-/// [`std::invoke()`](https://en.cppreference.com/w/cpp/utility/functional/invoke)
+/// [`std::invoke`](https://en.cppreference.com/w/cpp/utility/functional/invoke)
 /// but it provides the following additional guiderails:
 /// * Verifies that the thing being invoked is being moved from so that the
 ///   correct overload will be invoked.
@@ -395,11 +395,11 @@ sus_always_inline constexpr decltype(auto) call_once(F&& f, Args&&... args)
   return std::invoke(sus::move(f), sus::forward<Args>(args)...);
 }
 
-/// Invokes the `FnMut`, passing any given arguments along, and returning the
-/// result.
+/// Invokes the [`FnMut`]($sus::fn::FnMut), passing any given arguments along,
+/// and returning the result.
 ///
 /// This function is like
-/// [`std::invoke()`](https://en.cppreference.com/w/cpp/utility/functional/invoke)
+/// [`std::invoke`](https://en.cppreference.com/w/cpp/utility/functional/invoke)
 /// but it provides the following additional guiderails:
 /// * Verifies that the thing being invoked is called as a mutable lvalue so
 ///   that the correct overload will be invoked.
@@ -410,11 +410,11 @@ sus_always_inline constexpr decltype(auto) call_mut(F&& f, Args&&... args) {
                      sus::forward<Args>(args)...);
 }
 
-/// Invokes the `Fn`, passing any given arguments along, and returning the
-/// result.
+/// Invokes the [`Fn`]($sus::fn::Fn), passing any given arguments along,
+/// and returning the result.
 ///
 /// This function is like
-/// [`std::invoke()`](https://en.cppreference.com/w/cpp/utility/functional/invoke)
+/// [`std::invoke`](https://en.cppreference.com/w/cpp/utility/functional/invoke)
 /// but it provides the following additional guiderails:
 /// * Verifies that the thing being invoked is called as a const lvalue so
 ///   that the correct overload will be invoked.

From 3e82b7664c8f4c8166a6e134f6aa5fa9313b16b7 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sat, 9 Sep 2023 14:44:09 -0400
Subject: [PATCH 07/31] Links on fn return type concepts

---
 sus/fn/fn_concepts.h | 33 +++++++++++++++++++++++----------
 1 file changed, 23 insertions(+), 10 deletions(-)

diff --git a/sus/fn/fn_concepts.h b/sus/fn/fn_concepts.h
index e47969a9d..bb1903b0e 100644
--- a/sus/fn/fn_concepts.h
+++ b/sus/fn/fn_concepts.h
@@ -26,24 +26,33 @@
 
 namespace sus::fn {
 
-/// When used as the return type of the function signature in `Fn`, `FnMut` and
-/// `FnOnce`, the concepts will match against any return type from a functor
-/// except `void`.
+/// When used as the return type of the function signature in
+/// [`Fn`]($sus::fn::Fn), [`FnMut`]($sus::fn::FnMut) and
+/// [`FnOnce`]($sus::fn::FnOnce), the concepts will match against any return
+/// type from a functor except `void`.
+///
+/// Use [`Anything`]($sus::fn::Anything) to include `void` as an accepted return
+/// type.
 struct NonVoid {
   template <class T>
   constexpr NonVoid(T&&) noexcept {}
 };
 
-/// When used as the return type of the function signature in `Fn`, `FnMut` and
-/// `FnOnce`, the concepts will match against any return type from a functor
-/// including `void`.
+/// When used as the return type of the function signature in
+/// [`Fn`]($sus::fn::Fn), [`FnMut`]($sus::fn::FnMut) and
+/// [`FnOnce`]($sus::fn::FnOnce), the concepts will match against any return
+/// type from a functor including `void`.
+///
+/// Use [`NonVoid`]($sus::fn::NonVoid) to exclude `void` as an accepted return
+/// type.
 struct Anything {
   template <class T>
   constexpr Anything(T&&) noexcept {}
 };
 
-/// The version of a callable object that is called on an rvalue (moved-from)
-/// receiver. A `FnOnce` is typically the best fit for any callable that will
+/// The version of a callable object that may be called only once.
+///
+/// A `FnOnce` is typically the best fit for any callable that will
 /// only be called at most once. However when a template (or constexpr) is not
 /// required, receiving a `FnOnceRef` instead of `FnOnce auto&&` will typically
 /// produce less code by using type erasure to avoid template instantiation.
@@ -154,7 +163,9 @@ concept FnOnce = requires {
 };
 
 /// The version of a callable object that is allowed to mutate internal state
-/// and may be called multiple times. A `FnMut` is typically the best fit for
+/// and may be called multiple times.
+///
+/// A `FnMut` is typically the best fit for
 /// any callable that may be called one or more times. However when a template
 /// (or constexpr) is not required, receiving a `FnMutRef` instead of `FnMut
 /// auto` will typically produce less code by using type erasure to avoid
@@ -268,7 +279,9 @@ concept FnMut = requires {
 };
 
 /// The version of a callable object that may be called multiple times without
-/// mutating internal state. A `Fn` is useful for a callable that is received as
+/// mutating internal state.
+///
+/// A `Fn` is useful for a callable that is received as
 /// a const reference to indicate it and may be called one or more times and
 /// does not change between call. However when a template (or constexpr) is not
 /// required, receiving a `FnRef` instead of `const Fn auto&` will typically

From a6a6c56a44eb75273c0e2b0dfc2e49ff8e754c46 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 02:48:22 -0400
Subject: [PATCH 08/31] Add DynConcept, Dyn, and make DynError satisfy
 DynConcept

Generalize Box<DynError>::from(Error auto) to work with any DynConcept
type erasure, with Box<DynC>::from(C auto).
---
 sus/CMakeLists.txt          |   2 +
 sus/boxed/box.h             |  44 ++--
 sus/boxed/dyn.h             | 393 ++++++++++++++++++++++++++++++++++++
 sus/boxed/dyn_unittest.cc   | 327 ++++++++++++++++++++++++++++++
 sus/error/error.h           |  46 +++--
 sus/error/error_unittest.cc |  13 +-
 6 files changed, 794 insertions(+), 31 deletions(-)
 create mode 100644 sus/boxed/dyn.h
 create mode 100644 sus/boxed/dyn_unittest.cc

diff --git a/sus/CMakeLists.txt b/sus/CMakeLists.txt
index 9f84a8a60..f96a28fc0 100644
--- a/sus/CMakeLists.txt
+++ b/sus/CMakeLists.txt
@@ -25,6 +25,7 @@ target_sources(subspace PUBLIC
     "assertions/panic.cc"
     "assertions/unreachable.h"
     "boxed/box.h"
+    "boxed/dyn.h"
     "choice/__private/all_values_are_unique.h"
     "choice/__private/index_of_value.h"
     "choice/__private/index_type.h"
@@ -252,6 +253,7 @@ if(${SUBSPACE_BUILD_TESTS})
         "assertions/panic_unittest.cc"
         "assertions/unreachable_unittest.cc"
         "boxed/box_unittest.cc"
+        "boxed/dyn_unittest.cc"
         "choice/choice_types_unittest.cc"
         "choice/choice_unittest.cc"
         "construct/transmogrify_unittest.cc"
diff --git a/sus/boxed/box.h b/sus/boxed/box.h
index 9f5d795f0..61176a574 100644
--- a/sus/boxed/box.h
+++ b/sus/boxed/box.h
@@ -36,6 +36,14 @@ namespace sus::boxed {
 
 // TODO: Box has an allocator parameter in Rust but std::unique_ptr does not.
 // Which do we do?
+
+/// A heap allocated object.
+///
+/// # Box implements some concepts for its inner type
+/// For some concepts in the Subspace library, if `T` satisfies the concept,
+/// then `Box<T>` will as well, forwarding through to the inner heap-allocated
+/// object. Those concepts are:
+/// * [`Error`]($sus::error::Error).
 template <class T>
 class [[sus_trivial_abi]] Box final {
   static_assert(!std::is_reference_v<T>, "Box of a reference is not allowed.");
@@ -168,24 +176,29 @@ class [[sus_trivial_abi]] Box final {
     return t_;
   }
 
-  /// Satisfies the [`From<E>`]($sus::construct::From) concept for
-  /// [`Box`]($sus::boxed::Box)`<`[`DynError`]($sus::error::DynError)`>` when
-  /// `E` satisfies [`Error`]($sus::error::Error). This conversion moves and
-  /// type-erases `E` into a heap-alloocated
-  /// [`DynError`]($sus::error::DynError).
+  /// For a type-erased `DynC` of a concept `C`, `Box<DynC>` can be
+  /// constructed from a type that satisfies `C`.
   ///
-  /// #[doc.overloads=dynerror.from.error]
-  template <::sus::error::Error E>
-    requires(sus::mem::Move<E>)
-  constexpr static Box from(E e) noexcept
-    requires(std::same_as<T, ::sus::error::DynError>)
+  /// This satisfies the [`From<DynC, C>`]($sus::construct::From) concept for
+  /// constructing `Box<DynC>` from any type that satisfies the concept `C`. It
+  /// allows returning a non-templated type satisfying a concept.
+  ///
+  /// See [`DynConcept`]($sus::boxed::DynConcept) for more on type erasure of
+  /// concept-satisfying types.
+  template <sus::mem::Move U>
+  constexpr static Box from(U u) noexcept
+    requires(std::same_as<U, std::remove_cvref_t<U>> &&  //
+             DynConcept<T, U> &&                         //
+             T::template SatisfiesConcept<U>)
   {
-    using HeapError = ::sus::error::DynErrorTyped<E>;
-    auto* heap_e = new HeapError(::sus::move(e));
-    // This implicitly upcasts to the DynError.
-    return Box(FROM_POINTER, heap_e);
+    using DynTyped = T::template DynTyped<U, U>;
+    // This implicitly upcasts to the `DynConcept` type `T`.
+    return Box(FROM_POINTER, new DynTyped(::sus::move(u)));
   }
 
+  /// A `Box<DynError>` can be constructed from a string, which gets type-erased
+  /// into a type that satisfies [`Error`]($sus::error::Error).
+
   /// Satisfies the [`From<std::string>`]($sus::construct::From) concept for
   /// [`Box`]($sus::boxed::Box)`<`[`DynError`]($sus::error::DynError)`>`. This
   /// conversion moves and type-erases the `std::string` into a heap-alloocated
@@ -195,7 +208,8 @@ class [[sus_trivial_abi]] Box final {
   constexpr static Box from(std::string s) noexcept
     requires(std::same_as<T, ::sus::error::DynError>)
   {
-    using HeapError = ::sus::error::DynErrorTyped<__private::StringError>;
+    using HeapError = ::sus::error::DynErrorTyped<__private::StringError,
+                                                  __private::StringError>;
     auto* heap_e = new HeapError(__private::StringError(::sus::move(s)));
     // This implicitly upcasts to the DynError.
     return Box(FROM_POINTER, heap_e);
diff --git a/sus/boxed/dyn.h b/sus/boxed/dyn.h
new file mode 100644
index 000000000..dcc4c8625
--- /dev/null
+++ b/sus/boxed/dyn.h
@@ -0,0 +1,393 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <concepts>
+#include <type_traits>
+
+#include "sus/macros/lifetimebound.h"
+#include "sus/mem/forward.h"
+
+namespace sus::boxed {
+
+/// A concept for generalized type erasure of concepts, allowing use of a
+/// concept-satisfying type `T` without knowing the concrete type `T`.
+///
+/// By providing a virtual type-erasure class that satisifies `DynConcept` along
+/// with a concept `C`, it allows the use of generic concept-satisfying objects
+/// without the use of templates.
+/// This means a function accepting a concept-satisying object as
+/// a parameter can:
+/// * Be written outside of the header.
+/// * Be a virtual method.
+/// * Be part of a non-header-only library API.
+///
+/// We can not specify a concept as a type parameter so there is a level of
+/// indirection involved and the concept itself is not named.
+///
+/// To type-erase a concept `C`, there must be a virtual class `DynC` declared
+/// that satisfies this `DynConcept` concept for all concrete types `ConcreteT`
+/// which satisfy the concept `C` being type-erased.
+///
+/// # Performing the type erasure
+///
+/// To type-erase a concept-satisfying object into the heap, use
+/// [`Box`]($sus::boxed::Box), such as `Box<DynC>` to hold a type-erased
+/// heap-allocated object that is known to satisfy the concept `C`.
+///
+/// Then, `Box<DynC>` will come with a method
+/// [`from`]($sus::boxed::Box::from!dync) that lifts any object satisfying the
+/// concept `C` into the heap and type-erases it to `DynC`. This implies that
+/// [`Box<DynC>`]($sus::boxed::Box) will satisfy the
+/// [`From`]($sus::construct::From) concept, and can be constructed with type
+/// deduction through [`sus::into()`]($sus::construct::into) or
+/// explicitly with `Box<DynC>::from(sus::move(satisfies_c))`.
+///
+/// To type-erase a concept-satisfying object into a `DynC` reference without
+/// heap allocation, use [`dyn`]($sus::boxed::dyn), such as `dyn<DynC>(x)` to
+/// construct a type-erased reference to an object `x` that is known to satisfy
+/// the concept `C`.
+///
+/// The [`dyn`]($sus::boxed::dyn) function, and its returned type should only
+/// appear in function call arguments. The returned type
+/// [`Dyn`]($sus::boxed::Dyn) can not be moved, and it only converts a
+/// reference to a `ConcreteT` into a reference to `DynC`.
+/// This can be used to call functions that accept a type-erased concept
+/// by reference, such as with a `const DynC&` parameter.
+///
+/// # Type erasure of concepts in the Subspace library
+///
+/// Some concepts in the Subspace library come with a virtual type-erasure class
+/// that satisfies `DynConcept` and can be type-erased into `Box<DynC>` for the
+/// concept `C`:
+/// * [`Error`]($sus::error::Error)
+/// * [`Fn`]($sus::fn::Fn)
+/// * [`FnMut`]($sus::fn::FnMut)
+/// * [`FnOnce`]($sus::fn::FnOnce)
+///
+/// For some concepts in the Subspace library, `Box<DynC>` will also satisfy the
+/// concept `C` itself, without having use the inner type. See
+/// [Box implements some concepts for its inner type](
+/// $sus::boxed::Box#box-implements-some-concepts-for-its-inner-type).
+///
+/// Since the actual type is erased, it can not be moved or copied. While it can
+/// be constructed on the stack or the heap, any access to it other than its
+/// initial declaration must be through a pointer or reference, similar to
+/// [`Pin<T>`](https://doc.rust-lang.org/std/pin/struct.Pin.html) types in
+/// Rust.
+///
+/// # Examples
+///
+/// Providing the mechanism to type erase objects that satisfy a concept named
+/// `MyConcept` through a `DynMyConcept` class:
+/// ```
+/// // A concept which requires a single const-access method named `concept_fn`.
+/// template <class T>
+/// concept MyConcept = requires(const T& t) {
+///   { t.concept_fn() } -> std::same_as<void>;
+/// };
+///
+/// template <class T, class Store>
+/// class DynMyConceptTyped;
+///
+/// class DynMyConcept {
+///   sus_dyn_concept(MyConcept, DynMyConcept, DynMyConceptTyped);
+///
+///  public:
+///   // Pure virtual concept API.
+///   virtual void concept_fn() const = 0;
+/// };
+/// // Verifies that DynMyConcept also satisfies MyConcept, which is required.
+/// static_assert(MyConcept<DynMyConcept>);
+///
+/// template <class T, class Store>
+/// class DynMyConceptTyped final : public DynMyConcept {
+///   sus_dyn_concept_typed(MyConcept, DynMyConcept, DynMyConceptTyped, v);
+///
+///   // Virtual concept API implementation.
+///   void concept_fn() const override { return v.concept_fn(); };
+/// };
+///
+/// // A type which satiesfies `MyConcept`.
+/// struct MyConceptType {
+///   void concept_fn() const {}
+/// };
+///
+/// int main() {
+///   // Verifies that DynMyConcept is functioning correctly, testing it against
+///   // a type that satisfies MyConcept.
+///   static_assert(sus::boxed::DynConcept<DynMyConcept, MyConceptType>);
+///
+///   auto b = [](Box<DynMyConcept> c) { c->concept_fn(); };
+///   // `Box<DynMyConcept>` constructs from `MyConceptType`.
+///   b(sus::into(MyConceptType()));
+///
+///   auto d = [](const DynMyConcept& c) { c.concept_fn(); };
+///   // `MyConceptType` converts to `const MyConcept&` with `sus::dyn()`.
+///   d(sus::dyn<const DynMyConcept>(MyConceptType()));
+/// }
+/// ```
+///
+/// An identical example to above, with a `DynMyConcept` class providing type
+/// erasure for the `MyConcept` concept, however without the use of the helper
+/// macros, showing all the required machinery:
+/// ```
+/// // A concept which requires a single const-access method named `concept_fn`.
+/// template <class T>
+/// concept MyConcept = requires(const T& t) {
+///   { t.concept_fn() } -> std::same_as<void>;
+/// };
+///
+/// template <class T, class Store>
+/// class DynMyConceptTyped;
+///
+/// class DynMyConcept {
+///  public:
+///   // Pure virtual concept API.
+///   virtual void concept_fn() const = 0;
+///   template <class T>
+///
+///   static constexpr bool SatisfiesConcept = MyConcept<T>;
+///   template <class T, class Store>
+///   using DynTyped = DynMyConceptTyped<T, Store>;
+///
+///   DynMyConcept() = default;
+///   virtual ~DynMyConcept() = default;
+///   DynMyConcept(DynC&&) = delete;
+///   DynMyConcept& operator=(DynMyConcept&&) = delete;
+/// };
+/// // Verifies that DynMyConcept also satisfies MyConcept, which is required.
+/// static_assert(MyConcept<DynMyConcept>);
+///
+/// template <class T, class Store>
+/// class DynMyConceptTyped final : public DynMyConcept {
+///  public:
+///   // Virtual concept API implementation.
+///   void concept_fn() const override { return c_.concept_fn(); };
+///
+///   constexpr DynMyConceptTyped(Store&& c) : c_(::sus::forward<Store>(c)) {}
+///
+///  private:
+///   Store c_;
+/// };
+///
+/// // A type which satiesfies `MyConcept`.
+/// struct MyConceptType {
+///   void concept_fn() const {}
+/// };
+///
+/// int main() {
+///   // Verifies that DynMyConcept is functioning correctly, testing it against
+///   // a type that satisfies MyConcept.
+///   static_assert(sus::boxed::DynConcept<DynMyConcept, MyConceptType>);
+///
+///   auto b = [](Box<DynMyConcept> c) { c->concept_fn(); };
+///   // `Box<DynMyConcept>` constructs from `MyConceptType`.
+///   b(sus::into(MyConceptType()));
+///
+///   auto d = [](const DynMyConcept& c) { c.concept_fn(); };
+///   // `MyConceptType` converts to `const MyConcept&` with `sus::dyn()`.
+///   d(sus::dyn<const DynMyConcept>(MyConceptType()));
+/// }
+/// ```
+template <class DynC, class ConcreteT>
+concept DynConcept = requires {
+  // The types are not qualified or references.
+  requires std::same_as<DynC, std::remove_cvref_t<DynC>>;
+  requires std::same_as<ConcreteT, std::remove_cvref_t<ConcreteT>>;
+
+  // The SatisfiesConcept bool tests against the concept.
+  { DynC::template SatisfiesConcept<ConcreteT> } -> std::same_as<const bool&>;
+  // The `DynTyped` type alias names the typed subclass. The `DynTyped` class
+  // has two template parameters, the concrete type and the storage type (value
+  // or reference).
+  typename DynC::template DynTyped<ConcreteT, ConcreteT>;
+
+  // The type-erased `DynC` must also satisfy the concept, so it can be used
+  // in templated code still as well.
+  requires DynC::template SatisfiesConcept<DynC>;
+
+  // The typed class is a subclass of the type-erased `DynC` base class, and is
+  // final.
+  requires std::is_base_of_v<
+      DynC, typename DynC::template DynTyped<ConcreteT, ConcreteT>>;
+  requires std::is_final_v<
+      typename DynC::template DynTyped<ConcreteT, ConcreteT>>;
+
+  // The type-erased `DynC` can not be moved (which would slice the typed
+  // subclass off).
+  requires !std::is_move_constructible_v<DynC>;
+  requires !std::is_move_assignable_v<DynC>;
+};
+
+/// Type erases a reference to a `ConcreteT` which satisfies a concept `C`,
+/// into a reference to `DynC`. Returned from [`dyn`]($sus::boxed::dyn).
+///
+/// Use [`dyn`]($sus::boxed::dyn) to convert to a `DynC` reference instead of
+/// constructing this type directly.
+///
+/// See [`DynConcept`]($sus::boxed::DynConcept) for more on type erasure of
+/// concept-satisfying types.
+template <class DynC, class ConcreteT>
+class [[nodiscard]] Dyn {
+ public:
+  static_assert(std::same_as<const DynC, const std::remove_cvref_t<DynC>>,
+                "DynC can be const-qualified but not a reference");
+  static_assert(std::same_as<ConcreteT, std::remove_cvref_t<ConcreteT>>,
+                "ConcreteT can not be qualified or a reference");
+
+  static_assert(
+      DynC::template SatisfiesConcept<ConcreteT>,
+      "ConcreteT must satisfy the concept that DynC type-erases for.");
+
+  /// Construct a `Dyn<DynC, T>` from a mutable reference to `T`, which will
+  /// vend a mutable reference `DynC&`.
+  ///
+  /// #[doc.overloads=mut]
+  Dyn(ConcreteT& concrete sus_lifetimebound)
+    requires(!std::is_const_v<DynC>)
+      : dyn_(concrete) {}
+  /// #[doc.overloads=mut]
+  Dyn(ConcreteT&& concrete sus_lifetimebound)
+    requires(!std::is_const_v<DynC>)
+      : dyn_(concrete) {}
+  /// Construct a `Dyn<const DynC, T>` from a reference to `T`, which will
+  /// vend a const reference `const DynC&`.
+  ///
+  /// #[doc.overloads=const]
+  Dyn(const ConcreteT& concrete sus_lifetimebound)
+    requires(std::is_const_v<DynC>)
+      // This drops the const qualifier on `concrete` however we have a const
+      // qualifier on `DynC` (checked by the requires clause on this
+      // constructor) which prevents the `concrete` from being accessed in a
+      // non-const way through the `operator DynC&` overloads.
+      : dyn_(const_cast<ConcreteT&>(concrete)) {}
+
+  /// Converts the reference to `ConcreteT` into a `DynC` reference.
+  operator const DynC&() const&& { return dyn_; }
+  operator DynC&() &&
+    requires(!std::is_const_v<DynC>)
+  {
+    return dyn_;
+  }
+
+  /// `Dyn` can not be moved.
+  ///
+  /// `Dyn` only exists as a temporary to convert a
+  /// concrete reference to a concept type to into a type-erased reference.
+  Dyn(Dyn&&) = delete;
+  /// `Dyn` can not be moved.
+  ///
+  /// `Dyn` only exists as a temporary to convert a
+  /// concrete reference to a concept type to into a type-erased reference.
+  Dyn& operator=(Dyn&&) = delete;
+
+ private:
+  /// The typed subclass of `DynC` which holds the reference to `ConcreteT`.
+  typename DynC::template DynTyped<ConcreteT, ConcreteT&> dyn_;
+};
+
+/// Type erases a reference to a `ConcreteT` which satisfies a concept `C`,
+/// into a reference to `DynC`.
+///
+/// Use `dyn<DynC>(x)` to convert a mutable reference to `x` into `DynC&` and
+/// `dyn<const DynC>(x)` to convert a const or mutable reference to `x` into
+/// `const Dyn&`.
+///
+/// Type erasure into `DynC` allows calling a method that receives a `DynC`
+/// reference, such as `const DynC&`, without requiring a heap allocation into
+/// a `Box<DynC>`.
+///
+/// See [`DynConcept`]($sus::boxed::DynConcept) for more on type erasure of
+/// concept-satisfying types.
+template <class DynC, class ConcreteT>
+  requires(std::same_as<DynC, std::remove_cvref_t<DynC>> &&  //
+           std::same_as<ConcreteT, std::remove_cvref_t<ConcreteT>>)
+constexpr Dyn<DynC, ConcreteT> dyn(ConcreteT& t sus_lifetimebound) noexcept {
+  return Dyn<DynC, ConcreteT>(t);
+}
+template <class DynC, class ConcreteT>
+  requires(std::same_as<DynC, std::remove_cvref_t<DynC>> &&            //
+           std::same_as<ConcreteT, std::remove_cvref_t<ConcreteT>> &&  //
+           std::is_rvalue_reference_v<ConcreteT &&>)
+constexpr Dyn<DynC, ConcreteT> dyn(ConcreteT&& t sus_lifetimebound) noexcept {
+  return Dyn<DynC, ConcreteT>(t);
+}
+template <class DynC, class ConcreteT>
+  requires(std::same_as<const DynC, const std::remove_cvref_t<DynC>> &&
+           std::same_as<ConcreteT, std::remove_cvref_t<ConcreteT>> &&
+           std::is_const_v<DynC>)
+constexpr Dyn<DynC, ConcreteT> dyn(
+    const ConcreteT& t sus_lifetimebound) noexcept {
+  return Dyn<DynC, ConcreteT>(t);
+}
+
+}  // namespace sus::boxed
+
+// Promote `dyn` to the top `sus` namespace.
+namespace sus {
+using sus::boxed::dyn;
+}
+
+/// Macro to help implement `DynC` for a concept `C`. The macro is placed in the
+/// body of the `DynC` class.
+///
+/// Here `DynC` is used as a placeholder name to refer to the virtual class
+/// that type-erases for the concept `C`. The type erasure class is typically
+/// named to match the concept, with a "Dyn" prefix. The type-aware subclass
+/// of the type erasure class is typically named to match the concept with a
+/// "Dyn" prefix and a "Typed" suffix.
+///
+/// The `Concept` parameter is the concept `C` for which types are being
+/// type-erased.
+///
+/// The `DynConcept` parameter is the name of the type-erasure
+/// class `DynC` which the macro is written within, and which has a pure virtual
+/// interface matching the concept's requirements.
+///
+/// The `DynConceptTyped`
+/// parameter is the type-aware subclass of `DynC` which contains the
+/// `sus_dyn_concept_typed` macro in its body, and the
+/// implementation of the virtual interface that forwards calls through to the
+/// concrete type.
+///
+/// See [`DynConcept`]($sus::boxed::DynConcept) for more on type erasure of
+/// concept-satisfying types, and [DynConcept examples](
+/// $sus::boxed::DynConcept#examples) for examples of using the macro.
+#define sus_dyn_concept(Concept, DynConcept, DynConceptTyped)  \
+ public:                                                       \
+  template <class ConcreteT>                                   \
+  static constexpr bool SatisfiesConcept = Concept<ConcreteT>; \
+  template <class ConcreteT, class Store>                      \
+  using DynTyped = DynConceptTyped<ConcreteT, Store>;          \
+                                                               \
+  DynConcept() = default;                                      \
+  virtual ~DynConcept() = default;                             \
+  DynConcept(DynConcept&&) = delete;                           \
+  DynConcept& operator=(DynConcept&&) = delete
+
+/// Macro to help implement `DynCTyped` for a concept `C`. The macro is placed
+/// in the body of the `DynCTyped` class.
+///
+/// See the TODO: link [`sus_dyn_concept`] macro for more, and
+/// [DynConcept examples]($sus::boxed::DynConcept#examples) for examples
+/// of using the macro.
+#define sus_dyn_concept_typed(Concept, DynConcept, DynConceptTyped, VarName)  \
+ public:                                                                      \
+  static_assert(Concept<T>);                                                  \
+  constexpr DynConceptTyped(Store&& c) : VarName(::sus::forward<Store>(c)) {} \
+                                                                              \
+ private:                                                                     \
+  Store VarName;
diff --git a/sus/boxed/dyn_unittest.cc b/sus/boxed/dyn_unittest.cc
new file mode 100644
index 000000000..5cd997924
--- /dev/null
+++ b/sus/boxed/dyn_unittest.cc
@@ -0,0 +1,327 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "sus/boxed/dyn.h"
+
+#include "googletest/include/gtest/gtest.h"
+#include "sus/boxed/box.h"
+#include "sus/prelude.h"
+
+namespace {
+using namespace sus::boxed;
+
+/// Some concept which requires two functions.
+template <class T>
+concept C = requires(const T& c, T& m) {
+  { c.concept_fn() } -> std::same_as<i32>;
+  { m.concept_fn_mut() } -> std::same_as<i32>;
+};
+
+template <C T, class Store>
+struct DynCTyped;
+
+/// The C concept when type-erased.
+struct DynC {
+  template <class T>
+  static constexpr bool SatisfiesConcept = C<T>;
+  template <class T, class Store>
+  using DynTyped = DynCTyped<T, Store>;
+
+  DynC() = default;
+  virtual ~DynC() = default;
+  DynC(DynC&&) = delete;
+  DynC& operator=(DynC&&) = delete;
+
+  // Virtual concept API.
+  virtual i32 concept_fn() const = 0;
+  virtual i32 concept_fn_mut() = 0;
+};
+
+/// DynC satisfies concept C.
+static_assert(C<DynC>);
+
+/// The implementation of type-erasure for the C concept.
+template <C T, class Store>
+struct DynCTyped final : public DynC {
+  constexpr DynCTyped(Store&& c) : c_(sus::forward<Store>(c)) {}
+
+  constexpr i32 concept_fn() const override { return c_.concept_fn(); }
+  constexpr i32 concept_fn_mut() override { return c_.concept_fn_mut(); }
+
+ private:
+  Store c_;
+};
+
+/// Foo satisfies concept C.
+struct Foo final {
+  i32 concept_fn() const noexcept { return called_const += 1, called_const; }
+  i32 concept_fn_mut() noexcept { return called_mut += 1, called_mut; }
+
+  mutable i32 called_const;
+  i32 called_mut;
+};
+static_assert(C<Foo>);
+
+/// These act on the `C` concept but without being templated.
+i32 GiveC(const DynC& c) { return c.concept_fn(); }
+i32 GiveCMut(DynC& c) { return c.concept_fn_mut(); }
+Box<DynC> GiveBoxC(Box<DynC> c) { return c; }
+
+/// `DynC` satisfies `DynConcept` with an implementation of `C` (which is `Foo`
+/// here).
+static_assert(sus::boxed::DynConcept<DynC, Foo>);
+
+TEST(Dyn, Box) {
+  // Box::from(C) exists since DynC exists and satisfies `DynConcept` for `C`.
+  {
+    static_assert(sus::construct::From<Box<DynC>, Foo>);
+    auto b = Box<DynC>::from(Foo());
+    EXPECT_EQ(b->concept_fn(), 1);
+    EXPECT_EQ(b->concept_fn(), 2);
+    EXPECT_EQ(b->concept_fn_mut(), 1);
+    const auto bc = sus::move(b);
+    EXPECT_EQ(bc->concept_fn(), 3);
+  }
+  // Into<C, Box> works.
+  {
+    static_assert(sus::construct::Into<Foo, Box<DynC>>);
+    auto b = GiveBoxC(sus::into(Foo()));
+    EXPECT_EQ(b->concept_fn(), 1);
+    EXPECT_EQ(b->concept_fn(), 2);
+    EXPECT_EQ(b->concept_fn_mut(), 1);
+  }
+}
+
+template <class DynC, class Foo, class Ref>
+concept CanGiveCMutFromStruct = requires(Ref r) {
+  { GiveCMut(Dyn<DynC, Foo>(r)) };
+};
+template <class DynC, class Foo, class Ref>
+concept CanGiveCFromStruct = requires(Ref r) {
+  { GiveC(Dyn<DynC, Foo>(r)) };
+};
+
+// Tests the semantics of the struct itself, though it's not used directly.
+TEST(Dyn, DynStruct) {
+  // Mutable.
+  {
+    Foo f;
+
+    static_assert(CanGiveCFromStruct<DynC, Foo, decltype(f)>);
+    static_assert(CanGiveCMutFromStruct<DynC, Foo, decltype(f)>);
+    static_assert(CanGiveCFromStruct<const DynC, Foo, decltype(f)>);
+    // Can't give a const `DynC` to a mutable reference `DynC&`.
+    static_assert(!CanGiveCMutFromStruct<const DynC, Foo, decltype(f)>);
+
+    EXPECT_EQ(GiveC(Dyn<DynC, Foo>(f)), 1);
+    EXPECT_EQ(GiveC(Dyn<DynC, Foo>(f)), 2);
+    EXPECT_EQ(GiveCMut(Dyn<DynC, Foo>(f)), 1);
+    EXPECT_EQ(GiveC(Dyn<const DynC, Foo>(f)), 3);
+    EXPECT_EQ(GiveC(Dyn<const DynC, Foo>(f)), 4);
+    // ERROR: Can't give a const `DynC` to a mutable reference `DynC&`.
+    // GiveCMut(Dyn<const DynC, Foo>(f));
+  }
+  // Const.
+  {
+    const Foo f;
+
+    // Can't use a const `Foo` to construct a mutable `DynC`.
+    static_assert(!CanGiveCFromStruct<DynC, Foo, decltype(f)>);
+    // Can't use a const `Foo` to construct a mutable `DynC&`.
+    static_assert(!CanGiveCMutFromStruct<DynC, Foo, decltype(f)>);
+    static_assert(CanGiveCFromStruct<const DynC, Foo, decltype(f)>);
+    // Can't give a const `DynC` to a mutable reference `DynC&`.
+    static_assert(!CanGiveCMutFromStruct<const DynC, Foo, decltype(f)>);
+
+    EXPECT_EQ(GiveC(Dyn<const DynC, Foo>(f)), 1);
+    EXPECT_EQ(GiveC(Dyn<const DynC, Foo>(f)), 2);
+    // ERROR: Can't use a const `Foo` to construct a mutable `DynC`.
+    // GiveC(Dyn<DynC, Foo>(f));
+    // GiveCMut(Dyn<DynC, Foo>(f));
+    // ERROR: Can't give a const `DynC` to a mutable reference `DynC&`.
+    // GiveCMut(Dyn<const DynC, Foo>(f));
+  }
+
+  // ERROR: Holding a reference to a temporary (on clang only).
+  // TODO: How to test this with a concept?
+  // [[maybe_unused]] auto x = Dyn<DynC, Foo>(Foo());
+}
+
+template <class DynC, class Foo, class Ref>
+concept CanGiveCMut = requires(Ref r) {
+  { GiveCMut(sus::dyn<DynC>(r)) };
+};
+template <class DynC, class Foo, class Ref>
+concept CanGiveC = requires(Ref r) {
+  { GiveC(sus::dyn<DynC>(r)) };
+};
+
+TEST(Dyn, DynFunction) {
+  // Mutable.
+  {
+    Foo f;
+
+    static_assert(CanGiveC<DynC, Foo, decltype(f)>);
+    static_assert(CanGiveCMut<DynC, Foo, decltype(f)>);
+    static_assert(CanGiveC<const DynC, Foo, decltype(f)>);
+    // Can't give a const `DynC` to a mutable reference `DynC&`.
+    static_assert(!CanGiveCMut<const DynC, Foo, decltype(f)>);
+
+    EXPECT_EQ(GiveC(sus::dyn<DynC>(f)), 1);
+    EXPECT_EQ(GiveC(sus::dyn<DynC>(f)), 2);
+    EXPECT_EQ(GiveCMut(sus::dyn<DynC>(f)), 1);
+    EXPECT_EQ(GiveC(sus::dyn<const DynC>(f)), 3);
+    EXPECT_EQ(GiveC(sus::dyn<const DynC>(f)), 4);
+    // ERROR: Can't give a const `DynC` to a mutable reference `DynC&`.
+    // GiveCMut(sus::dyn<const DynC>(f));
+  }
+  // Const.
+  {
+    const Foo f;
+
+    // Can't use a const `Foo` to construct a mutable `DynC`.
+    static_assert(!CanGiveC<DynC, Foo, decltype(f)>);
+    // Can't use a const `Foo` to construct a mutable `DynC&`.
+    static_assert(!CanGiveCMut<DynC, Foo, decltype(f)>);
+    static_assert(CanGiveC<const DynC, Foo, decltype(f)>);
+    // Can't give a const `DynC` to a mutable reference `DynC&`.
+    static_assert(!CanGiveCMut<const DynC, Foo, decltype(f)>);
+
+    EXPECT_EQ(GiveC(sus::dyn<const DynC>(f)), 1);
+    EXPECT_EQ(GiveC(sus::dyn<const DynC>(f)), 2);
+    // ERROR: Can't use a const `Foo` to construct a mutable `DynC`.
+    // GiveC(sus::dyn<DynC>(f));
+    // GiveCMut(sus::dyn<DynC>(f));
+    // ERROR: Can't give a const `DynC` to a mutable reference `DynC&`.
+    // GiveCMut(sus::dyn<const DynC>(f));
+  }
+
+  // ERROR: Holding a reference to a temporary (on clang only).
+  // TODO: How to test this with a concept?
+  // [[maybe_unused]] auto x = sus::dyn<DynC>(Foo());
+}
+
+namespace example_no_macro {
+
+// A concept which requires a single const-access method named `concept_fn`.
+template <class T>
+concept MyConcept = requires(const T& t) {
+  { t.concept_fn() } -> std::same_as<void>;
+};
+
+template <class T, class Store>
+class DynMyConceptTyped;
+
+class DynMyConcept {
+ public:
+  // Pure virtual concept API.
+  virtual void concept_fn() const = 0;
+  template <class T>
+
+  static constexpr bool SatisfiesConcept = MyConcept<T>;
+  template <class T, class Store>
+  using DynTyped = DynMyConceptTyped<T, Store>;
+
+  DynMyConcept() = default;
+  virtual ~DynMyConcept() = default;
+  DynMyConcept(DynC&&) = delete;
+  DynMyConcept& operator=(DynMyConcept&&) = delete;
+};
+// Verifies that DynMyConcept also satisfies MyConcept, which is required.
+static_assert(MyConcept<DynMyConcept>);
+
+template <class T, class Store>
+class DynMyConceptTyped final : public DynMyConcept {
+ public:
+  // Virtual concept API implementation.
+  void concept_fn() const override { return c_.concept_fn(); };
+
+  constexpr DynMyConceptTyped(Store&& c) : c_(sus::forward<Store>(c)) {}
+
+ private:
+  Store c_;
+};
+
+// A type which satiesfies `MyConcept`.
+struct MyConceptType {
+  void concept_fn() const {}
+};
+
+TEST(Dyn, Example_NoMacro) {
+  // Verifies that DynMyConcept is functioning correctly, testing it against
+  // a type that satisfies MyConcept.
+  static_assert(sus::boxed::DynConcept<DynMyConcept, MyConceptType>);
+
+  auto b = [](Box<DynMyConcept> c) { c->concept_fn(); };
+  // `Box<DynMyConcept>` constructs from `MyConceptType`.
+  b(sus::into(MyConceptType()));
+
+  auto d = [](const DynMyConcept& c) { c.concept_fn(); };
+  // `MyConceptType` converts to `const MyConcept&` with `sus::dyn()`.
+  d(sus::dyn<const DynMyConcept>(MyConceptType()));
+}
+
+}  // namespace example_no_macro
+
+namespace example_macro {
+
+// A concept which requires a single const-access method named `concept_fn`.
+template <class T>
+concept MyConcept = requires(const T& t) {
+  { t.concept_fn() } -> std::same_as<void>;
+};
+
+template <class T, class Store>
+class DynMyConceptTyped;
+
+class DynMyConcept {
+  sus_dyn_concept(MyConcept, DynMyConcept, DynMyConceptTyped);
+
+ public:
+  // Pure virtual concept API.
+  virtual void concept_fn() const = 0;
+};
+// Verifies that DynMyConcept also satisfies MyConcept, which is required.
+static_assert(MyConcept<DynMyConcept>);
+
+template <class T, class Store>
+class DynMyConceptTyped final : public DynMyConcept {
+  sus_dyn_concept_typed(MyConcept, DynMyConcept, DynMyConceptTyped, v);
+
+  // Virtual concept API implementation.
+  void concept_fn() const override { return v.concept_fn(); };
+};
+
+// A type which satiesfies `MyConcept`.
+struct MyConceptType {
+  void concept_fn() const {}
+};
+
+TEST(Dyn, Example_Macro) {
+  // Verifies that DynMyConcept is functioning correctly, testing it against
+  // a type that satisfies MyConcept.
+  static_assert(sus::boxed::DynConcept<DynMyConcept, MyConceptType>);
+
+  auto b = [](Box<DynMyConcept> c) { c->concept_fn(); };
+  // `Box<DynMyConcept>` constructs from `MyConceptType`.
+  b(sus::into(MyConceptType()));
+
+  auto d = [](const DynMyConcept& c) { c.concept_fn(); };
+  // `MyConceptType` converts to `const MyConcept&` with `sus::dyn()`.
+  d(sus::dyn<const DynMyConcept>(MyConceptType()));
+}
+
+}  // namespace example_macro
+
+}  // namespace
diff --git a/sus/error/error.h b/sus/error/error.h
index f739f85d0..573a01244 100644
--- a/sus/error/error.h
+++ b/sus/error/error.h
@@ -15,6 +15,7 @@
 #pragma once
 
 #include "fmt/core.h"
+#include "sus/boxed/dyn.h"
 #include "sus/macros/lifetimebound.h"
 #include "sus/option/option.h"
 
@@ -224,6 +225,9 @@ concept HasErrorSource = requires(const T& t) {
 /// single type, as does passing error types through virtual methods or dylib
 /// ABI boundaries.
 ///
+/// See [`DynConcept`]($sus::boxed::DynConcept) for more on type erasure of
+/// [`Error`]($sus::error::Error) types.
+///
 /// ## Opaque erasure
 /// When an application just wants to return an error without exposing the
 /// actual type behind it, use the [`DynError`]($sus::error::DynError) type.
@@ -239,7 +243,7 @@ concept HasErrorSource = requires(const T& t) {
 /// `error` that satisfies [`Error`]($sus::error::Error).
 ///
 /// This is similar to
-/// `&dyn Error` when working with the Rust
+/// `Box<dyn Error>` when working with the Rust
 /// [`Error`](https://doc.rust-lang.org/stable/std/error/trait.Error.html)
 /// trait. However with `DynError`, the error type can be printed/displayed but
 /// no further information can be extracted from the error. Nonetheless this is
@@ -419,7 +423,14 @@ concept Error = requires(const T& t) {
   };
 };
 
-/// A type-erased [`Error`]($sus::error::Error) object.
+template <Error E, class Store>
+struct DynErrorTyped;
+
+/// A type-erased [`Error`]($sus::error::Error) object
+/// which satisfies [`DynConcept`]($sus::boxed::DynConcept)
+/// for all [`Error`]($sus::error::Error)s.
+///
+/// `DynError` also satisfies [`Error`]($sus::error::Error) itself.
 ///
 /// Using this allows the error type to be placed in heap-allocated smart
 /// pointers without templates, and thus without knowing the concrete type.
@@ -438,10 +449,22 @@ struct DynError {
   /// Forwards to the [`Error`]($sus::error::Error) implementation of `E`.
   virtual sus::Option<const DynError&> source() const noexcept = 0;
 
+  // `DynConcept` machinery for type-erasing the `Error` concept.
+
+  /// #[doc.hidden]
   constexpr DynError() = default;
+  /// #[doc.hidden]
   constexpr virtual ~DynError() = default;
+  /// #[doc.hidden]
   DynError(DynError&&) = delete;
+  /// #[doc.hidden]
   DynError&& operator=(DynError&&) = delete;
+  /// #[doc.hidden]
+  template <class ConcreteT>
+  static constexpr bool SatisfiesConcept = Error<ConcreteT>;
+  /// #[doc.hidden]
+  template <class ConcreteT, class Store>
+  using DynTyped = DynErrorTyped<ConcreteT, Store>;
 };
 
 /// Gets a string describing the `error` from an [`Error`]($sus::error::Error)
@@ -463,10 +486,12 @@ constexpr inline sus::Option<const DynError&> error_source(
   }
 }
 
-/// The wrapper around an [`Error`]($sus::error::Error) object that allows it
-/// to be type-erased as [`DynError`]($sus::error::DynError).
-template <class E>
-struct DynErrorTyped : public DynError {
+/// The type-aware subclass of `DynError` for type-erasing an `Error` concept
+/// type through `DynConcept`.
+///
+/// #[doc.hidden]
+template <Error E, class Store>
+struct DynErrorTyped final : public DynError {
   std::string display() const noexcept override {
     return error_display(error_);
   }
@@ -474,15 +499,10 @@ struct DynErrorTyped : public DynError {
     return error_source(error_);
   }
 
-  constexpr DynErrorTyped(E&& error) : error_(::sus::move(error)) {}
-  constexpr ~DynErrorTyped() override = default;
-
-  /// Unwraps and returns the inner error type `E`, discarding the
-  /// `DynErrorTyped`.
-  constexpr E into_inner() && noexcept { return ::sus::move(error_); }
+  constexpr DynErrorTyped(Store&& c) : error_(std::forward<Store>(c)) {}
 
  private:
-  E error_;
+  Store error_;
 };
 
 }  // namespace sus::error
diff --git a/sus/error/error_unittest.cc b/sus/error/error_unittest.cc
index 0f5998112..e1f286255 100644
--- a/sus/error/error_unittest.cc
+++ b/sus/error/error_unittest.cc
@@ -88,6 +88,13 @@ static_assert(sus::error::Error<SuperErrorSideKick>);
 
 namespace {
 using sus::error::Error;
+using sus::error::DynError;
+
+// Tests that DynError functions as a DynConcept.
+static_assert(sus::boxed::DynConcept<DynError, ErrorReason>);
+static_assert(sus::boxed::DynConcept<DynError, ErrorString>);
+static_assert(sus::boxed::DynConcept<DynError, SuperError>);
+static_assert(sus::boxed::DynConcept<DynError, SuperErrorSideKick>);
 
 TEST(Error, Example_ToString) {
   auto err = u32::try_from(-1).unwrap_err();
@@ -96,7 +103,7 @@ TEST(Error, Example_ToString) {
 
 TEST(Error, Example_Result) {
   auto f =
-      [](i32 i) -> sus::result::Result<void, sus::Box<sus::error::DynError>> {
+      [](i32 i) -> sus::result::Result<void, sus::Box<DynError>> {
     if (i > 10) return sus::err(sus::into(ErrorReason::SomeReason));
     if (i < -10) return sus::err(sus::into(ErrorString("too low")));
     return sus::ok();
@@ -145,11 +152,11 @@ TEST(Error, Source) {
   auto super_error = SuperError{.source = sus::into(SuperErrorSideKick())};
   decltype(auto) source = sus::error::error_source(super_error);
   static_assert(
-      std::same_as<decltype(source), sus::Option<const sus::error::DynError&>>);
+      std::same_as<decltype(source), sus::Option<const DynError&>>);
   EXPECT_EQ(source.is_some(), true);
   decltype(auto) inner_source = sus::error::error_source(source.as_value());
   static_assert(std::same_as<decltype(inner_source),
-                             sus::Option<const sus::error::DynError&>>);
+                             sus::Option<const DynError&>>);
   EXPECT_EQ(inner_source.is_some(), false);
 
   EXPECT_EQ(sus::error::error_display(*source), "SuperErrorSideKick is here!");

From 6ee2017c37607eb9a9238e29a74240187261b0a9 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 04:01:40 -0400
Subject: [PATCH 09/31] Add DynFn type-erased virtual classes

---
 sus/CMakeLists.txt        |   1 +
 sus/boxed/box.h           |  32 ++++++++
 sus/boxed/dyn.h           |   6 ++
 sus/boxed/dyn_unittest.cc |  18 ++++-
 sus/fn/fn.h               |   1 +
 sus/fn/fn_dyn.h           | 161 ++++++++++++++++++++++++++++++++++++++
 sus/fn/fn_dyn_unittest.cc |  84 ++++++++++++++++++++
 7 files changed, 301 insertions(+), 2 deletions(-)
 create mode 100644 sus/fn/fn_dyn.h
 create mode 100644 sus/fn/fn_dyn_unittest.cc

diff --git a/sus/CMakeLists.txt b/sus/CMakeLists.txt
index f96a28fc0..6d4d2c2ad 100644
--- a/sus/CMakeLists.txt
+++ b/sus/CMakeLists.txt
@@ -279,6 +279,7 @@ if(${SUBSPACE_BUILD_TESTS})
         "error/error_unittest.cc"
         "fn/fn_box_unittest.cc"
         "fn/fn_concepts_unittest.cc"
+        "fn/fn_dyn_unittest.cc"
         "fn/fn_ref_unittest.cc"
         "iter/compat_ranges_unittest.cc"
         "iter/empty_unittest.cc"
diff --git a/sus/boxed/box.h b/sus/boxed/box.h
index 61176a574..bc09f4f69 100644
--- a/sus/boxed/box.h
+++ b/sus/boxed/box.h
@@ -20,6 +20,8 @@
 
 #include "sus/boxed/__private/string_error.h"
 #include "sus/error/error.h"
+#include "sus/fn/fn_concepts.h"
+#include "sus/fn/fn_dyn.h"
 #include "sus/macros/no_unique_address.h"
 #include "sus/macros/pure.h"
 #include "sus/mem/clone.h"
@@ -270,6 +272,36 @@ class [[sus_trivial_abi]] Box final {
     return ::sus::mem::replace(t_, nullptr);
   }
 
+  /// Consumes the `Box`, calling `f` with the wrapped value before destroying
+  /// it.
+  ///
+  /// This allows the caller to make use of the wrapped object as an rvalue
+  /// without moving out of the wrapped object in a way that leaves the Box with
+  /// a moved-from object within.
+  template <::sus::fn::FnOnce<sus::fn::Anything(T&&)> F>
+  constexpr ::sus::fn::ReturnOnce<F, T&&> consume(F f) && noexcept {
+    ::sus::check_with_message(t_, "Box used after move");
+    ::sus::fn::ReturnOnce<F, T&&> ret =
+        ::sus::fn::call_once(::sus::move(f), sus::move(*t_));
+    delete ::sus::mem::replace(t_, nullptr);
+    return ret;
+  }
+
+  template <class... Args>
+  constexpr sus::fn::Return<T, Args...> operator()(
+      Args&&... args) const noexcept
+    requires(
+        std::same_as<T, ::sus::fn::DynFn<sus::fn::Return<T, Args...>(Args...)>>)
+  {
+    ::sus::check_with_message(t_, "Box used after move");
+    struct Cleanup {
+      constexpr ~Cleanup() noexcept { delete t_; }
+      T* t;
+    };
+    auto cleanup = Cleanup(::sus::mem::replace(t_, nullptr));
+    return ::sus::fn::call(*cleanup.t, ::sus::forward<Args>(args)...);
+  }
+
  private:
   enum FromPointer { FROM_POINTER };
   Box(FromPointer, T* t) : t_(t) {}
diff --git a/sus/boxed/dyn.h b/sus/boxed/dyn.h
index dcc4c8625..2c2b77f85 100644
--- a/sus/boxed/dyn.h
+++ b/sus/boxed/dyn.h
@@ -19,6 +19,7 @@
 
 #include "sus/macros/lifetimebound.h"
 #include "sus/mem/forward.h"
+#include "sus/mem/move.h"
 
 namespace sus::boxed {
 
@@ -282,6 +283,11 @@ class [[nodiscard]] Dyn {
   {
     return dyn_;
   }
+  operator DynC&&() &&
+    requires(!std::is_const_v<DynC>)
+  {
+    return ::sus::move(dyn_);
+  }
 
   /// `Dyn` can not be moved.
   ///
diff --git a/sus/boxed/dyn_unittest.cc b/sus/boxed/dyn_unittest.cc
index 5cd997924..a0f436243 100644
--- a/sus/boxed/dyn_unittest.cc
+++ b/sus/boxed/dyn_unittest.cc
@@ -76,6 +76,7 @@ static_assert(C<Foo>);
 /// These act on the `C` concept but without being templated.
 i32 GiveC(const DynC& c) { return c.concept_fn(); }
 i32 GiveCMut(DynC& c) { return c.concept_fn_mut(); }
+i32 GiveCRval(DynC&& c) { return c.concept_fn_mut(); }
 Box<DynC> GiveBoxC(Box<DynC> c) { return c; }
 
 /// `DynC` satisfies `DynConcept` with an implementation of `C` (which is `Foo`
@@ -103,13 +104,17 @@ TEST(Dyn, Box) {
   }
 }
 
+template <class DynC, class Foo, class Ref>
+concept CanGiveCFromStruct = requires(Ref r) {
+  { GiveC(Dyn<DynC, Foo>(r)) };
+};
 template <class DynC, class Foo, class Ref>
 concept CanGiveCMutFromStruct = requires(Ref r) {
   { GiveCMut(Dyn<DynC, Foo>(r)) };
 };
 template <class DynC, class Foo, class Ref>
-concept CanGiveCFromStruct = requires(Ref r) {
-  { GiveC(Dyn<DynC, Foo>(r)) };
+concept CanGiveCRvalFromStruct = requires(Ref r) {
+  { GiveCMut(Dyn<DynC, Foo>(r)) };
 };
 
 // Tests the semantics of the struct itself, though it's not used directly.
@@ -120,9 +125,12 @@ TEST(Dyn, DynStruct) {
 
     static_assert(CanGiveCFromStruct<DynC, Foo, decltype(f)>);
     static_assert(CanGiveCMutFromStruct<DynC, Foo, decltype(f)>);
+    static_assert(CanGiveCRvalFromStruct<DynC, Foo, decltype(f)>);
     static_assert(CanGiveCFromStruct<const DynC, Foo, decltype(f)>);
     // Can't give a const `DynC` to a mutable reference `DynC&`.
     static_assert(!CanGiveCMutFromStruct<const DynC, Foo, decltype(f)>);
+    // Can't give a const `DynC` to an rvalue reference `DynC&&`
+    static_assert(!CanGiveCRvalFromStruct<const DynC, Foo, decltype(f)>);
 
     EXPECT_EQ(GiveC(Dyn<DynC, Foo>(f)), 1);
     EXPECT_EQ(GiveC(Dyn<DynC, Foo>(f)), 2);
@@ -131,6 +139,8 @@ TEST(Dyn, DynStruct) {
     EXPECT_EQ(GiveC(Dyn<const DynC, Foo>(f)), 4);
     // ERROR: Can't give a const `DynC` to a mutable reference `DynC&`.
     // GiveCMut(Dyn<const DynC, Foo>(f));
+
+    EXPECT_EQ(GiveCRval(Dyn<DynC, Foo>(Foo())), 1);
   }
   // Const.
   {
@@ -140,9 +150,13 @@ TEST(Dyn, DynStruct) {
     static_assert(!CanGiveCFromStruct<DynC, Foo, decltype(f)>);
     // Can't use a const `Foo` to construct a mutable `DynC&`.
     static_assert(!CanGiveCMutFromStruct<DynC, Foo, decltype(f)>);
+    // Can't use a const `Foo` to construct an rvalue reference`DynC&&`.
+    static_assert(!CanGiveCRvalFromStruct<const DynC, Foo, decltype(f)>);
     static_assert(CanGiveCFromStruct<const DynC, Foo, decltype(f)>);
     // Can't give a const `DynC` to a mutable reference `DynC&`.
     static_assert(!CanGiveCMutFromStruct<const DynC, Foo, decltype(f)>);
+    // Can't give a const `DynC` to an rvalue reference `DynC&&`
+    static_assert(!CanGiveCRvalFromStruct<const DynC, Foo, decltype(f)>);
 
     EXPECT_EQ(GiveC(Dyn<const DynC, Foo>(f)), 1);
     EXPECT_EQ(GiveC(Dyn<const DynC, Foo>(f)), 2);
diff --git a/sus/fn/fn.h b/sus/fn/fn.h
index e1d31d206..f2a41a109 100644
--- a/sus/fn/fn.h
+++ b/sus/fn/fn.h
@@ -20,4 +20,5 @@
 #include "sus/fn/fn_box_impl.h"
 #include "sus/fn/fn_concepts.h"
 #include "sus/fn/fn_ref.h"
+#include "sus/fn/fn_dyn.h"
 // IWYU pragma: end_exports
diff --git a/sus/fn/fn_dyn.h b/sus/fn/fn_dyn.h
new file mode 100644
index 000000000..bee46ec70
--- /dev/null
+++ b/sus/fn/fn_dyn.h
@@ -0,0 +1,161 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// IWYU pragma: private, include "sus/fn/fn.h"
+// IWYU pragma: friend "sus/.*"
+#pragma once
+
+#include "sus/boxed/dyn.h"
+#include "sus/fn/fn_concepts.h"
+
+namespace sus::fn {
+
+template <class T>
+struct DynFn;
+template <class T>
+struct DynFnMut;
+template <class T>
+struct DynFnOnce;
+
+template <class T, class Store, class R, class... Args>
+  requires(Fn<T, R(Args...)>)
+struct DynFnTyped;
+template <class T, class Store, class R, class... Args>
+  requires(FnMut<T, R(Args...)>)
+struct DynFnMutTyped;
+template <class T, class Store, class R, class... Args>
+  requires(FnOnce<T, R(Args...)>)
+struct DynFnOnceTyped;
+
+/// A type-erased object which satisifies the concept [`Fn<R(Args...)>`](
+/// $sus::fn::Fn).
+template <class R, class... Args>
+struct DynFn<R(Args...)> {
+  template <class T>
+  static constexpr bool SatisfiesConcept = Fn<T, R(Args...)>;
+  template <class T, class Store>
+  using DynTyped = DynFnTyped<T, Store, R, Args...>;
+
+  DynFn() = default;
+  virtual ~DynFn() = default;
+  DynFn(DynFn&&) = delete;
+  DynFn& operator=(DynFn&&) = delete;
+
+  // Virtual concept API.
+  virtual R operator()(Args&&...) const = 0;
+};
+
+/// The implementation of type-erasure for the Fn concept.
+/// #[doc.hidden]
+template <class T, class Store, class R, class... Args>
+  requires(Fn<T, R(Args...)>)
+struct DynFnTyped final : public DynFn<R(Args...)> {
+  constexpr DynFnTyped(Store&& c) : c_(sus::forward<Store>(c)) {}
+
+  R operator()(Args&&... args) const override {
+    return c_(::sus::forward<Args>(args)...);
+  }
+
+ private:
+  Store c_;
+};
+
+/// A type-erased object which satisifies the concept [`FnMut<R(Args...)>`](
+/// $sus::fn::FnMut).
+template <class R, class... Args>
+struct DynFnMut<R(Args...)> {
+  template <class T>
+  static constexpr bool SatisfiesConcept = FnMut<T, R(Args...)>;
+  template <class T, class Store>
+  using DynTyped = DynFnMutTyped<T, Store, R, Args...>;
+
+  DynFnMut() = default;
+  virtual ~DynFnMut() = default;
+  DynFnMut(DynFnMut&&) = delete;
+  DynFnMut& operator=(DynFnMut&&) = delete;
+
+  // Virtual concept API.
+  virtual R operator()(Args&&...) = 0;
+};
+
+/// The implementation of type-erasure for the DynFnMut concept.
+/// #[doc.hidden]
+template <class T, class Store, class R, class... Args>
+  requires(FnMut<T, R(Args...)>)
+struct DynFnMutTyped final : public DynFnMut<R(Args...)> {
+  constexpr DynFnMutTyped(Store&& c) : c_(sus::forward<Store>(c)) {}
+
+  R operator()(Args&&... args) override {
+    return c_(::sus::forward<Args>(args)...);
+  }
+
+ private:
+  Store c_;
+};
+
+/// A type-erased object which satisifies the concept [`FnOnce<R(Args...)>`](
+/// $sus::fn::FnOnce).
+template <class R, class... Args>
+struct DynFnOnce<R(Args...)> {
+  template <class T>
+  static constexpr bool SatisfiesConcept = FnOnce<T, R(Args...)>;
+  template <class T, class Store>
+  using DynTyped = DynFnOnceTyped<T, Store, R, Args...>;
+
+  DynFnOnce() = default;
+  virtual ~DynFnOnce() = default;
+  DynFnOnce(DynFnOnce&&) = delete;
+  DynFnOnce& operator=(DynFnOnce&&) = delete;
+
+  // Virtual concept API.
+  virtual R operator()(Args&&...) && = 0;
+};
+
+/// The implementation of type-erasure for the DynFnOnce concept.
+/// #[doc.hidden]
+template <class T, class Store, class R, class... Args>
+  requires(FnOnce<T, R(Args...)>)
+struct DynFnOnceTyped final : public DynFnOnce<R(Args...)> {
+  constexpr DynFnOnceTyped(Store&& c) : c_(sus::forward<Store>(c)) {}
+
+  R operator()(Args&&... args) && override {
+    return c_(::sus::forward<Args>(args)...);
+  }
+
+ private:
+  Store c_;
+};
+
+// `DynFn` satisfies `Fn`.
+static_assert(Fn<DynFn<int(double)>, int(double)>);
+// `DynFn` satisfies `DynConcept`, meaning it type-erases correctly and can
+// interact with `Dyn` and `Box`.
+static_assert(::sus::boxed::DynConcept<DynFn<int(float)>,
+                                       decltype([](float) { return 0; })>);
+
+// `DynFnMut` satisfies `FnMut`.
+static_assert(FnMut<DynFnMut<int(double)>, int(double)>);
+// `DynFnMut` satisfies `DynConcept`, meaning it type-erases correctly and can
+// interact with `Dyn` and `Box`.
+static_assert(::sus::boxed::DynConcept<DynFnMut<int(float)>,
+                                       decltype([](float) { return 0; })>);
+
+// `DynFnOnce` satisfies `FnOnce`.
+static_assert(FnOnce<DynFnOnce<int(double)>, int(double)>);
+// `DynFnOnce` satisfies `DynConcept`, meaning it type-erases correctly and can
+// interact with `Dyn` and `Box`.
+static_assert(::sus::boxed::DynConcept<DynFnOnce<int(float)>,
+                                       decltype([](float) { return 0; })>);
+
+}  // namespace sus::fn
diff --git a/sus/fn/fn_dyn_unittest.cc b/sus/fn/fn_dyn_unittest.cc
new file mode 100644
index 000000000..0c2c72167
--- /dev/null
+++ b/sus/fn/fn_dyn_unittest.cc
@@ -0,0 +1,84 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "sus/fn/fn_dyn.h"
+
+#include "googletest/include/gtest/gtest.h"
+#include "sus/boxed/box.h"
+#include "sus/prelude.h"
+
+namespace {
+using namespace sus::fn;
+
+TEST(FnDyn, Fn) {
+  auto x = [](const DynFn<i32(i32, i32)>& f) { return call(f, 1, 2); };
+  i32 c = x(sus::dyn<DynFn<i32(i32, i32)>>([](i32 a, i32 b) { return a + b; }));
+  EXPECT_EQ(c, 1 + 2);
+  i32 d = x(sus::dyn<DynFn<i32(i32, i32)>>([](i32 a, i32 b) { return a * b; }));
+  EXPECT_EQ(d, 1 * 2);
+}
+
+TEST(FnDyn, FnBox) {
+  auto x = [](sus::Box<DynFn<i32(i32, i32)>> f) { return call(*f, 1, 2); };
+  i32 c = x(sus::into([](i32 a, i32 b) { return a + b; }));
+  EXPECT_EQ(c, 1 + 2);
+  i32 d = x(sus::into([](i32 a, i32 b) { return a * b; }));
+  EXPECT_EQ(d, 1 * 2);
+}
+
+TEST(FnMutDyn, FnMut) {
+  auto x = [](DynFnMut<i32(i32, i32)>& f) { return call_mut(f, 1, 2); };
+  i32 c =
+      x(sus::dyn<DynFnMut<i32(i32, i32)>>([](i32 a, i32 b) { return a + b; }));
+  EXPECT_EQ(c, 1 + 2);
+  i32 d =
+      x(sus::dyn<DynFnMut<i32(i32, i32)>>([](i32 a, i32 b) { return a * b; }));
+  EXPECT_EQ(d, 1 * 2);
+}
+
+TEST(FnMutDyn, FnMutBox) {
+  auto x = [](sus::Box<DynFnMut<i32(i32, i32)>> f) {
+    return call_mut(*f, 1, 2);
+  };
+  i32 c = x(sus::into([](i32 a, i32 b) { return a + b; }));
+  EXPECT_EQ(c, 1 + 2);
+  i32 d = x(sus::into([](i32 a, i32 b) { return a * b; }));
+  EXPECT_EQ(d, 1 * 2);
+}
+
+TEST(FnDyn, FnOnce) {
+  auto x = [](DynFnOnce<i32(i32, i32)>&& f) {
+    return call_once(sus::move(f), 1, 2);
+  };
+  i32 c =
+      x(sus::dyn<DynFnOnce<i32(i32, i32)>>([](i32 a, i32 b) { return a + b; }));
+  EXPECT_EQ(c, 1 + 2);
+  i32 d =
+      x(sus::dyn<DynFnOnce<i32(i32, i32)>>([](i32 a, i32 b) { return a * b; }));
+  EXPECT_EQ(d, 1 * 2);
+}
+
+TEST(FnOnceDyn, FnOnceBox) {
+  auto x = [](sus::Box<DynFnOnce<i32(i32, i32)>> f) {
+    return sus::move(f).consume([](auto&& dynfn) {
+      return ::sus::fn::call_once(sus::move(dynfn), 1, 2);
+    });
+  };
+  i32 c = x(sus::into([](i32 a, i32 b) { return a + b; }));
+  EXPECT_EQ(c, 1 + 2);
+  i32 d = x(sus::into([](i32 a, i32 b) { return a * b; }));
+  EXPECT_EQ(d, 1 * 2);
+}
+
+}  // namespace

From 42eafa784f84690bd353dc153e6f75de18217a86 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 04:58:18 -0400
Subject: [PATCH 10/31] When building the storage reference, work with rvalue
 correctly

The reference may be an rvalue and it may need to be used as an rvalue
in order to get the desired type from it.
---
 sus/option/option.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/sus/option/option.h b/sus/option/option.h
index 7b1964b98..0b868246b 100644
--- a/sus/option/option.h
+++ b/sus/option/option.h
@@ -1887,10 +1887,11 @@ class Option final {
   // storage from a `T` object or a `T&&` (which is received as `T&`).
   template <class U>
   static constexpr inline decltype(auto) move_to_storage(U&& t) {
-    if constexpr (std::is_reference_v<T>)
-      return StoragePointer<T>(t);
-    else
+    if constexpr (std::is_reference_v<T>) {
+      return StoragePointer<T>(::sus::forward<U>(t));
+    } else {
       return ::sus::move(t);
+    }
   }
 
   /// Constructors for `Some`.

From 296818da5a17e850401956026d83e2eb8836a0ab Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 04:59:15 -0400
Subject: [PATCH 11/31] Support getting an lvalue ref from Dyn when it's an
 lvalue.

This can be useful when it lives on the stack in order to extend its
lifetime.
---
 sus/boxed/dyn.h | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/sus/boxed/dyn.h b/sus/boxed/dyn.h
index 2c2b77f85..92eb3ef5b 100644
--- a/sus/boxed/dyn.h
+++ b/sus/boxed/dyn.h
@@ -277,7 +277,12 @@ class [[nodiscard]] Dyn {
       : dyn_(const_cast<ConcreteT&>(concrete)) {}
 
   /// Converts the reference to `ConcreteT` into a `DynC` reference.
-  operator const DynC&() const&& { return dyn_; }
+  operator const DynC&() const& { return dyn_; }
+  operator DynC&() &
+    requires(!std::is_const_v<DynC>)
+  {
+    return dyn_;
+  }
   operator DynC&() &&
     requires(!std::is_const_v<DynC>)
   {

From 4a449009f270957658a3b434fd1f249e814ec47c Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 04:59:47 -0400
Subject: [PATCH 12/31] Avoid needing to be able to construct in order to look
 for NeverValue

---
 sus/mem/never_value.h | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/sus/mem/never_value.h b/sus/mem/never_value.h
index e230e1c65..88a5b791f 100644
--- a/sus/mem/never_value.h
+++ b/sus/mem/never_value.h
@@ -72,14 +72,17 @@ struct NeverValueAccess<T&> {
   static constexpr bool has_field = false;
 };
 
+/// Whether the type `T` has a never-value field.
 template <class T>
-struct NeverValueAccess {
-  /// Whether the type `T` has a never-value field.
+struct NeverValueChecker {
   static constexpr bool has_field = requires {
     std::declval<T&>()._sus_Unsafe_NeverValueIsConstructed(
         ::sus::marker::unsafe_fn);
   };
+};
 
+template <class T>
+struct NeverValueAccess {
   constexpr NeverValueAccess() = default;
 
   template <class... U>
@@ -89,7 +92,7 @@ struct NeverValueAccess {
   /// Checks if the never-value field is set to the never-value, returning false
   /// if it is.
   sus_pure constexpr sus_always_inline bool is_constructed() const noexcept
-    requires(has_field)
+    requires(NeverValueChecker<T>::has_field)
   {
     return t_._sus_Unsafe_NeverValueIsConstructed(::sus::marker::unsafe_fn);
   }
@@ -97,7 +100,7 @@ struct NeverValueAccess {
   /// Sets the never-value field to the destroy-value.
   constexpr sus_always_inline void set_destroy_value(
       ::sus::marker::UnsafeFnMarker) noexcept
-    requires(has_field)
+    requires(NeverValueChecker<T>::has_field)
   {
     t_._sus_Unsafe_NeverValueSetDestroyValue(::sus::marker::unsafe_fn);
   }
@@ -126,7 +129,7 @@ struct NeverValueAccess {
 /// the field will be set to a special destroy-value before the destructor is
 /// called.
 template <class T>
-concept NeverValueField = __private::NeverValueAccess<T>::has_field;
+concept NeverValueField = __private::NeverValueChecker<T>::has_field;
 
 }  // namespace sus::mem
 
@@ -151,6 +154,8 @@ concept NeverValueField = __private::NeverValueAccess<T>::has_field;
                                                                                \
   template <class>                                                             \
   friend struct ::sus::mem::__private::NeverValueAccess;                       \
+  template <class>                                                             \
+  friend struct ::sus::mem::__private::NeverValueChecker;                      \
                                                                                \
   sus_pure constexpr bool _sus_Unsafe_NeverValueIsConstructed(                 \
       ::sus::marker::UnsafeFnMarker) const noexcept {                          \

From 47c71848728fff4c02010af58a4429e8cdce8af1 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 05:00:08 -0400
Subject: [PATCH 13/31] Avoid conflicting comments on constructors

---
 sus/error/error.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/sus/error/error.h b/sus/error/error.h
index 573a01244..b96f087cc 100644
--- a/sus/error/error.h
+++ b/sus/error/error.h
@@ -455,7 +455,6 @@ struct DynError {
   constexpr DynError() = default;
   /// #[doc.hidden]
   constexpr virtual ~DynError() = default;
-  /// #[doc.hidden]
   DynError(DynError&&) = delete;
   /// #[doc.hidden]
   DynError&& operator=(DynError&&) = delete;

From 46a9f377e51e17e2ed8a1ea9401bea51e7db8af6 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 05:00:34 -0400
Subject: [PATCH 14/31] Remove use of FnOnceRef in subdoc

---
 subdoc/lib/gen/generate_function.cc |  9 ++++++---
 subdoc/lib/gen/generate_record.cc   | 16 +++++++++-------
 subdoc/lib/gen/generate_type.cc     | 20 +++++++++++---------
 subdoc/lib/gen/generate_type.h      |  8 ++++----
 subdoc/lib/type.cc                  | 20 ++++++++++----------
 subdoc/lib/type.h                   | 12 ++++++------
 subdoc/tests/type_unittest.cc       | 20 ++++++++++++--------
 7 files changed, 58 insertions(+), 47 deletions(-)

diff --git a/subdoc/lib/gen/generate_function.cc b/subdoc/lib/gen/generate_function.cc
index 567918ccc..04be79c39 100644
--- a/subdoc/lib/gen/generate_function.cc
+++ b/subdoc/lib/gen/generate_function.cc
@@ -49,9 +49,12 @@ void generate_function_params(HtmlWriter::OpenDiv& div,
       if (p.parameter_name.empty()) {
         generate_type(div, p.type, sus::none());
       } else {
-        generate_type(div, p.type, sus::some([&](HtmlWriter::OpenDiv& div) {
-                        div.write_text(p.parameter_name);
-                      }));
+        generate_type(
+            div, p.type,
+            sus::some(sus::dyn<sus::fn::DynFnMut<void(HtmlWriter::OpenDiv&)>>(
+                [&](HtmlWriter::OpenDiv& div) {
+                  div.write_text(p.parameter_name);
+                })));
       }
 
       if (p.default_value.is_some()) {
diff --git a/subdoc/lib/gen/generate_record.cc b/subdoc/lib/gen/generate_record.cc
index b3399cc42..d44d92d64 100644
--- a/subdoc/lib/gen/generate_record.cc
+++ b/subdoc/lib/gen/generate_record.cc
@@ -243,13 +243,15 @@ sus::Result<void, MarkdownToHtmlError> generate_record_fields(
           }
           name_div.write_text(" ");
         }
-        generate_type(name_div, fe.type,
-                      sus::some([&](HtmlWriter::OpenDiv& div) {
-                        auto anchor = div.open_a();
-                        anchor.add_href(construct_html_url_for_field(fe));
-                        anchor.add_class("field-name");
-                        anchor.write_text(fe.name);
-                      }));
+        generate_type(
+            name_div, fe.type,
+            sus::some(sus::dyn<sus::fn::DynFnMut<void(HtmlWriter::OpenDiv&)>>(
+                [&](HtmlWriter::OpenDiv& div) {
+                  auto anchor = div.open_a();
+                  anchor.add_href(construct_html_url_for_field(fe));
+                  anchor.add_class("field-name");
+                  anchor.write_text(fe.name);
+                })));
       }
       {
         auto desc_div = field_div.open_div();
diff --git a/subdoc/lib/gen/generate_type.cc b/subdoc/lib/gen/generate_type.cc
index 5be1b2c0c..21da172d0 100644
--- a/subdoc/lib/gen/generate_type.cc
+++ b/subdoc/lib/gen/generate_type.cc
@@ -34,7 +34,7 @@ std::string make_title_string(TypeToStringQuery q) {
 }  // namespace
 
 void generate_type(HtmlWriter::OpenDiv& div, const LinkedType& linked_type,
-                   sus::Option<sus::fn::FnOnceRef<void(HtmlWriter::OpenDiv&)>>
+                   sus::Option<sus::fn::DynFnMut<void(HtmlWriter::OpenDiv&)>&>
                        var_name_fn) noexcept {
   auto text_fn = [&](std::string_view text) { div.write_text(text); };
   auto type_fn = [&, i_ = 0_usize](TypeToStringQuery q) mutable {
@@ -79,15 +79,17 @@ void generate_type(HtmlWriter::OpenDiv& div, const LinkedType& linked_type,
     span.write_text("volatile");
   };
   auto var_fn = [&]() { sus::move(var_name_fn).unwrap()(div); };
+  // Construct our DynFnMut reference to `var_fn` in case we need it so that
+  // it can outlive the Option holding a ref to it.
+  auto dyn_fn = sus::dyn<sus::fn::DynFnMut<void()>>(var_fn);
+  auto opt_dyn_fn = sus::Option<sus::fn::DynFnMut<void()>&>(dyn_fn);
 
-  type_to_string(linked_type.type, text_fn, type_fn, const_fn, volatile_fn,
-                 [&]() -> sus::Option<sus::fn::FnOnceRef<void(void)>> {
-                   if (var_name_fn.is_some()) {
-                     return sus::some(sus::move(var_fn));
-                   } else {
-                     return sus::none();
-                   }
-                 }());
+  type_to_string(linked_type.type,
+                 sus::dyn<sus::fn::DynFnMut<void(std::string_view)>>(text_fn),
+                 sus::dyn<sus::fn::DynFnMut<void(TypeToStringQuery)>>(type_fn),
+                 sus::dyn<sus::fn::DynFnMut<void()>>(const_fn),
+                 sus::dyn<sus::fn::DynFnMut<void()>>(volatile_fn),
+                 var_name_fn.and_that(sus::move(opt_dyn_fn)));
 }
 
 }  // namespace subdoc::gen
diff --git a/subdoc/lib/gen/generate_type.h b/subdoc/lib/gen/generate_type.h
index 36a3085a3..d57ddf63a 100644
--- a/subdoc/lib/gen/generate_type.h
+++ b/subdoc/lib/gen/generate_type.h
@@ -17,13 +17,13 @@
 #include "subdoc/lib/database.h"
 #include "subdoc/lib/gen/html_writer.h"
 #include "subdoc/lib/type.h"
-#include "sus/prelude.h"
 #include "sus/fn/fn_ref.h"
+#include "sus/prelude.h"
 
 namespace subdoc::gen {
 
-void generate_type(
-    HtmlWriter::OpenDiv& div, const LinkedType& linked_type,
-    sus::Option<sus::fn::FnOnceRef<void(HtmlWriter::OpenDiv&)>> var_name_fn) noexcept;
+void generate_type(HtmlWriter::OpenDiv& div, const LinkedType& linked_type,
+                   sus::Option<sus::fn::DynFnMut<void(HtmlWriter::OpenDiv&)>&>
+                       var_name_fn) noexcept;
 
 }  // namespace subdoc::gen
diff --git a/subdoc/lib/type.cc b/subdoc/lib/type.cc
index 361d9fa26..3a0830cdb 100644
--- a/subdoc/lib/type.cc
+++ b/subdoc/lib/type.cc
@@ -528,11 +528,11 @@ Type build_local_type(clang::QualType qualtype, const clang::SourceManager& sm,
 namespace {
 
 void type_to_string_internal(
-    const Type& type, sus::fn::FnMutRef<void(std::string_view)>& text_fn,
-    sus::fn::FnMutRef<void(TypeToStringQuery)>& type_fn,
-    sus::fn::FnMutRef<void()>& const_qualifier_fn,
-    sus::fn::FnMutRef<void()>& volatile_qualifier_fn,
-    sus::Option<sus::fn::FnOnceRef<void()>> var_name_fn) noexcept {
+    const Type& type, sus::fn::DynFnMut<void(std::string_view)>& text_fn,
+    sus::fn::DynFnMut<void(TypeToStringQuery)>& type_fn,
+    sus::fn::DynFnMut<void()>& const_qualifier_fn,
+    sus::fn::DynFnMut<void()>& volatile_qualifier_fn,
+    sus::Option<sus::fn::DynFnMut<void()>&> var_name_fn) noexcept {
   if (type.qualifier.is_const) {
     const_qualifier_fn();
     text_fn(" ");
@@ -730,11 +730,11 @@ void type_walk_types_internal(
 }  // namespace
 
 void type_to_string(
-    const Type& type, sus::fn::FnMutRef<void(std::string_view)> text_fn,
-    sus::fn::FnMutRef<void(TypeToStringQuery)> type_fn,
-    sus::fn::FnMutRef<void()> const_qualifier_fn,
-    sus::fn::FnMutRef<void()> volatile_qualifier_fn,
-    sus::Option<sus::fn::FnOnceRef<void()>> var_name_fn) noexcept {
+    const Type& type, sus::fn::DynFnMut<void(std::string_view)>& text_fn,
+    sus::fn::DynFnMut<void(TypeToStringQuery)>& type_fn,
+    sus::fn::DynFnMut<void()>& const_qualifier_fn,
+    sus::fn::DynFnMut<void()>& volatile_qualifier_fn,
+    sus::Option<sus::fn::DynFnMut<void()>&> var_name_fn) noexcept {
   return type_to_string_internal(type, text_fn, type_fn, const_qualifier_fn,
                                  volatile_qualifier_fn, sus::move(var_name_fn));
 }
diff --git a/subdoc/lib/type.h b/subdoc/lib/type.h
index 3431ebc23..426d2d23e 100644
--- a/subdoc/lib/type.h
+++ b/subdoc/lib/type.h
@@ -17,7 +17,7 @@
 #include "subdoc/llvm.h"
 #include "sus/choice/choice.h"
 #include "sus/collections/vec.h"
-#include "sus/fn/fn_ref.h"
+#include "sus/fn/fn.h"
 #include "sus/prelude.h"
 
 namespace subdoc {
@@ -242,11 +242,11 @@ struct TypeToStringQuery {
 /// The `var_name_fn` is called at the place where the variable name (if any)
 /// would appear.
 void type_to_string(
-    const Type& type, sus::fn::FnMutRef<void(std::string_view)> text_fn,
-    sus::fn::FnMutRef<void(TypeToStringQuery)> type_fn,
-    sus::fn::FnMutRef<void()> const_qualifier_fn,
-    sus::fn::FnMutRef<void()> volatile_qualifier_fn,
-    sus::Option<sus::fn::FnOnceRef<void()>> var_name_fn) noexcept;
+    const Type& type, sus::fn::DynFnMut<void(std::string_view)>& text_fn,
+    sus::fn::DynFnMut<void(TypeToStringQuery)>& type_fn,
+    sus::fn::DynFnMut<void()>& const_qualifier_fn,
+    sus::fn::DynFnMut<void()>& volatile_qualifier_fn,
+    sus::Option<sus::fn::DynFnMut<void()>&> var_name_fn) noexcept;
 
 /// Like `type_to_string` but just walks through the types and does not produce
 /// any output.
diff --git a/subdoc/tests/type_unittest.cc b/subdoc/tests/type_unittest.cc
index 7b1778701..7c5a173cc 100644
--- a/subdoc/tests/type_unittest.cc
+++ b/subdoc/tests/type_unittest.cc
@@ -34,14 +34,18 @@ std::string make_string(std::string_view var_name, const subdoc::Type& type) {
   auto const_fn = [&]() { str << "const"; };
   auto volatile_fn = [&]() { str << "volatile"; };
   auto var_fn = [&]() { str << var_name; };
-
-  subdoc::type_to_string(type, text_fn, type_fn, const_fn, volatile_fn,
-                         [&]() -> sus::Option<sus::fn::FnOnceRef<void()>> {
-                           if (var_name.empty())
-                             return sus::none();
-                           else
-                             return sus::some(sus::move(var_fn));
-                         }());
+  // Construct our DynFnMut reference to `var_fn` in case we need it so that
+  // it can outlive the Option holding a ref to it.
+  auto dyn_fn = sus::dyn<sus::fn::DynFnMut<void()>>(var_fn);
+  sus::Option<sus::fn::DynFnMut<void()>&> opt_dyn_fn;
+  if (!var_name.empty()) opt_dyn_fn.insert(dyn_fn);
+
+  subdoc::type_to_string(
+      type, sus::dyn<sus::fn::DynFnMut<void(std::string_view)>>(text_fn),
+      sus::dyn<sus::fn::DynFnMut<void(subdoc::TypeToStringQuery)>>(type_fn),
+      sus::dyn<sus::fn::DynFnMut<void()>>(const_fn),
+      sus::dyn<sus::fn::DynFnMut<void()>>(volatile_fn),
+      sus::move(opt_dyn_fn));
   return sus::move(str).str();
 }
 

From 4b6d36cfca964b531ba6e5c8e745066b5f48d5d4 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 05:05:05 -0400
Subject: [PATCH 15/31] Remove use of FnMutRef and FnMutBox in subdoc

---
 subdoc/lib/database.h | 95 ++++++++++++++++++++++---------------------
 subdoc/lib/type.cc    |  4 +-
 subdoc/lib/type.h     |  2 +-
 3 files changed, 51 insertions(+), 50 deletions(-)

diff --git a/subdoc/lib/database.h b/subdoc/lib/database.h
index 287f8ca05..a8b2018ee 100644
--- a/subdoc/lib/database.h
+++ b/subdoc/lib/database.h
@@ -18,13 +18,13 @@
 
 #include "subdoc/lib/doc_attributes.h"
 #include "subdoc/lib/friendly_names.h"
+#include "subdoc/lib/linked_type.h"
 #include "subdoc/lib/method_qualifier.h"
 #include "subdoc/lib/parse_comment.h"
 #include "subdoc/lib/path.h"
 #include "subdoc/lib/record_type.h"
 #include "subdoc/lib/requires.h"
 #include "subdoc/lib/type.h"
-#include "subdoc/lib/linked_type.h"
 #include "subdoc/lib/unique_symbol.h"
 #include "subdoc/llvm.h"
 #include "sus/assertions/check.h"
@@ -226,7 +226,7 @@ struct FunctionElement : public CommentElement {
     return sus::none();
   }
 
-  void for_each_comment(sus::fn::FnMutRef<void(Comment&)> fn) { fn(comment); }
+  void for_each_comment(sus::fn::FnMut<void(Comment&)> auto fn) { fn(comment); }
 };
 
 struct ConceptElement : public CommentElement {
@@ -262,7 +262,7 @@ struct ConceptElement : public CommentElement {
     return sus::none();
   }
 
-  void for_each_comment(sus::fn::FnMutRef<void(Comment&)> fn) { fn(comment); }
+  void for_each_comment(sus::fn::FnMut<void(Comment&)> auto fn) { fn(comment); }
 };
 
 struct FieldElement : public CommentElement {
@@ -310,7 +310,7 @@ struct FieldElement : public CommentElement {
     return sus::none();
   }
 
-  void for_each_comment(sus::fn::FnMutRef<void(Comment&)> fn) { fn(comment); }
+  void for_each_comment(sus::fn::FnMut<void(Comment&)> auto fn) { fn(comment); }
 };
 
 struct ConceptId {
@@ -552,7 +552,7 @@ struct RecordElement : public TypeElement {
     return out;
   }
 
-  void for_each_comment(sus::fn::FnMutRef<void(Comment&)> fn) {
+  void for_each_comment(sus::fn::FnMut<void(Comment&)> auto fn) {
     fn(comment);
     for (auto& [k, e] : records) e.for_each_comment(fn);
     for (auto& [k, e] : fields) e.for_each_comment(fn);
@@ -736,7 +736,7 @@ struct NamespaceElement : public CommentElement {
     return out;
   }
 
-  void for_each_comment(sus::fn::FnMutRef<void(Comment&)> fn) {
+  void for_each_comment(sus::fn::FnMut<void(Comment&)> auto fn) {
     fn(comment);
     for (auto& [k, e] : concepts) e.for_each_comment(fn);
     for (auto& [k, e] : namespaces) e.for_each_comment(fn);
@@ -777,13 +777,11 @@ struct Database {
     sus::Vec<Comment*> to_resolve;
     {
       sus::Vec<Comment*>* to_resolve_ptr = &to_resolve;
-      sus::fn::FnMutBox<void(Comment&)> fn = sus_bind_mut(
-          sus_store(sus_unsafe_pointer(to_resolve_ptr)), [&](Comment& c) {
-            if (c.attrs.inherit.is_some()) {
-              to_resolve_ptr->push(&c);
-            }
-          });
-      global.for_each_comment(fn);
+      global.for_each_comment([&](Comment& c) {
+        if (c.attrs.inherit.is_some()) {
+          to_resolve_ptr->push(&c);
+        }
+      });
     }
 
     while (!to_resolve.is_empty()) {
@@ -931,41 +929,44 @@ struct Database {
   sus::Vec<sus::Option<TypeRef>> collect_type_element_refs(
       const Type& type) const noexcept {
     sus::Vec<sus::Option<TypeRef>> vec;
-    type_walk_types(type, [&](TypeToStringQuery q) {
-      const NamespaceElement* ns_cursor = &global;
-      for (const std::string& name : q.namespace_path) {
-        auto it = ns_cursor->namespaces.find(NamespaceId(name));
-        if (it == ns_cursor->namespaces.end()) {
-          vec.push(sus::none());
-          return;
-        }
-        ns_cursor = &it->second;
-      }
-      if (q.record_path.is_empty()) {
-        vec.push(ns_cursor->get_local_type_element_ref_by_name(q.name));
-        return;
-      }
+    type_walk_types(
+        type,
+        sus::dyn<sus::fn::DynFnMut<void(TypeToStringQuery)>>(
+            [&](TypeToStringQuery q) {
+              const NamespaceElement* ns_cursor = &global;
+              for (const std::string& name : q.namespace_path) {
+                auto it = ns_cursor->namespaces.find(NamespaceId(name));
+                if (it == ns_cursor->namespaces.end()) {
+                  vec.push(sus::none());
+                  return;
+                }
+                ns_cursor = &it->second;
+              }
+              if (q.record_path.is_empty()) {
+                vec.push(ns_cursor->get_local_type_element_ref_by_name(q.name));
+                return;
+              }
 
-      const RecordElement* rec_cursor = nullptr;
-      for (const auto& [i, name] : q.record_path.iter().enumerate()) {
-        if (i == 0u) {
-          auto it = ns_cursor->records.find(RecordId(name));
-          if (it == ns_cursor->records.end()) {
-            vec.push(sus::none());
-            return;
-          }
-          rec_cursor = &it->second;
-        } else {
-          auto it = rec_cursor->records.find(RecordId(name));
-          if (it == rec_cursor->records.end()) {
-            vec.push(sus::none());
-            return;
-          }
-          rec_cursor = &it->second;
-        }
-      }
-      vec.push(rec_cursor->get_local_type_element_ref_by_name(q.name));
-    });
+              const RecordElement* rec_cursor = nullptr;
+              for (const auto& [i, name] : q.record_path.iter().enumerate()) {
+                if (i == 0u) {
+                  auto it = ns_cursor->records.find(RecordId(name));
+                  if (it == ns_cursor->records.end()) {
+                    vec.push(sus::none());
+                    return;
+                  }
+                  rec_cursor = &it->second;
+                } else {
+                  auto it = rec_cursor->records.find(RecordId(name));
+                  if (it == rec_cursor->records.end()) {
+                    vec.push(sus::none());
+                    return;
+                  }
+                  rec_cursor = &it->second;
+                }
+              }
+              vec.push(rec_cursor->get_local_type_element_ref_by_name(q.name));
+            }));
     return vec;
   }
 
diff --git a/subdoc/lib/type.cc b/subdoc/lib/type.cc
index 3a0830cdb..9a95dcfcb 100644
--- a/subdoc/lib/type.cc
+++ b/subdoc/lib/type.cc
@@ -681,7 +681,7 @@ void type_to_string_internal(
 
 void type_walk_types_internal(
     const Type& type,
-    sus::fn::FnMutRef<void(TypeToStringQuery)>& type_fn) noexcept {
+    sus::fn::DynFnMut<void(TypeToStringQuery)>& type_fn) noexcept {
   for (const TypeOrValue& tv : type.nested_names) {
     switch (tv.choice) {
       case TypeOrValueTag::Type: {
@@ -741,7 +741,7 @@ void type_to_string(
 
 void type_walk_types(
     const Type& type,
-    sus::fn::FnMutRef<void(TypeToStringQuery)> type_fn) noexcept {
+    sus::fn::DynFnMut<void(TypeToStringQuery)>& type_fn) noexcept {
   return type_walk_types_internal(type, type_fn);
 }
 
diff --git a/subdoc/lib/type.h b/subdoc/lib/type.h
index 426d2d23e..9610c016d 100644
--- a/subdoc/lib/type.h
+++ b/subdoc/lib/type.h
@@ -252,6 +252,6 @@ void type_to_string(
 /// any output.
 void type_walk_types(
     const Type& type,
-    sus::fn::FnMutRef<void(TypeToStringQuery)> type_fn) noexcept;
+    sus::fn::DynFnMut<void(TypeToStringQuery)>& type_fn) noexcept;
 
 }  // namespace subdoc

From 7a9d7c37cd3f7e49752a858446437993ec18f743 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 12:23:58 -0400
Subject: [PATCH 16/31] Remove FnBoxMut from RepeatWith and make it constexpr

---
 sus/iter/repeat_with.h           | 42 ++++++++++++++++++++------------
 sus/iter/repeat_with_unittest.cc |  4 +++
 2 files changed, 31 insertions(+), 15 deletions(-)

diff --git a/sus/iter/repeat_with.h b/sus/iter/repeat_with.h
index 08ab06b4f..5b12b9e51 100644
--- a/sus/iter/repeat_with.h
+++ b/sus/iter/repeat_with.h
@@ -23,7 +23,7 @@ namespace sus::iter {
 
 using ::sus::option::Option;
 
-template <class ItemT>
+template <class ItemT, class GenFn>
 class RepeatWith;
 
 /// Creates a new iterator that repeats elements of type `Item` endlessly by
@@ -46,40 +46,52 @@ class RepeatWith;
 /// sus::check(r.next().unwrap() == 3_u16);
 /// sus::check(r.next().unwrap() == 3_u16);
 /// ```
-template <class Item>
-inline RepeatWith<Item> repeat_with(::sus::fn::FnMutBox<Item()> gen) noexcept {
-  return RepeatWith<Item>(::sus::move(gen));
+template <class Item, ::sus::fn::FnMut<Item()> GenFn>
+constexpr inline RepeatWith<Item, GenFn> repeat_with(GenFn gen) noexcept {
+  return RepeatWith<Item, GenFn>(::sus::move(gen));
 }
 
 /// An Iterator that walks over at most a single Item.
-template <class ItemT>
-class [[nodiscard]] [[sus_trivial_abi]] RepeatWith final
-    : public IteratorBase<RepeatWith<ItemT>, ItemT> {
+template <class ItemT, class GenFn>
+class [[nodiscard]] RepeatWith final
+    : public IteratorBase<RepeatWith<ItemT, GenFn>, ItemT> {
  public:
   using Item = ItemT;
 
+  // Type is Move and (can be) Clone.
+  RepeatWith(RepeatWith&&) = default;
+  RepeatWith& operator=(RepeatWith&&) = default;
+
+  // sus::mem::Clone trait.
+  constexpr RepeatWith clone() const noexcept
+    requires(::sus::mem::Clone<GenFn>)
+  {
+    return RepeatWith(sus::clone(gen_));
+  }
+
   // sus::iter::Iterator trait.
-  Option<Item> next() noexcept {
+  constexpr Option<Item> next() noexcept {
     return ::sus::some(::sus::fn::call_mut(gen_));
   }
   /// sus::iter::Iterator trait.
-  SizeHint size_hint() const noexcept {
+  constexpr SizeHint size_hint() const noexcept {
     return SizeHint(usize::MAX, ::sus::Option<::sus::num::usize>());
   }
   // sus::iter::DoubleEndedIterator trait.
-  Option<Item> next_back() noexcept {
+  constexpr Option<Item> next_back() noexcept {
     return ::sus::some(::sus::fn::call_mut(gen_));
   }
 
  private:
-  friend RepeatWith<Item> sus::iter::repeat_with<Item>(
-      ::sus::fn::FnMutBox<Item()> gen) noexcept;
+  friend constexpr RepeatWith<Item, GenFn> sus::iter::repeat_with<Item>(
+      GenFn gen) noexcept;
 
-  RepeatWith(::sus::fn::FnMutBox<Item()> gen) : gen_(::sus::move(gen)) {}
+  constexpr RepeatWith(GenFn gen) : gen_(::sus::move(gen)) {}
 
-  ::sus::fn::FnMutBox<Item()> gen_;
+  GenFn gen_;
 
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(gen_));
+  sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
+                                           decltype(gen_));
 };
 
 }  // namespace sus::iter
diff --git a/sus/iter/repeat_with_unittest.cc b/sus/iter/repeat_with_unittest.cc
index 17074ecf3..021706646 100644
--- a/sus/iter/repeat_with_unittest.cc
+++ b/sus/iter/repeat_with_unittest.cc
@@ -46,4 +46,8 @@ TEST(RepeatWith, NextBack) {
   EXPECT_EQ(o.next_back(), sus::some(3_u16));
 }
 
+// constexpr
+static_assert(sus::iter::repeat_with<i32>([] { return 3; }).take(4u).sum() ==
+              3 * 4);
+
 }  // namespace

From b9fa1136e38b1711a5596cd9518e7b3c41fc22e8 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 12:43:27 -0400
Subject: [PATCH 17/31] Implement iterator max_by_key and min_by_key more
 efficiently

Now that everything can be constexpr we can just max_by and min_by
in the implementation of them.
---
 sus/iter/iterator_defn.h | 74 +++++++++++++++++-----------------------
 1 file changed, 32 insertions(+), 42 deletions(-)

diff --git a/sus/iter/iterator_defn.h b/sus/iter/iterator_defn.h
index 68350bd8b..c6f46ab7f 100644
--- a/sus/iter/iterator_defn.h
+++ b/sus/iter/iterator_defn.h
@@ -1504,29 +1504,24 @@ template <
            !std::is_reference_v<Key>)
 constexpr Option<Item> IteratorBase<Iter, Item>::max_by_key(
     KeyFn fn) && noexcept {
-  auto fold = [&fn](sus::Tuple<Key, Item>&& acc, Item&& item) {
-    Key key = ::sus::fn::call_mut(fn, item);
-    if (key >= acc.template at<0>())
-      return sus::Tuple<Key, Item>(::sus::move(key),
-                                   ::sus::forward<Item>(item));
-    return ::sus::move(acc);
+  // Builds a map function that turns an Item into a Tuple<Key, Item> by using
+  // `keyfn`.
+  auto key = [](KeyFn keyfn) {
+    return [keyfn](Item&& item) {
+      return sus::Tuple<Key, Item>(keyfn(item), sus::forward<Item>(item));
+    };
   };
 
-  // TODO: We could do .map() to make the tuple and use max_by(), and not need
-  // the if statement but for that .map() would need to take a reference
-  // on/ownership of `fn` and that requires heap allocations for FnMutBox.
-  auto first = as_subclass_mut().next();
-  if (first.is_none()) return Option<Item>();
-  Key first_key = fn(first.as_value());
-  return Option<Item>(
-      // Run fold() over a Tuple<Key, Item> to find the max Key.
-      static_cast<Iter&&>(*this)
-          .fold(sus::Tuple<Key, Item>(first_key,
-                                      ::sus::move(first).unwrap_unchecked(
-                                          ::sus::marker::unsafe_fn)),
-                fold)
-          // Pull out the Item for the max Key.
-          .template into_inner<1>());
+  // Compares just the keys.
+  auto compare = [](const sus::Tuple<Key, Item>& x,
+                    const sus::Tuple<Key, Item>& y) {
+    return x.at<0>() <=> y.at<0>();
+  };
+
+  return static_cast<Iter&&>(*this).map(key(fn)).max_by(compare).map(
+      [](auto&& key_item) -> Item {
+        return sus::move(key_item).into_inner<1>();
+      });
 }
 
 template <class Iter, class Item>
@@ -1562,29 +1557,24 @@ template <
            !std::is_reference_v<Key>)
 constexpr Option<Item> IteratorBase<Iter, Item>::min_by_key(
     KeyFn fn) && noexcept {
-  auto fold = [&fn](sus::Tuple<Key, Item>&& acc, Item&& item) {
-    Key key = ::sus::fn::call_mut(fn, item);
-    if (key < acc.template at<0>())
-      return sus::Tuple<Key, Item>(::sus::move(key),
-                                   ::sus::forward<Item>(item));
-    return ::sus::move(acc);
+  // Builds a map function that turns an Item into a Tuple<Key, Item> by using
+  // `keyfn`.
+  auto key = [](KeyFn keyfn) {
+    return [keyfn](Item&& item) {
+      return sus::Tuple<Key, Item>(keyfn(item), sus::forward<Item>(item));
+    };
   };
 
-  // TODO: We could do .map() to make the tuple and use min_by(), and not need
-  // the if statement but for that .map() would need to take a reference
-  // on/ownership of `fn` and that requires heap allocations for FnMutBox.
-  auto first = as_subclass_mut().next();
-  if (first.is_none()) return Option<Item>();
-  Key first_key = fn(first.as_value());
-  return Option<Item>(
-      // Run fold() over a Tuple<Key, Item> to find the min Key.
-      static_cast<Iter&&>(*this)
-          .fold(sus::Tuple<Key, Item>(first_key,
-                                      ::sus::move(first).unwrap_unchecked(
-                                          ::sus::marker::unsafe_fn)),
-                fold)
-          // Pull out the Item for the min Key.
-          .template into_inner<1>());
+  // Compares just the keys.
+  auto compare = [](const sus::Tuple<Key, Item>& x,
+                    const sus::Tuple<Key, Item>& y) {
+    return x.at<0>() <=> y.at<0>();
+  };
+
+  return static_cast<Iter&&>(*this).map(key(fn)).min_by(compare).map(
+      [](auto&& key_item) -> Item {
+        return sus::move(key_item).into_inner<1>();
+      });
 }
 
 template <class Iter, class Item>

From 39ab44ec8ef773cdd2cbe147c71fd8ab5f8a5576 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 15:17:45 -0400
Subject: [PATCH 18/31] Box<DynFn> now is a Fn itself and add tons of docs for
 type-erasure and Box

---
 sus/boxed/box.h           | 138 +++++++++++++++++++++++++++++++++++---
 sus/boxed/box_unittest.cc |  26 +++++++
 sus/error/error.h         |   7 +-
 sus/fn/fn_dyn.h           |  21 +++++-
 sus/fn/fn_dyn_unittest.cc |  10 +--
 5 files changed, 178 insertions(+), 24 deletions(-)

diff --git a/sus/boxed/box.h b/sus/boxed/box.h
index bc09f4f69..add44c02c 100644
--- a/sus/boxed/box.h
+++ b/sus/boxed/box.h
@@ -41,14 +41,73 @@ namespace sus::boxed {
 
 /// A heap allocated object.
 ///
+/// A `Box<T>` holds ownership of an object of type `T` on the heap. When `Box`
+/// is destroyed, or an rvalue-qualified method is called, the inner heap
+/// object is freed.
+///
+/// `Box` is similar to [`std::unique_ptr`](
+/// https://en.cppreference.com/w/cpp/memory/unique_ptr) with some differences,
+/// and should be preferred when those differences will benefit you:
+/// * Const correctness. A `const Box` treats the inner object as `const` and
+///   does not expose mutable access to it.
+/// * Never null. A `Box` always holds a value until it is moved-from. It is
+///   constructed from a value, not a pointer.
+///   A moved-from `Box` may not be used except to be assigned to or destroyed.
+///   Using a moved-from `Box` will [`panic`]($sus::assertions::panic) and
+///   terminate the program rather than operate on a null. This prevents
+///   Undefined Behaviour and memory bugs caused by dereferencing null or using
+///   null in unintended ways.
+/// * Supports up-casting (TODO: and [`down-casting`](
+///   https://github.com/chromium/subspace/issues/333)) without leaving
+///   requiring a native pointer to be pulled out of the `Box`.
+/// * No native arrays, `Box` can hold [`Array`]($sus::collection::Array) or
+///   [`std::array`](https://en.cppreference.com/w/cpp/container/array) but
+///   avoids API complexity for supporting pointers and native arrays (which
+///   decay to pointers) by rejecting native arrays.
+/// * Integration with [concept type-erasure]($sus::boxed::DynConcept) for
+///   holding and constructing from type-erased objects which satisfy a given
+///   concept in a type-safe way and without requiring inheritence. This
+///   construction is done through [`From`]($sus::construct::From) and thus
+///   can `Box<DynC>` can be constructed in a type-deduced way from any object
+///   that satisfies the concept `C` via [`sus::into()`]($sus::construct::into).
+///   This only requires that `DynC` is compatible with
+///   [`DynConcept`]($sus::boxed::DynConcept) which is the case for all
+///   type-erasable concepts in the Subspace library.
+/// * Additional integration with Subspace library concepts like
+///   [`Error`]($sus::error::Error) and [`Fn`]($sus::fn::Fn) such that `Box`
+///   [will satisfy those concepts itself](
+///   #box-implements-some-concepts-for-its-inner-type) when holding
+///   a type-erased object that satisfies those concepts.
+///
 /// # Box implements some concepts for its inner type
-/// For some concepts in the Subspace library, if `T` satisfies the concept,
-/// then `Box<T>` will as well, forwarding through to the inner heap-allocated
-/// object. Those concepts are:
-/// * [`Error`]($sus::error::Error).
+///
+/// The Subspace library provides a number of concepts which support
+/// type-erasure through [`DynConcept`]($sus::boxed::DynConcept), and when
+/// `Box` is holding these as its value, it may itself implement the concept,
+/// forwarding use of the concept through to the inner type.
+///
+/// The canonical example of this is
+/// [`Result`]($sus::result::Result)`<T, Box<`[`DynError`](
+/// $sus::error::DynError)`>>`, which allows construction via
+/// `sus::err(sus::into(e))` for any `e` that satisfies
+/// [`Error`]($sus::error::Error). The error field, now being a `Box` is still
+/// usable as an [`Error`]($sus::error::Error) allowing generic code that
+/// expects the [`Result`]($sus::result::Result) to hold an
+/// [`Error`]($sus::error::Error) to function even though the actual error has
+/// been type-erased and no longer needs the functions to be templated on it.
+///
+/// The following concepts, when type-erased in `Box` will also be satisfied
+/// by the `Box` itself, avoiding the need to unwrap the inner type and allowing
+/// the `Box` to be used in templated code requiring that concept:
+/// * [`Error`]($sus::error::Error)
+/// * [`Fn`]($sus::fn::Fn)
+/// * [`FnMut`]($sus::fn::FnMut)
+/// * [`FnOnce`]($sus::fn::FnOnce)
 template <class T>
 class [[sus_trivial_abi]] Box final {
   static_assert(!std::is_reference_v<T>, "Box of a reference is not allowed.");
+  static_assert(!std::is_array_v<T>,
+                "Box<T[N]> is not allowed, use Box<Array<T, N>>");
   static_assert(sus::mem::size_of<T>() != 0u);  // Ensure that `T` is defined.
 
  public:
@@ -287,20 +346,77 @@ class [[sus_trivial_abi]] Box final {
     return ret;
   }
 
+  /// A `Box` holding a type-erased function type will satisfy the fn concepts
+  /// and can be used as a function type. It will forward the call through
+  /// to the inner type.
+  ///
+  /// `Box<`[`DynFn`]($sus::fn::DynFn)`>` satisfies [`Fn`]($sus::fn::Fn),
+  /// `Box<`[`DynFnMut`]($sus::fn::DynFnMut)`>` satisfies [`FnMut`]($sus::fn::FnMut),
+  /// and `Box<`[`DynFnOnce`]($sus::fn::DynFnOnce)`>` satisfies [`FnOnce`]($sus::fn::FnOnce).
+  /// The usual compatibility rules apply, allowing [`DynFn`]($sus::fn::DynFn)
+  /// to be treated like [`DynFnMut`]($sus::fn::DynFnMut)
+  /// and both of them to be treated like [`DynFnOnce`]($sus::fn::DynFnOnce).
+  ///
+  /// A `Box<`[`DynFnOnce`]($sus::fn::DynFnOnce)`>` must be moved from
+  /// when called, and will destroy the
+  /// underlying function object after the call completes.
+  ///
+  /// # Examples
+  ///
+  /// A `Box<DynFn>` being used as a function object:
+  /// ```
+  /// const auto b = Box<sus::fn::DynFn<usize(std::string_view)>>::from(
+  ///     &std::string_view::size);
+  /// sus::check(b("hello world") == 11u);
+  ///
+  /// auto mut_b = Box<sus::fn::DynFn<usize(std::string_view)>>::from(
+  ///     &std::string_view::size);
+  /// sus::check(mut_b("hello world") == 11u);
+  ///
+  /// sus::check(sus::move(mut_b)("hello world") == 11u);
+  /// // The object inside `mut_b` is now destroyed.
+  /// ```
+  ///
+  /// A `Box<FynFnMut>` being used as a function object. It can not be called
+  /// on a `const Box` as it requies the ability to mutate, and `const Box`
+  /// treats its inner object as const.
+  ///
+  // TODO: https://github.com/llvm/llvm-project/issues/65904
+  // clang-format off
+  template <class... Args>
+  constexpr sus::fn::Return<T, Args...> operator()(Args&&... args) const&
+    requires(T::IsDynFn &&
+             ::sus::fn::Fn<T, sus::fn::Return<T, Args...>(Args...)>)
+  {
+    ::sus::check_with_message(t_, "Box used after move");
+    return ::sus::fn::call(*t_, ::sus::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  constexpr sus::fn::ReturnMut<T, Args...> operator()(Args&&... args) &
+    requires(T::IsDynFn &&
+             ::sus::fn::FnMut<T, sus::fn::ReturnMut<T, Args...>(Args...)>)
+  {
+    ::sus::check_with_message(t_, "Box used after move");
+    return ::sus::fn::call_mut(*t_, ::sus::forward<Args>(args)...);
+  }
+
   template <class... Args>
-  constexpr sus::fn::Return<T, Args...> operator()(
-      Args&&... args) const noexcept
-    requires(
-        std::same_as<T, ::sus::fn::DynFn<sus::fn::Return<T, Args...>(Args...)>>)
+  constexpr sus::fn::ReturnOnce<T, Args...> operator()(Args&&... args) &&
+    requires(T::IsDynFn &&  //
+             ::sus::fn::FnOnce<T, sus::fn::ReturnOnce<T, Args...>(Args...)>)
   {
     ::sus::check_with_message(t_, "Box used after move");
     struct Cleanup {
-      constexpr ~Cleanup() noexcept { delete t_; }
+      constexpr ~Cleanup() noexcept { delete t; }
       T* t;
     };
-    auto cleanup = Cleanup(::sus::mem::replace(t_, nullptr));
-    return ::sus::fn::call(*cleanup.t, ::sus::forward<Args>(args)...);
+    return ::sus::fn::call_once(
+        sus::move(*Cleanup(::sus::mem::replace(t_, nullptr)).t),
+                           ::sus::forward<Args>(args)...);
   }
+  ;
+  // clang-format on
 
  private:
   enum FromPointer { FROM_POINTER };
diff --git a/sus/boxed/box_unittest.cc b/sus/boxed/box_unittest.cc
index f51b48d71..aab2d639f 100644
--- a/sus/boxed/box_unittest.cc
+++ b/sus/boxed/box_unittest.cc
@@ -305,6 +305,32 @@ TEST(BoxDynError, FromString) {
   }
 }
 
+TEST(BoxDynFn, Example_Call) {
+  {
+    const auto b = Box<sus::fn::DynFn<usize(std::string_view)>>::from(
+        &std::string_view::size);
+    sus::check(b("hello world") == 11u);
+
+    auto mut_b = Box<sus::fn::DynFn<usize(std::string_view)>>::from(
+        &std::string_view::size);
+    sus::check(mut_b("hello world") == 11u);
+
+    sus::check(sus::move(mut_b)("hello world") == 11u);
+    // The object inside `mut_b` is now destroyed.
+  }
+  {
+    auto b = Box<sus::fn::DynFnMut<usize(std::string_view)>>::from(
+        &std::string_view::size);
+    EXPECT_EQ((*b)("hello world"), 11u);
+    EXPECT_EQ(b("hello world"), 11u);
+  }
+  {
+    auto b = Box<sus::fn::DynFnOnce<usize(std::string_view)>>::from(
+        &std::string_view::size);
+    EXPECT_EQ(sus::move(b)("hello world"), 11u);
+  }
+}
+
 TEST(Box, fmt) {
   static_assert(fmt::is_formattable<Box<i32>, char>::value);
   EXPECT_EQ(fmt::format("{}", Box<i32>(12345)), "12345");
diff --git a/sus/error/error.h b/sus/error/error.h
index b96f087cc..1179e4c71 100644
--- a/sus/error/error.h
+++ b/sus/error/error.h
@@ -426,9 +426,7 @@ concept Error = requires(const T& t) {
 template <Error E, class Store>
 struct DynErrorTyped;
 
-/// A type-erased [`Error`]($sus::error::Error) object
-/// which satisfies [`DynConcept`]($sus::boxed::DynConcept)
-/// for all [`Error`]($sus::error::Error)s.
+/// A type-erased [`Error`]($sus::error::Error) object.
 ///
 /// `DynError` also satisfies [`Error`]($sus::error::Error) itself.
 ///
@@ -443,6 +441,9 @@ struct DynErrorTyped;
 /// and it can not be moved similar to
 /// [`Pin<T>`](https://doc.rust-lang.org/std/pin/struct.Pin.html) types in
 /// Rust.
+///
+/// See [`DynConcept`]($sus::boxed::DynConcept) for more on type erasure of
+/// concept-satisfying types.
 struct DynError {
   /// Forwards to the [`Error`]($sus::error::Error) implementation of `E`.
   virtual std::string display() const noexcept = 0;
diff --git a/sus/fn/fn_dyn.h b/sus/fn/fn_dyn.h
index bee46ec70..2244c9390 100644
--- a/sus/fn/fn_dyn.h
+++ b/sus/fn/fn_dyn.h
@@ -40,6 +40,9 @@ struct DynFnOnceTyped;
 
 /// A type-erased object which satisifies the concept [`Fn<R(Args...)>`](
 /// $sus::fn::Fn).
+///
+/// See [`DynConcept`]($sus::boxed::DynConcept) for more on type erasure of
+/// concept-satisfying types.
 template <class R, class... Args>
 struct DynFn<R(Args...)> {
   template <class T>
@@ -47,6 +50,8 @@ struct DynFn<R(Args...)> {
   template <class T, class Store>
   using DynTyped = DynFnTyped<T, Store, R, Args...>;
 
+  static constexpr bool IsDynFn = true;
+
   DynFn() = default;
   virtual ~DynFn() = default;
   DynFn(DynFn&&) = delete;
@@ -64,7 +69,7 @@ struct DynFnTyped final : public DynFn<R(Args...)> {
   constexpr DynFnTyped(Store&& c) : c_(sus::forward<Store>(c)) {}
 
   R operator()(Args&&... args) const override {
-    return c_(::sus::forward<Args>(args)...);
+    return sus::fn::call(c_, ::sus::forward<Args>(args)...);
   }
 
  private:
@@ -73,6 +78,9 @@ struct DynFnTyped final : public DynFn<R(Args...)> {
 
 /// A type-erased object which satisifies the concept [`FnMut<R(Args...)>`](
 /// $sus::fn::FnMut).
+///
+/// See [`DynConcept`]($sus::boxed::DynConcept) for more on type erasure of
+/// concept-satisfying types.
 template <class R, class... Args>
 struct DynFnMut<R(Args...)> {
   template <class T>
@@ -80,6 +88,8 @@ struct DynFnMut<R(Args...)> {
   template <class T, class Store>
   using DynTyped = DynFnMutTyped<T, Store, R, Args...>;
 
+  static constexpr bool IsDynFn = true;
+
   DynFnMut() = default;
   virtual ~DynFnMut() = default;
   DynFnMut(DynFnMut&&) = delete;
@@ -97,7 +107,7 @@ struct DynFnMutTyped final : public DynFnMut<R(Args...)> {
   constexpr DynFnMutTyped(Store&& c) : c_(sus::forward<Store>(c)) {}
 
   R operator()(Args&&... args) override {
-    return c_(::sus::forward<Args>(args)...);
+    return call_mut(c_, ::sus::forward<Args>(args)...);
   }
 
  private:
@@ -106,6 +116,9 @@ struct DynFnMutTyped final : public DynFnMut<R(Args...)> {
 
 /// A type-erased object which satisifies the concept [`FnOnce<R(Args...)>`](
 /// $sus::fn::FnOnce).
+///
+/// See [`DynConcept`]($sus::boxed::DynConcept) for more on type erasure of
+/// concept-satisfying types.
 template <class R, class... Args>
 struct DynFnOnce<R(Args...)> {
   template <class T>
@@ -113,6 +126,8 @@ struct DynFnOnce<R(Args...)> {
   template <class T, class Store>
   using DynTyped = DynFnOnceTyped<T, Store, R, Args...>;
 
+  static constexpr bool IsDynFn = true;
+
   DynFnOnce() = default;
   virtual ~DynFnOnce() = default;
   DynFnOnce(DynFnOnce&&) = delete;
@@ -130,7 +145,7 @@ struct DynFnOnceTyped final : public DynFnOnce<R(Args...)> {
   constexpr DynFnOnceTyped(Store&& c) : c_(sus::forward<Store>(c)) {}
 
   R operator()(Args&&... args) && override {
-    return c_(::sus::forward<Args>(args)...);
+    return call_once(::sus::move(c_), ::sus::forward<Args>(args)...);
   }
 
  private:
diff --git a/sus/fn/fn_dyn_unittest.cc b/sus/fn/fn_dyn_unittest.cc
index 0c2c72167..29ccc9433 100644
--- a/sus/fn/fn_dyn_unittest.cc
+++ b/sus/fn/fn_dyn_unittest.cc
@@ -30,7 +30,7 @@ TEST(FnDyn, Fn) {
 }
 
 TEST(FnDyn, FnBox) {
-  auto x = [](sus::Box<DynFn<i32(i32, i32)>> f) { return call(*f, 1, 2); };
+  auto x = [](sus::Box<DynFn<i32(i32, i32)>> f) { return f(1, 2); };
   i32 c = x(sus::into([](i32 a, i32 b) { return a + b; }));
   EXPECT_EQ(c, 1 + 2);
   i32 d = x(sus::into([](i32 a, i32 b) { return a * b; }));
@@ -48,9 +48,7 @@ TEST(FnMutDyn, FnMut) {
 }
 
 TEST(FnMutDyn, FnMutBox) {
-  auto x = [](sus::Box<DynFnMut<i32(i32, i32)>> f) {
-    return call_mut(*f, 1, 2);
-  };
+  auto x = [](sus::Box<DynFnMut<i32(i32, i32)>> f) { return f(1, 2); };
   i32 c = x(sus::into([](i32 a, i32 b) { return a + b; }));
   EXPECT_EQ(c, 1 + 2);
   i32 d = x(sus::into([](i32 a, i32 b) { return a * b; }));
@@ -71,9 +69,7 @@ TEST(FnDyn, FnOnce) {
 
 TEST(FnOnceDyn, FnOnceBox) {
   auto x = [](sus::Box<DynFnOnce<i32(i32, i32)>> f) {
-    return sus::move(f).consume([](auto&& dynfn) {
-      return ::sus::fn::call_once(sus::move(dynfn), 1, 2);
-    });
+    return sus::move(f)(1, 2);
   };
   i32 c = x(sus::into([](i32 a, i32 b) { return a + b; }));
   EXPECT_EQ(c, 1 + 2);

From 2ee325d8c8faa14bd931e0a4b399071b13808059 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 15:19:51 -0400
Subject: [PATCH 19/31] Add some missing template keywords

---
 sus/iter/iterator_defn.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/sus/iter/iterator_defn.h b/sus/iter/iterator_defn.h
index c6f46ab7f..5de27dec9 100644
--- a/sus/iter/iterator_defn.h
+++ b/sus/iter/iterator_defn.h
@@ -1515,12 +1515,12 @@ constexpr Option<Item> IteratorBase<Iter, Item>::max_by_key(
   // Compares just the keys.
   auto compare = [](const sus::Tuple<Key, Item>& x,
                     const sus::Tuple<Key, Item>& y) {
-    return x.at<0>() <=> y.at<0>();
+    return x.template at<0>() <=> y.template at<0>();
   };
 
   return static_cast<Iter&&>(*this).map(key(fn)).max_by(compare).map(
       [](auto&& key_item) -> Item {
-        return sus::move(key_item).into_inner<1>();
+        return sus::move(key_item).template into_inner<1>();
       });
 }
 
@@ -1568,12 +1568,12 @@ constexpr Option<Item> IteratorBase<Iter, Item>::min_by_key(
   // Compares just the keys.
   auto compare = [](const sus::Tuple<Key, Item>& x,
                     const sus::Tuple<Key, Item>& y) {
-    return x.at<0>() <=> y.at<0>();
+    return x.template at<0>() <=> y.template at<0>();
   };
 
   return static_cast<Iter&&>(*this).map(key(fn)).min_by(compare).map(
       [](auto&& key_item) -> Item {
-        return sus::move(key_item).into_inner<1>();
+        return sus::move(key_item).template into_inner<1>();
       });
 }
 

From b4c2d8f7d9baa1e7f9a99dc65d0cb1f46eb91f49 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 15:21:25 -0400
Subject: [PATCH 20/31] Fix from overload tags to fix links

---
 sus/boxed/box.h | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/sus/boxed/box.h b/sus/boxed/box.h
index add44c02c..aa893376f 100644
--- a/sus/boxed/box.h
+++ b/sus/boxed/box.h
@@ -138,7 +138,7 @@ class [[sus_trivial_abi]] Box final {
   /// Satisfies the [`From<U>`]($sus::construct::From) concept for
   /// [`Box<T>`]($sus::boxed::Box) where `U` is convertible to `T` and is not a
   /// subclass of `T`.
-  /// #[doc.overloads=from.convert]
+  /// #[doc.overloads=convert]
   template <std::convertible_to<T> U>
     requires(!::sus::ptr::SameOrSubclassOf<U*, T*>)
   constexpr static Box from(U u) noexcept
@@ -152,7 +152,7 @@ class [[sus_trivial_abi]] Box final {
   ///
   /// Satisfies the [`From<U>`]($sus::construct::From) concept for
   /// [`Box<T>`]($sus::boxed::Box) where U is `T` or a subclass of `T`.
-  /// #[doc.overloads=from.inherit]
+  /// #[doc.overloads=inherit]
   template <class U>
     requires(::sus::ptr::SameOrSubclassOf<U*, T*>)
   constexpr static Box from(U u) noexcept
@@ -246,6 +246,8 @@ class [[sus_trivial_abi]] Box final {
   ///
   /// See [`DynConcept`]($sus::boxed::DynConcept) for more on type erasure of
   /// concept-satisfying types.
+  ///
+  /// #[doc.overloads=dync]
   template <sus::mem::Move U>
   constexpr static Box from(U u) noexcept
     requires(std::same_as<U, std::remove_cvref_t<U>> &&  //
@@ -265,7 +267,7 @@ class [[sus_trivial_abi]] Box final {
   /// conversion moves and type-erases the `std::string` into a heap-alloocated
   /// [`DynError`]($sus::error::DynError).
   ///
-  /// #[doc.overloads=dynerror.from.string]
+  /// #[doc.overloads=dynerror]
   constexpr static Box from(std::string s) noexcept
     requires(std::same_as<T, ::sus::error::DynError>)
   {

From 3ee7b6fbe45d187ed212b95f264c27d00fd980a9 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 15:30:29 -0400
Subject: [PATCH 21/31] Improve Box<DynFn> docs

---
 sus/boxed/box.h           | 35 ++++++++++++++++++++++++++++++-----
 sus/boxed/box_unittest.cc | 16 ++++++++++++----
 2 files changed, 42 insertions(+), 9 deletions(-)

diff --git a/sus/boxed/box.h b/sus/boxed/box.h
index aa893376f..08a9d192c 100644
--- a/sus/boxed/box.h
+++ b/sus/boxed/box.h
@@ -352,9 +352,12 @@ class [[sus_trivial_abi]] Box final {
   /// and can be used as a function type. It will forward the call through
   /// to the inner type.
   ///
-  /// `Box<`[`DynFn`]($sus::fn::DynFn)`>` satisfies [`Fn`]($sus::fn::Fn),
-  /// `Box<`[`DynFnMut`]($sus::fn::DynFnMut)`>` satisfies [`FnMut`]($sus::fn::FnMut),
-  /// and `Box<`[`DynFnOnce`]($sus::fn::DynFnOnce)`>` satisfies [`FnOnce`]($sus::fn::FnOnce).
+  /// * `Box<`[`DynFn`]($sus::fn::DynFn)`>` satisfies [`Fn`]($sus::fn::Fn).
+  /// * `Box<`[`DynFnMut`]($sus::fn::DynFnMut)`>` satisfies
+  ///   [`FnMut`]($sus::fn::FnMut).
+  /// * `Box<`[`DynFnOnce`]($sus::fn::DynFnOnce)`>` satisfies
+  ///   [`FnOnce`]($sus::fn::FnOnce).
+  ///
   /// The usual compatibility rules apply, allowing [`DynFn`]($sus::fn::DynFn)
   /// to be treated like [`DynFnMut`]($sus::fn::DynFnMut)
   /// and both of them to be treated like [`DynFnOnce`]($sus::fn::DynFnOnce).
@@ -379,10 +382,32 @@ class [[sus_trivial_abi]] Box final {
   /// // The object inside `mut_b` is now destroyed.
   /// ```
   ///
-  /// A `Box<FynFnMut>` being used as a function object. It can not be called
+  /// A `Box<DynFnMut>` being used as a function object. It can not be called
   /// on a `const Box` as it requies the ability to mutate, and `const Box`
-  /// treats its inner object as const.
+  /// treats its inner object as const:
+  /// ```
+  /// auto mut_b = Box<sus::fn::DynFnMut<usize(std::string_view)>>::from(
+  ///     &std::string_view::size);
+  /// sus::check(mut_b("hello world") == 11u);
+  ///
+  /// sus::check(sus::move(mut_b)("hello world") == 11u);
+  /// // The object inside `mut_b` is now destroyed.
+  /// ```
+  ///
+  /// A `Box<DynFnOnce>` being used as a function object. It must be an rvalue
+  /// (either a return from a call or moved with [`move`]($sus::mem::move))
+  /// to call through it:
+  /// ```
+  /// auto b = Box<sus::fn::DynFnOnce<usize(std::string_view)>>::from(
+  ///     &std::string_view::size);
+  /// sus::check(sus::move(b)("hello world") == 11u);
   ///
+  /// auto x = [] {
+  ///   return Box<sus::fn::DynFnOnce<usize(std::string_view)>>::from(
+  ///       &std::string_view::size);
+  /// };
+  /// sus::check(x()("hello world") == 11u);
+  /// ```
   // TODO: https://github.com/llvm/llvm-project/issues/65904
   // clang-format off
   template <class... Args>
diff --git a/sus/boxed/box_unittest.cc b/sus/boxed/box_unittest.cc
index aab2d639f..4c9715504 100644
--- a/sus/boxed/box_unittest.cc
+++ b/sus/boxed/box_unittest.cc
@@ -319,15 +319,23 @@ TEST(BoxDynFn, Example_Call) {
     // The object inside `mut_b` is now destroyed.
   }
   {
-    auto b = Box<sus::fn::DynFnMut<usize(std::string_view)>>::from(
+    auto mut_b = Box<sus::fn::DynFnMut<usize(std::string_view)>>::from(
         &std::string_view::size);
-    EXPECT_EQ((*b)("hello world"), 11u);
-    EXPECT_EQ(b("hello world"), 11u);
+    sus::check(mut_b("hello world") == 11u);
+
+    sus::check(sus::move(mut_b)("hello world") == 11u);
+    // The object inside `mut_b` is now destroyed.
   }
   {
     auto b = Box<sus::fn::DynFnOnce<usize(std::string_view)>>::from(
         &std::string_view::size);
-    EXPECT_EQ(sus::move(b)("hello world"), 11u);
+    sus::check(sus::move(b)("hello world") == 11u);
+
+    auto x = [] {
+      return Box<sus::fn::DynFnOnce<usize(std::string_view)>>::from(
+          &std::string_view::size);
+    };
+    sus::check(x()("hello world") == 11u);
   }
 }
 

From 6de324dbb8eddb7d99b72c1b3325d270d086ea90 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 15:43:42 -0400
Subject: [PATCH 22/31] Fix type in codelink

---
 sus/boxed/box.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sus/boxed/box.h b/sus/boxed/box.h
index 08a9d192c..bbf02b726 100644
--- a/sus/boxed/box.h
+++ b/sus/boxed/box.h
@@ -60,7 +60,7 @@ namespace sus::boxed {
 /// * Supports up-casting (TODO: and [`down-casting`](
 ///   https://github.com/chromium/subspace/issues/333)) without leaving
 ///   requiring a native pointer to be pulled out of the `Box`.
-/// * No native arrays, `Box` can hold [`Array`]($sus::collection::Array) or
+/// * No native arrays, `Box` can hold [`Array`]($sus::collections::Array) or
 ///   [`std::array`](https://en.cppreference.com/w/cpp/container/array) but
 ///   avoids API complexity for supporting pointers and native arrays (which
 ///   decay to pointers) by rejecting native arrays.

From dd02c0e6202ca557b9fd7ac322cc9ec2906a0c14 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 15:59:04 -0400
Subject: [PATCH 23/31] Make all overloads with the same parameters but
 different method qualifiers appear in subdoc

---
 subdoc/gen_tests/struct-complex/S.html  | 28 +++++++++++++++++++++
 subdoc/gen_tests/struct-complex/test.cc | 15 +++++++----
 subdoc/lib/visit.cc                     | 33 +++++++++++++++++++------
 tools/run_subdoc.bat                    |  2 +-
 4 files changed, 65 insertions(+), 13 deletions(-)

diff --git a/subdoc/gen_tests/struct-complex/S.html b/subdoc/gen_tests/struct-complex/S.html
index f1b8690d5..ccbbd8fc2 100644
--- a/subdoc/gen_tests/struct-complex/S.html
+++ b/subdoc/gen_tests/struct-complex/S.html
@@ -73,6 +73,12 @@
         <li>
           <a class="sidebar-item" href="S.html#method.void_method">void_method</a>
         </li>
+        <li>
+          <a class="sidebar-header" href="#operators">Operators</a>
+        </li>
+        <li>
+          <a class="sidebar-item" href="S.html#method.operator()">operator()</a>
+        </li>
         <li>
           <a class="sidebar-header" href="#data-members">Data Members</a>
         </li>
@@ -190,6 +196,28 @@
           </div>
         </div>
       </div>
+      <div class="section methods nonstatic">
+        <div class="section-header">
+          <a name="operators" href="#operators">Operators</a>
+        </div>
+        <div class="section-items">
+          <div class="overload-set item-name">
+            <div class="overload">
+              <div class="function-signature"><a name="method.operator()"></a><span class="function-auto">auto</span> <a class="function-name" href="S.html#method.operator()">operator()</a>() const& -&gt; int</div>
+            </div>
+            <div class="overload">
+              <div class="function-signature"><a name="method.operator()"></a><span class="function-auto">auto</span> <a class="function-name" href="S.html#method.operator()">operator()</a>() & -&gt; bool</div>
+            </div>
+            <div class="overload">
+              <div class="function-signature"><a name="method.operator()"></a><span class="function-auto">auto</span> <a class="function-name" href="S.html#method.operator()">operator()</a>() && -&gt; float</div>
+            </div>
+          </div>
+          <div class="description long">
+            <p>Call operator with two overloads.</p>
+
+          </div>
+        </div>
+      </div>
       <div class="section fields nonstatic">
         <div class="section-header">
           <a name="data-members" href="#data-members">Data Members</a>
diff --git a/subdoc/gen_tests/struct-complex/test.cc b/subdoc/gen_tests/struct-complex/test.cc
index 55a61e2fe..e27b5ee25 100644
--- a/subdoc/gen_tests/struct-complex/test.cc
+++ b/subdoc/gen_tests/struct-complex/test.cc
@@ -6,16 +6,16 @@ struct OtherType {};
 /// Comment headline S
 struct S {
   /// Comment headline void_method
-  void void_method() const& {}
+  void void_method() const&;
   /// Comment headline static_type_method
-  static OtherType static_type_method() {}
+  static OtherType static_type_method();
   /// Comment headline type_method
-  OtherType type_method() {}
+  OtherType type_method();
   /// Comment headline static_bool_method
-  static bool static_bool_method() {}
+  static bool static_bool_method();
 
   // Overload should be grouped with the other int_method().
-  void int_method() volatile {}
+  void int_method() volatile;
 
   /// Comment headline type_field
   const OtherType type_field;
@@ -25,4 +25,9 @@ struct S {
   bool bool_field;
   /// Comment headline static_bool_member
   static bool static_bool_member;
+
+  /// Call operator with two overloads.
+  int operator()() const&;
+  bool operator()() &;
+  float operator()() &&;
 };
diff --git a/subdoc/lib/visit.cc b/subdoc/lib/visit.cc
index a24da4a88..7eb64b60e 100644
--- a/subdoc/lib/visit.cc
+++ b/subdoc/lib/visit.cc
@@ -517,9 +517,10 @@ class Visitor : public clang::RecursiveASTVisitor<Visitor> {
                     ->getNameAsString();
               } else if (auto* convdecl =
                              clang::dyn_cast<clang::CXXConversionDecl>(decl)) {
-                Type t = build_local_type(convdecl->getReturnType(),
-                                          convdecl->getASTContext().getSourceManager(),
-                                          preprocessor_);
+                Type t = build_local_type(
+                    convdecl->getReturnType(),
+                    convdecl->getASTContext().getSourceManager(),
+                    preprocessor_);
                 return std::string("operator ") + t.name;
               } else {
                 return decl->getNameAsString();
@@ -538,10 +539,27 @@ class Visitor : public clang::RecursiveASTVisitor<Visitor> {
             sus::Option<std::string> overload_set =
                 sus::clone(comment.attrs.overload_set);
 
-            std::string signature;
+            std::string signature = "(";
             for (clang::ParmVarDecl* p : decl->parameters()) {
               signature += p->getOriginalType().getAsString();
             }
+            signature += ")";
+            if (auto* mdecl = clang::dyn_cast<clang::CXXMethodDecl>(decl)) {
+              // Prevent a parameter and return qualifier from possibly being
+              // confused for eachother in the string by putting a delimiter in
+              // here that can't appear in the parameter list.
+              signature += " -> ";
+              signature += mdecl->getMethodQualifiers().getAsString();
+              switch (mdecl->getRefQualifier()) {
+                case clang::RefQualifierKind::RQ_None: break;
+                case clang::RefQualifierKind::RQ_LValue:
+                  signature += "&";
+                  break;
+                case clang::RefQualifierKind::RQ_RValue:
+                  signature += "&&";
+                  break;
+              }
+            }
 
             auto linked_return_type = LinkedType::with_type(
                 build_local_type(decl->getReturnType(),
@@ -561,7 +579,7 @@ class Visitor : public clang::RecursiveASTVisitor<Visitor> {
                 decl->getASTContext().getSourceManager().getFileOffset(
                     decl->getLocation()));
 
-            if (clang::isa<clang::CXXMethodDecl>(decl)) {
+            if (auto* mdecl = clang::dyn_cast<clang::CXXMethodDecl>(decl)) {
               sus::check(clang::isa<clang::RecordDecl>(context));
 
               // TODO: It's possible to overload a method in a base class. What
@@ -572,7 +590,6 @@ class Visitor : public clang::RecursiveASTVisitor<Visitor> {
               if (sus::Option<RecordElement&> parent = docs_db_.find_record_mut(
                       clang::cast<clang::RecordDecl>(context));
                   parent.is_some()) {
-                auto* mdecl = clang::cast<clang::CXXMethodDecl>(decl);
                 fe.overloads[0u].method = sus::some(MethodSpecific{
                     .is_static = mdecl->isStatic(),
                     .is_volatile = mdecl->isVolatile(),
@@ -644,7 +661,9 @@ class Visitor : public clang::RecursiveASTVisitor<Visitor> {
       // We already visited this thing, from another translation unit.
       add_overload = false;
     } else {
-      add_overload = true;
+      // The comment is ambiguous, there's another comment for the same overload
+      // set. This is an error.
+      add_overload = false;
       auto& ast_cx = decl->getASTContext();
       const auto& old_comment_element = it->second;
       ast_cx.getDiagnostics()
diff --git a/tools/run_subdoc.bat b/tools/run_subdoc.bat
index 25cd41264..0767f554e 100644
--- a/tools/run_subdoc.bat
+++ b/tools/run_subdoc.bat
@@ -9,4 +9,4 @@ out\subdoc\subdoc -p out --out docs ^
     --project-logo logo.png ^
     --project-name Subspace ^
     --ignore-bad-code-links ^
-    subspace/sus/num/uptr
+    subspace/sus/num/uptr sus/boxed/box_

From b9c3d3a4c1383833ada4e3da910cee4ce5a0ba52 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@orodu.net>
Date: Sun, 10 Sep 2023 16:24:13 -0400
Subject: [PATCH 24/31] Change FnMut concept to use `requires (F&)` not
 `requires (F)`

On clang 16 (but not after for some reason) the concept will not match
any type `F` that is pure virtual. This prevented FnMut from matching
against DynFnMut.

More precisely:

```
template <class T>
concept C = requires(T t) { t.foo(); }
```

This won't match a pure virtual `T` with a mutable `foo()` on clang 16.
It works on 17+ and with GCC 13 and MSVC (at least one version).

`requires(T& t)` does the right thing universally, as in:

```
template <class T>
concept C = requires(T& t) { t.foo(); }
```

Add a rule to STYLE.md and update all concepts that wrote a value type
in a rule to be reference types.
---
 STYLE.md                          |  6 ++++++
 sus/choice/choice_unittest.cc     |  6 +++---
 sus/collections/array_unittest.cc |  4 ++--
 sus/collections/slice_unittest.cc |  4 ++--
 sus/collections/vec_unittest.cc   |  4 ++--
 sus/fn/__private/callable_types.h |  4 ++--
 sus/fn/__private/signature.h      |  2 +-
 sus/fn/callable.h                 | 10 +++++-----
 sus/mem/move_unittest.cc          |  2 +-
 sus/ops/range.h                   |  2 +-
 sus/ptr/nonnull_unittest.cc       |  4 ++--
 11 files changed, 27 insertions(+), 21 deletions(-)

diff --git a/STYLE.md b/STYLE.md
index 1a3ad8358..0dfa46741 100644
--- a/STYLE.md
+++ b/STYLE.md
@@ -60,3 +60,9 @@ footguns, crashes, bugs, and UB.
   * But don't follow the IWYU rules _inside_ the library. We include the minimal internal
     headers internally to reduce the amount of textual parsing needed to satisfy
     including one public header.
+1. All types in requires clauses should be references or pointers.
+   * For mutable access always write it as `requires(T& t)` instead of
+     `requires (T t)`, as the latter will not match pure virtual types in
+     clang-16.
+   * Similarly, for const usage, write `requires (const T& t)` instead of
+     `requires (const T t)`.
diff --git a/sus/choice/choice_unittest.cc b/sus/choice/choice_unittest.cc
index d796bc38f..bfb47156e 100644
--- a/sus/choice/choice_unittest.cc
+++ b/sus/choice/choice_unittest.cc
@@ -619,12 +619,12 @@ TEST(Choice, Clone) {
 }
 
 template <class T, auto Tag>
-concept CanGetRef = requires(T t) { t.template as<Tag>(); };
+concept CanGetRef = requires(T& t) { t.template as<Tag>(); };
 template <class T, auto Tag>
-concept CanGetMut = requires(T t) { t.template as_mut<Tag>(); };
+concept CanGetMut = requires(T& t) { t.template as_mut<Tag>(); };
 template <class T, auto Tag>
 concept CanIntoInner =
-    requires(T t) { sus::move(t).template into_inner<Tag>(); };
+    requires(T& t) { sus::move(t).template into_inner<Tag>(); };
 
 TEST(Choice, Eq) {
   struct NotEq {};
diff --git a/sus/collections/array_unittest.cc b/sus/collections/array_unittest.cc
index 911520415..bb6bce583 100644
--- a/sus/collections/array_unittest.cc
+++ b/sus/collections/array_unittest.cc
@@ -265,7 +265,7 @@ TEST(Array, GetUnchecked) {
 }
 
 template <class T, class U>
-concept HasGetMut = requires(T t, U u) { t.get_mut(u); };
+concept HasGetMut = requires(T& t, const U& u) { t.get_mut(u); };
 
 // get_mut() is only available for mutable arrays.
 static_assert(!HasGetMut<const Array<i32, 3>, usize>);
@@ -289,7 +289,7 @@ TEST(Array, GetMut) {
 
 template <class T, class U>
 concept HasGetUncheckedMut =
-    requires(T t, U u) { t.get_unchecked_mut(unsafe_fn, u); };
+    requires(T& t, const U& u) { t.get_unchecked_mut(unsafe_fn, u); };
 
 // get_unchecked_mut() is only available for mutable arrays.
 static_assert(!HasGetUncheckedMut<const Array<i32, 3>, usize>);
diff --git a/sus/collections/slice_unittest.cc b/sus/collections/slice_unittest.cc
index 5e0fa3524..deb9279a2 100644
--- a/sus/collections/slice_unittest.cc
+++ b/sus/collections/slice_unittest.cc
@@ -105,7 +105,7 @@ TEST(Slice, Get) {
 }
 
 template <class T, class U>
-concept HasGetMut = requires(T t, U u) { t.get_mut(u); };
+concept HasGetMut = requires(T& t, const U& u) { t.get_mut(u); };
 
 // get_mut() is only available for mutable slices. A "const" mutable slice can
 // still give mutable access as the mutability is encoded in the type.
@@ -138,7 +138,7 @@ TEST(Slice, GetUnchecked) {
 
 template <class T, class U>
 concept HasGetUncheckedMut =
-    requires(T t, U u) { t.get_unchecked_mut(unsafe_fn, u); };
+    requires(T& t, const U& u) { t.get_unchecked_mut(unsafe_fn, u); };
 
 // get_unchecked_mut() is only available for mutable slices of mutable types.
 static_assert(!HasGetUncheckedMut<Slice<i32>, usize>);
diff --git a/sus/collections/vec_unittest.cc b/sus/collections/vec_unittest.cc
index 84cdd6c61..0e901d2a5 100644
--- a/sus/collections/vec_unittest.cc
+++ b/sus/collections/vec_unittest.cc
@@ -211,7 +211,7 @@ TEST(Vec, GetMut) {
 }
 
 template <class T, class U>
-concept HasGetMut = requires(T t, U u) { t.get_mut(u); };
+concept HasGetMut = requires(T& t, const U& u) { t.get_mut(u); };
 
 // get_mut() is only available for mutable Vec.
 static_assert(!HasGetMut<const Vec<i32>, usize>);
@@ -233,7 +233,7 @@ TEST(Vec, GetUncheckedMut) {
 
 template <class T, class U>
 concept HasGetUncheckedMut =
-    requires(T t, U u) { t.get_unchecked_mut(unsafe_fn, u); };
+    requires(T& t, const U& u) { t.get_unchecked_mut(unsafe_fn, u); };
 
 // get_unchecked_mut() is only available for mutable Vec.
 static_assert(!HasGetUncheckedMut<const Vec<i32>, usize>);
diff --git a/sus/fn/__private/callable_types.h b/sus/fn/__private/callable_types.h
index 1d02212c3..fe2cf9f39 100644
--- a/sus/fn/__private/callable_types.h
+++ b/sus/fn/__private/callable_types.h
@@ -29,7 +29,7 @@ namespace sus::fn::__private {
 /// and will return a value that can be stored as `R`.
 template <class F, class R, class... Args>
 concept FunctionPointer =
-    std::is_pointer_v<std::decay_t<F>> && requires(F f, Args... args) {
+    std::is_pointer_v<std::decay_t<F>> && requires(F& f, Args... args) {
       { std::invoke(*f, args...) } -> std::convertible_to<R>;
     };
 
@@ -41,7 +41,7 @@ concept IsFunctionPointer =
 /// Whether a functor `T` can convert to a function pointer, typically this
 /// means it's a captureless lambda.
 template <class F>
-concept ConvertsToFunctionPointer = requires(F f) {
+concept ConvertsToFunctionPointer = requires(F& f) {
   { +f } -> IsFunctionPointer;
 };
 
diff --git a/sus/fn/__private/signature.h b/sus/fn/__private/signature.h
index 9ffc76491..45cd1e66b 100644
--- a/sus/fn/__private/signature.h
+++ b/sus/fn/__private/signature.h
@@ -88,7 +88,7 @@ struct InvokedFnMut {
 };
 
 template <class F, class... Ts>
-  requires requires(F f) {
+  requires requires(F& f) {
     { std::invoke(f, std::declval<Ts>()...) };
   }
 struct InvokedFnMut<F, ArgsPack<Ts...>> {
diff --git a/sus/fn/callable.h b/sus/fn/callable.h
index 5e59a720e..b996bac90 100644
--- a/sus/fn/callable.h
+++ b/sus/fn/callable.h
@@ -25,7 +25,7 @@
 namespace sus::fn::callable {
 
 template <class T>
-concept FunctionPointer = requires(T t) {
+concept FunctionPointer = requires(const T& t) {
   { std::is_pointer_v<decltype(+t)> };
 };
 
@@ -42,7 +42,7 @@ concept FunctionPointerReturns = (
     std::convertible_to<std::invoke_result_t<T, Args...>, R> &&
     // We verify that `T` can be stored in a function pointer. Types must match
     // more strictly than just for invoking it.
-    requires (R(*p)(Args...), T t) {
+    requires (R(*p)(Args...), T& t) {
         { p = t };
     }
 );
@@ -63,7 +63,7 @@ concept FunctionPointerMatches = (
     FunctionPointer<T> &&
     // We verify that `T` can be stored in a function pointer. Types must match
     // more strictly than just for invoking it.
-    requires (R(*p)(Args...), T t) {
+    requires (R(*p)(Args...), T& t) {
         { p = t };
     }
 );
@@ -73,7 +73,7 @@ concept FunctionPointerMatches = (
 template <class T, class... Args>
 concept FunctionPointerWith = (
     FunctionPointer<T> &&
-    requires (T t, Args&&... args) {
+    requires (T& t, Args&&... args) {
         std::invoke(t, ::sus::mem::forward<Args>(args)...);
     }
 );
@@ -90,7 +90,7 @@ inline constexpr bool callable_const(R (T::*)(Args...) const) {
 
 template <class T, class R, class... Args>
 concept CallableObjectReturnsOnce =
-    !FunctionPointer<T> && requires(T t, Args&&... args) {
+    !FunctionPointer<T> && requires(T& t, Args&&... args) {
       {
         std::invoke(static_cast<T&&>(t), ::sus::mem::forward<Args>(args)...)
       } -> std::convertible_to<R>;
diff --git a/sus/mem/move_unittest.cc b/sus/mem/move_unittest.cc
index 657123141..46e619620 100644
--- a/sus/mem/move_unittest.cc
+++ b/sus/mem/move_unittest.cc
@@ -28,7 +28,7 @@ struct NonTrivial {
 
 // clang-format off
 template <class T>
-concept can_move = requires(T t) {
+concept can_move = requires(T& t) {
   { move(t) };
 };
 // clang-format on
diff --git a/sus/ops/range.h b/sus/ops/range.h
index 1bedb475d..715a6fd19 100644
--- a/sus/ops/range.h
+++ b/sus/ops/range.h
@@ -28,7 +28,7 @@ namespace sus::ops {
 /// `RangeBounds` is implemented by Subspace's range types, and produced by
 /// range syntax like `..`, `a..`, `..b`, `..=c`, `d..e`, or `f..=g`.
 template <class T, class I>
-concept RangeBounds = requires(const T& t, T v, I i) {
+concept RangeBounds = requires(const T& t, T& v, const I& i) {
   { t.start_bound() } -> std::same_as<::sus::option::Option<const I&>>;
   { t.end_bound() } -> std::same_as<::sus::option::Option<const I&>>;
   // Rvalue overloads must not exist as they would return a reference to a
diff --git a/sus/ptr/nonnull_unittest.cc b/sus/ptr/nonnull_unittest.cc
index 5de15b9a5..593c337e4 100644
--- a/sus/ptr/nonnull_unittest.cc
+++ b/sus/ptr/nonnull_unittest.cc
@@ -153,7 +153,7 @@ TEST(NonNull, AsRef) {
 }
 
 template <class T>
-concept AsRefMutExists = requires(T t) { t.as_mut(); };
+concept AsRefMutExists = requires(T& t) { t.as_mut(); };
 
 TEST(NonNull, AsRefMut) {
   int i = 1;
@@ -180,7 +180,7 @@ TEST(NonNull, AsPtr) {
 }
 
 template <class T>
-concept AsPtrMutExists = requires(T t) { t.as_mut_ptr(); };
+concept AsPtrMutExists = requires(T& t) { t.as_mut_ptr(); };
 
 TEST(NonNull, AsPtrMut) {
   int i = 1;

From e4833c980e725af03ba29ac866aec6df0e332cf4 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 16:52:00 -0400
Subject: [PATCH 25/31] Add docs for the boxed namespace

---
 sus/boxed/__private/string_error.h |  2 ++
 sus/boxed/box.h                    |  1 +
 sus/boxed/boxed.h                  | 25 +++++++++++++++++++++++++
 sus/boxed/dyn.h                    | 17 ++++++++++++-----
 4 files changed, 40 insertions(+), 5 deletions(-)
 create mode 100644 sus/boxed/boxed.h

diff --git a/sus/boxed/__private/string_error.h b/sus/boxed/__private/string_error.h
index 55b19bbd6..7ff6b5c6c 100644
--- a/sus/boxed/__private/string_error.h
+++ b/sus/boxed/__private/string_error.h
@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// IWYU pragma: private
+// IWYU pragma: friend "sus/.*"
 #pragma once
 
 #include "sus/error/error.h"
diff --git a/sus/boxed/box.h b/sus/boxed/box.h
index bbf02b726..e27664570 100644
--- a/sus/boxed/box.h
+++ b/sus/boxed/box.h
@@ -19,6 +19,7 @@
 #include <type_traits>
 
 #include "sus/boxed/__private/string_error.h"
+#include "sus/boxed/boxed.h"  // namespace docs.
 #include "sus/error/error.h"
 #include "sus/fn/fn_concepts.h"
 #include "sus/fn/fn_dyn.h"
diff --git a/sus/boxed/boxed.h b/sus/boxed/boxed.h
new file mode 100644
index 000000000..646b0e954
--- /dev/null
+++ b/sus/boxed/boxed.h
@@ -0,0 +1,25 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// IWYU pragma: private
+// IWYU pragma: friend "sus/boxed/.*"
+#pragma once
+
+namespace sus {
+
+/// The [`Box<T>`]($sus::boxed::Box) type for heap allocation and other
+/// tools for [type-erasure of concepts]($sus::boxed::DynConcept).
+namespace boxed {}
+
+}  // namespace sus
diff --git a/sus/boxed/dyn.h b/sus/boxed/dyn.h
index 92eb3ef5b..a81472ded 100644
--- a/sus/boxed/dyn.h
+++ b/sus/boxed/dyn.h
@@ -17,6 +17,7 @@
 #include <concepts>
 #include <type_traits>
 
+#include "sus/boxed/boxed.h"  // namespace docs.
 #include "sus/macros/lifetimebound.h"
 #include "sus/mem/forward.h"
 #include "sus/mem/move.h"
@@ -64,7 +65,8 @@ namespace sus::boxed {
 /// The [`dyn`]($sus::boxed::dyn) function, and its returned type should only
 /// appear in function call arguments. The returned type
 /// [`Dyn`]($sus::boxed::Dyn) can not be moved, and it only converts a
-/// reference to a `ConcreteT` into a reference to `DynC`.
+/// reference to a type `T&` into a reference `DynC&` that also satisfies `C`
+/// but without templates.
 /// This can be used to call functions that accept a type-erased concept
 /// by reference, such as with a `const DynC&` parameter.
 ///
@@ -233,8 +235,13 @@ concept DynConcept = requires {
   requires !std::is_move_assignable_v<DynC>;
 };
 
-/// Type erases a reference to a `ConcreteT` which satisfies a concept `C`,
-/// into a reference to `DynC`. Returned from [`dyn`]($sus::boxed::dyn).
+/// A type erasure of a type satisfying a concept, which can be used as a
+/// reference without heap allocation or templates.
+/// Returned from [`dyn`]($sus::boxed::dyn).
+///
+/// This type is similar to `Box<DynC>` for purposes of type erasure but does
+/// not require heap allocation,
+/// and it converts directly to a reference to the erased type.
 ///
 /// Use [`dyn`]($sus::boxed::dyn) to convert to a `DynC` reference instead of
 /// constructing this type directly.
@@ -310,8 +317,8 @@ class [[nodiscard]] Dyn {
   typename DynC::template DynTyped<ConcreteT, ConcreteT&> dyn_;
 };
 
-/// Type erases a reference to a `ConcreteT` which satisfies a concept `C`,
-/// into a reference to `DynC`.
+/// Type erases a reference to a type `T&` which satisfies a concept `C`,
+/// into a reference `DynC&` that also satisfies `C` but without templates.
 ///
 /// Use `dyn<DynC>(x)` to convert a mutable reference to `x` into `DynC&` and
 /// `dyn<const DynC>(x)` to convert a const or mutable reference to `x` into

From fcbb850d0718e9649c06a5a32edddc4cd3d4dd8e Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 17:12:31 -0400
Subject: [PATCH 26/31] Remove FnMutBox from OnceWith and make it constexpr

---
 sus/iter/once_with.h           | 54 +++++++++++++++++++++-------------
 sus/iter/once_with_unittest.cc |  4 +++
 2 files changed, 38 insertions(+), 20 deletions(-)

diff --git a/sus/iter/once_with.h b/sus/iter/once_with.h
index 39b2f80a6..e4fe09eda 100644
--- a/sus/iter/once_with.h
+++ b/sus/iter/once_with.h
@@ -23,7 +23,7 @@ namespace sus::iter {
 
 using ::sus::option::Option;
 
-template <class ItemT>
+template <class ItemT, class GenFn>
 class OnceWith;
 
 /// Creates an iterator that lazily generates a value exactly once by invoking
@@ -41,45 +41,59 @@ class OnceWith;
 /// auto ow = sus::iter::once_with<u16>([]() { return 3_u16; });
 /// sus::check(ow.next().unwrap() == 3_u16);
 /// ```
-template <class Item>
-inline OnceWith<Item> once_with(::sus::fn::FnMutBox<Item()> gen) noexcept {
-  return OnceWith<Item>(::sus::move(gen));
+template <class Item, ::sus::fn::FnMut<Item()> GenFn>
+constexpr inline OnceWith<Item, GenFn> once_with(GenFn gen) noexcept {
+  return OnceWith<Item, GenFn>(::sus::move(gen));
 }
 
 /// An Iterator that walks over at most a single Item.
-template <class ItemT>
-class [[nodiscard]] [[sus_trivial_abi]] OnceWith final
-    : public IteratorBase<OnceWith<ItemT>, ItemT> {
+template <class ItemT, class GenFn>
+class [[nodiscard]] OnceWith final
+    : public IteratorBase<OnceWith<ItemT, GenFn>, ItemT> {
  public:
   using Item = ItemT;
 
+  // Type is Move and (can be) Clone.
+  OnceWith(OnceWith&&) = default;
+  OnceWith& operator=(OnceWith&&) = default;
+
+  // sus::mem::Clone trait.
+  constexpr OnceWith clone() const noexcept
+    requires(::sus::mem::Clone<GenFn>)
+  {
+    return OnceWith(sus::clone(gen_));
+  }
+
   // sus::iter::Iterator trait.
-  Option<Item> next() noexcept {
-    return gen_.take().map([](auto&& gen) { return ::sus::fn::call_mut(gen); });
+  constexpr Option<Item> next() noexcept {
+    return gen_.take().map(
+        [](auto&& gen) -> Item { return ::sus::fn::call_mut(gen); });
   }
   /// sus::iter::Iterator trait.
-  SizeHint size_hint() const noexcept {
+  constexpr SizeHint size_hint() const noexcept {
     ::sus::num::usize rem = gen_.is_some() ? 1u : 0u;
     return SizeHint(rem, ::sus::Option<::sus::num::usize>(rem));
   }
   // sus::iter::DoubleEndedIterator trait.
-  Option<Item> next_back() noexcept {
-    return gen_.take().map([](auto&& gen) { return ::sus::fn::call_mut(gen); });
+  constexpr Option<Item> next_back() noexcept {
+    return gen_.take().map(
+        [](auto&& gen) -> Item { return ::sus::fn::call_mut(gen); });
   }
   // sus::iter::ExactSizeIterator trait.
-  usize exact_size_hint() const noexcept { return gen_.is_some() ? 1u : 0u; }
+  constexpr usize exact_size_hint() const noexcept {
+    return gen_.is_some() ? 1u : 0u;
+  }
 
  private:
-  friend OnceWith<Item> sus::iter::once_with<Item>(
-      ::sus::fn::FnMutBox<Item()> gen) noexcept;
+  friend constexpr OnceWith<Item, GenFn> sus::iter::once_with<Item>(
+      GenFn gen) noexcept;
 
-  OnceWith(::sus::fn::FnMutBox<Item()> gen)
-      : gen_(sus::Option<::sus::fn::FnMutBox<Item()>>(::sus::move(gen))) {
-  }
+  constexpr OnceWith(GenFn gen) : gen_(sus::Option<GenFn>(::sus::move(gen))) {}
 
-  Option<::sus::fn::FnMutBox<Item()>> gen_;
+  Option<GenFn> gen_;
 
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(gen_));
+  sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
+                                           decltype(gen_));
 };
 
 }  // namespace sus::iter
diff --git a/sus/iter/once_with_unittest.cc b/sus/iter/once_with_unittest.cc
index 5f575dcbf..ed186a459 100644
--- a/sus/iter/once_with_unittest.cc
+++ b/sus/iter/once_with_unittest.cc
@@ -44,4 +44,8 @@ TEST(OnceWith, NextBack) {
   EXPECT_EQ(ow.next_back(), sus::none());
 }
 
+// constexpr, and verifies that the return type can be converted to the Item
+// type
+static_assert(sus::iter::once_with<i32>([] { return 5; }).sum() == 5);
+
 }  // namespace

From 88bbcf1354c5218b59be99b885577558b50c660d Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 17:25:41 -0400
Subject: [PATCH 27/31] Remove FnMutBox from Successors and make it constexpr

Also test it more!
---
 sus/iter/once_with_unittest.cc   |  2 +-
 sus/iter/repeat_with_unittest.cc |  3 ++-
 sus/iter/successors.h            | 40 +++++++++++++++++++-------------
 sus/iter/successors_unittest.cc  | 35 ++++++++++++++++++++++++++++
 4 files changed, 62 insertions(+), 18 deletions(-)

diff --git a/sus/iter/once_with_unittest.cc b/sus/iter/once_with_unittest.cc
index ed186a459..d6e690b8c 100644
--- a/sus/iter/once_with_unittest.cc
+++ b/sus/iter/once_with_unittest.cc
@@ -45,7 +45,7 @@ TEST(OnceWith, NextBack) {
 }
 
 // constexpr, and verifies that the return type can be converted to the Item
-// type
+// type.
 static_assert(sus::iter::once_with<i32>([] { return 5; }).sum() == 5);
 
 }  // namespace
diff --git a/sus/iter/repeat_with_unittest.cc b/sus/iter/repeat_with_unittest.cc
index 021706646..9dbcb1078 100644
--- a/sus/iter/repeat_with_unittest.cc
+++ b/sus/iter/repeat_with_unittest.cc
@@ -46,7 +46,8 @@ TEST(RepeatWith, NextBack) {
   EXPECT_EQ(o.next_back(), sus::some(3_u16));
 }
 
-// constexpr
+// constexpr, and verifies that the return type can be converted to the Item
+// type.
 static_assert(sus::iter::repeat_with<i32>([] { return 3; }).take(4u).sum() ==
               3 * 4);
 
diff --git a/sus/iter/successors.h b/sus/iter/successors.h
index 2872f6006..d9ff3455f 100644
--- a/sus/iter/successors.h
+++ b/sus/iter/successors.h
@@ -23,7 +23,7 @@ namespace sus::iter {
 
 using ::sus::option::Option;
 
-template <class ItemT>
+template <class ItemT, class GenFn>
 class Successors;
 
 /// Creates a new iterator where each successive item is computed based on the
@@ -41,32 +41,42 @@ class Successors;
 ///     sus::move(powers_of_10).collect<Vec<u16>>() ==
 ///     sus::Slice<u16>::from({1_u16, 10_u16, 100_u16, 1000_u16, 10000_u16}));
 /// ```
-template <class Item>
-inline Successors<Item> successors(
-    Option<Item> first,
-    ::sus::fn::FnMutBox<Option<Item>(const Item&)> func) noexcept {
-  return Successors<Item>(::sus::move(first), ::sus::move(func));
+template <class Item, ::sus::fn::FnMut<Option<Item>(const Item&)> GenFn>
+constexpr inline Successors<Item, GenFn> successors(Option<Item> first,
+                                                    GenFn func) noexcept {
+  return Successors<Item, GenFn>(::sus::move(first), ::sus::move(func));
 }
 
 /// An Iterator that generates each item from a function that takes the previous
 /// item.
 ///
 /// This type is created by `sus::iter::successors()`.
-template <class ItemT>
+template <class ItemT, class GenFn>
 class [[nodiscard]] Successors final
-    : public IteratorBase<Successors<ItemT>, ItemT> {
+    : public IteratorBase<Successors<ItemT, GenFn>, ItemT> {
  public:
   using Item = ItemT;
 
+  // Type is Move and (can be) Clone.
+  Successors(Successors&&) = default;
+  Successors& operator=(Successors&&) = default;
+
+  // sus::mem::Clone trait.
+  constexpr Successors clone() const noexcept
+    requires(::sus::mem::Clone<GenFn>)
+  {
+    return Successors(sus::clone(next_), sus::clone(func_));
+  }
+
   // sus::iter::Iterator trait.
-  Option<Item> next() noexcept {
+  constexpr Option<Item> next() noexcept {
     Option<Item> item = next_.take();
     if (item.is_some()) next_ = ::sus::fn::call_mut(func_, item.as_value());
     return item;
   }
 
   /// sus::iter::Iterator trait.
-  SizeHint size_hint() const noexcept {
+  constexpr SizeHint size_hint() const noexcept {
     if (next_.is_some())
       return SizeHint(1u, ::sus::Option<::sus::num::usize>());
     else
@@ -74,16 +84,14 @@ class [[nodiscard]] Successors final
   }
 
  private:
-  friend Successors<Item> sus::iter::successors<Item>(
-      Option<Item> first,
-      ::sus::fn::FnMutBox<Option<Item>(const Item&)> func) noexcept;
+  friend constexpr Successors<Item, GenFn> sus::iter::successors<Item>(
+      Option<Item> first, GenFn func) noexcept;
 
-  Successors(Option<Item> first,
-             ::sus::fn::FnMutBox<Option<Item>(const Item&)>&& func)
+  constexpr Successors(Option<Item> first, GenFn func)
       : next_(::sus::move(first)), func_(::sus::move(func)) {}
 
   Option<Item> next_;
-  ::sus::fn::FnMutBox<Option<Item>(const Item&)> func_;
+  GenFn func_;
 
   sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
                                            decltype(next_), decltype(func_));
diff --git a/sus/iter/successors_unittest.cc b/sus/iter/successors_unittest.cc
index ae741126f..43e7c2525 100644
--- a/sus/iter/successors_unittest.cc
+++ b/sus/iter/successors_unittest.cc
@@ -27,4 +27,39 @@ TEST(Successors, Example) {
       sus::Slice<u16>::from({1_u16, 10_u16, 100_u16, 1000_u16, 10000_u16}));
 }
 
+TEST(Successors, Some) {
+  auto empty = sus::iter::successors<i32>(
+      sus::some(2), [](i32 n) -> sus::Option<i32> { return sus::some(n + 1); });
+  EXPECT_EQ(empty.size_hint().lower, 1u);
+  EXPECT_EQ(empty.size_hint().upper, sus::none());
+  EXPECT_EQ(empty.next().unwrap(), 2);
+  EXPECT_EQ(empty.next().unwrap(), 3);
+  EXPECT_EQ(empty.next().unwrap(), 4);
+}
+
+TEST(Successors, None) {
+  auto empty = sus::iter::successors<i32>(
+      sus::none(), [](i32 n) -> sus::Option<i32> { return sus::some(n + 1); });
+  EXPECT_EQ(empty.size_hint().lower, 0u);
+  EXPECT_EQ(empty.size_hint().upper, sus::some(0u));
+  EXPECT_EQ(empty.next().is_none(), true);
+}
+
+// constexpr, and verifies that the return type can be converted to the Item
+// type.
+static_assert(sus::iter::successors<i32>(sus::some(2),
+                                         [](i32 i) -> sus::Option<i32> {
+                                           return sus::some(i + 1);
+                                         })
+                  .take(4u)
+                  .sum() == 2 + 3 + 4 + 5);
+
+// Longer iteration.
+static_assert(sus::iter::successors<i32>(sus::some(2),
+                                         [](i32 i) {
+                                           return sus::Option<i32>(i);
+                                         })
+                  .take(100u)
+                  .sum() == 2 * 100);
+
 }  // namespace

From 54b831a10429e09297098c69f77ddfcd634ecac2 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 17:28:26 -0400
Subject: [PATCH 28/31] Remove use of FnBox in subdoc RunOptions

Use Box<DynFn> instead.
---
 subdoc/lib/run_options.h      | 7 +++++--
 subdoc/tests/type_unittest.cc | 2 +-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/subdoc/lib/run_options.h b/subdoc/lib/run_options.h
index ee7f03388..9940eca22 100644
--- a/subdoc/lib/run_options.h
+++ b/subdoc/lib/run_options.h
@@ -17,6 +17,7 @@
 #include <regex>
 
 #include "subdoc/llvm.h"
+#include "sus/boxed/box.h"
 #include "sus/fn/fn.h"
 #include "sus/option/option.h"
 #include "sus/prelude.h"
@@ -39,7 +40,8 @@ struct RunOptions {
     return sus::move(*this);
   }
   RunOptions set_on_tu_complete(
-      sus::fn::FnBox<void(clang::ASTContext&, clang::Preprocessor&)> fn) && {
+      sus::Box<sus::fn::DynFn<void(clang::ASTContext&, clang::Preprocessor&)>>
+          fn) && {
     on_tu_complete = sus::some(sus::move(fn));
     return sus::move(*this);
   }
@@ -54,7 +56,8 @@ struct RunOptions {
   ///
   /// Used for tests to observe the AST and test subdoc methods that act on
   /// things from the AST.
-  sus::Option<sus::fn::FnBox<void(clang::ASTContext&, clang::Preprocessor&)>>
+  sus::Option<
+      sus::Box<sus::fn::DynFn<void(clang::ASTContext&, clang::Preprocessor&)>>>
       on_tu_complete;
   /// The overview markdown which will be applied as the doc comment to the
   /// global namespace/project overview page. This is the raw markdown text, not
diff --git a/subdoc/tests/type_unittest.cc b/subdoc/tests/type_unittest.cc
index 7c5a173cc..2fc418d89 100644
--- a/subdoc/tests/type_unittest.cc
+++ b/subdoc/tests/type_unittest.cc
@@ -83,7 +83,7 @@ struct SubDocTypeTest : public SubDocTest {
                                     clang::Preprocessor&)> auto body) {
     auto opts = subdoc::RunOptions()           //
                     .set_show_progress(false)  //
-                    .set_on_tu_complete(body);
+                    .set_on_tu_complete(sus::move_into(body));
     auto result = run_code_with_options(opts, code);
     ASSERT_TRUE(result.is_ok());
   }

From 72968c4394361c33439978b3b3496aed3cd6c998 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 20:14:35 -0400
Subject: [PATCH 29/31] Remove the FnRef and FnBox types

These are superceded by the general concept-type-erasure mechanism
of DynConcept and the DynFn/Mut/Once type-erasure support types.
---
 subdoc/lib/gen/generate_type.h    |   2 +-
 sus/CMakeLists.txt                |  11 +-
 sus/collections/slice.h           |   1 -
 sus/collections/vec.h             |   1 -
 sus/fn/__private/callable_types.h |  81 ---
 sus/fn/__private/fn_box_storage.h |  77 ---
 sus/fn/__private/fn_ref_invoker.h |  78 ---
 sus/fn/bind.h                     | 283 ----------
 sus/fn/callable.h                 | 118 ----
 sus/fn/fn.h                       |   4 -
 sus/fn/fn_box_defn.h              | 694 -----------------------
 sus/fn/fn_box_impl.h              | 225 --------
 sus/fn/fn_box_unittest.cc         | 709 ------------------------
 sus/fn/fn_concepts.h              |  98 ++--
 sus/fn/fn_ref.h                   | 511 -----------------
 sus/fn/fn_ref_unittest.cc         | 891 ------------------------------
 sus/iter/__private/iter_compare.h |   1 +
 sus/iter/adaptors/filter.h        |   2 +-
 sus/iter/adaptors/filter_map.h    |   2 +-
 sus/iter/adaptors/flat_map.h      |   2 +-
 sus/iter/adaptors/fuse.h          |   2 +-
 sus/iter/adaptors/inspect.h       |   2 +-
 sus/iter/adaptors/map.h           |   2 +-
 sus/iter/adaptors/map_while.h     |   2 +-
 sus/iter/adaptors/reverse.h       |   2 +-
 sus/iter/adaptors/scan.h          |   2 +-
 sus/iter/adaptors/skip_while.h    |   2 +-
 sus/iter/once_with.h              |   2 +-
 sus/iter/repeat_with.h            |   2 +-
 sus/iter/successors.h             |   2 +-
 sus/ops/ord.h                     |   1 -
 sus/result/result.h               |   2 +-
 32 files changed, 51 insertions(+), 3763 deletions(-)
 delete mode 100644 sus/fn/__private/callable_types.h
 delete mode 100644 sus/fn/__private/fn_box_storage.h
 delete mode 100644 sus/fn/__private/fn_ref_invoker.h
 delete mode 100644 sus/fn/bind.h
 delete mode 100644 sus/fn/callable.h
 delete mode 100644 sus/fn/fn_box_defn.h
 delete mode 100644 sus/fn/fn_box_impl.h
 delete mode 100644 sus/fn/fn_box_unittest.cc
 delete mode 100644 sus/fn/fn_ref.h
 delete mode 100644 sus/fn/fn_ref_unittest.cc

diff --git a/subdoc/lib/gen/generate_type.h b/subdoc/lib/gen/generate_type.h
index d57ddf63a..086d6c12a 100644
--- a/subdoc/lib/gen/generate_type.h
+++ b/subdoc/lib/gen/generate_type.h
@@ -17,7 +17,7 @@
 #include "subdoc/lib/database.h"
 #include "subdoc/lib/gen/html_writer.h"
 #include "subdoc/lib/type.h"
-#include "sus/fn/fn_ref.h"
+#include "sus/fn/fn.h"
 #include "sus/prelude.h"
 
 namespace subdoc::gen {
diff --git a/sus/CMakeLists.txt b/sus/CMakeLists.txt
index 6d4d2c2ad..ac6e5b27d 100644
--- a/sus/CMakeLists.txt
+++ b/sus/CMakeLists.txt
@@ -76,16 +76,9 @@ target_sources(subspace PUBLIC
     "env/var.h"
     "error/compat_error.h"
     "error/error.h"
-    "fn/__private/callable_types.h"
-    "fn/__private/fn_box_storage.h"
-    "fn/__private/fn_ref_invoker.h"
     "fn/__private/signature.h"
-    "fn/callable.h"
     "fn/fn.h"
-    "fn/bind.h"
-    "fn/fn_box_defn.h"
-    "fn/fn_box_impl.h"
-    "fn/fn_ref.h"
+    "fn/fn_dyn.h"
     "iter/__private/into_iterator_archetype.h"
     "iter/__private/is_generator.h"
     "iter/__private/iter_compare.h"
@@ -277,10 +270,8 @@ if(${SUBSPACE_BUILD_TESTS})
         "construct/default_unittest.cc"
         "env/var_unittest.cc"
         "error/error_unittest.cc"
-        "fn/fn_box_unittest.cc"
         "fn/fn_concepts_unittest.cc"
         "fn/fn_dyn_unittest.cc"
-        "fn/fn_ref_unittest.cc"
         "iter/compat_ranges_unittest.cc"
         "iter/empty_unittest.cc"
         "iter/generator_unittest.cc"
diff --git a/sus/collections/slice.h b/sus/collections/slice.h
index 7da030971..2ef410dfa 100644
--- a/sus/collections/slice.h
+++ b/sus/collections/slice.h
@@ -28,7 +28,6 @@
 #include "sus/collections/join.h"
 #include "sus/construct/default.h"
 #include "sus/fn/fn_concepts.h"
-#include "sus/fn/fn_ref.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/iter/iterator_ref.h"
 #include "sus/lib/__private/forward_decl.h"
diff --git a/sus/collections/vec.h b/sus/collections/vec.h
index 5f720bc14..befab4a48 100644
--- a/sus/collections/vec.h
+++ b/sus/collections/vec.h
@@ -34,7 +34,6 @@
 #include "sus/collections/iterators/vec_iter.h"
 #include "sus/collections/slice.h"
 #include "sus/fn/fn_concepts.h"
-#include "sus/fn/fn_ref.h"
 #include "sus/iter/adaptors/by_ref.h"
 #include "sus/iter/adaptors/enumerate.h"
 #include "sus/iter/adaptors/take.h"
diff --git a/sus/fn/__private/callable_types.h b/sus/fn/__private/callable_types.h
deleted file mode 100644
index fe2cf9f39..000000000
--- a/sus/fn/__private/callable_types.h
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2023 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// IWYU pragma: private
-// IWYU pragma: friend "sus/.*"
-#pragma once
-
-#include <concepts>
-#include <functional>
-#include <type_traits>
-
-#include "sus/mem/forward.h"
-#include "sus/mem/move.h"
-
-namespace sus::fn::__private {
-
-/// Whether a functor `F` is a function pointer that is callable with `Args...`
-/// and will return a value that can be stored as `R`.
-template <class F, class R, class... Args>
-concept FunctionPointer =
-    std::is_pointer_v<std::decay_t<F>> && requires(F& f, Args... args) {
-      { std::invoke(*f, args...) } -> std::convertible_to<R>;
-    };
-
-/// Whether a functor `T` is a function pointer.
-template <class T>
-concept IsFunctionPointer =
-    std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>;
-
-/// Whether a functor `T` can convert to a function pointer, typically this
-/// means it's a captureless lambda.
-template <class F>
-concept ConvertsToFunctionPointer = requires(F& f) {
-  { +f } -> IsFunctionPointer;
-};
-
-/// Whether a functor `F` is a callable object (with an `operator()`) that is
-/// once-callable as an rvalue with `Args...` and will return a value that can
-/// be stored as `R`.
-template <class F, class R, class... Args>
-concept CallableOnceMut =
-    !FunctionPointer<F, R, Args...> && requires(F&& f, Args... args) {
-      {
-        std::invoke(::sus::move(f), ::sus::forward<Args>(args)...)
-      } -> std::convertible_to<R>;
-    };
-
-/// Whether a functor `F` is a callable object (with an `operator()`) that is
-/// mutable-callable as an lvalue with `Args...` and will return a value that
-/// can be stored as `R`.
-template <class F, class R, class... Args>
-concept CallableMut =
-    !FunctionPointer<F, R, Args...> && requires(F& f, Args... args) {
-      {
-        std::invoke(f, ::sus::forward<Args>(args)...)
-      } -> std::convertible_to<R>;
-    };
-
-/// Whether a functor `F` is a callable object (with an `operator()`) that is
-/// const-callable with `Args...` and will return a value that can be stored as
-/// `R`.
-template <class F, class R, class... Args>
-concept CallableConst =
-    !FunctionPointer<F, R, Args...> && requires(const F& f, Args... args) {
-      {
-        std::invoke(f, ::sus::forward<Args>(args)...)
-      } -> std::convertible_to<R>;
-    };
-
-}  // namespace sus::fn::__private
diff --git a/sus/fn/__private/fn_box_storage.h b/sus/fn/__private/fn_box_storage.h
deleted file mode 100644
index c73e1b00d..000000000
--- a/sus/fn/__private/fn_box_storage.h
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright 2022 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// IWYU pragma: private
-// IWYU pragma: friend "sus/.*"
-#pragma once
-
-#include <functional>
-
-#include "sus/option/option.h"
-
-namespace sus::fn::__private {
-
-struct FnBoxStorageVtableBase {};
-
-struct FnBoxStorageBase {
-  virtual ~FnBoxStorageBase() = default;
-
-  // Should be to a static lifetime pointee.
-  Option<const FnBoxStorageVtableBase&> vtable;
-};
-
-template <class R, class... CallArgs>
-struct FnBoxStorageVtable final : public FnBoxStorageVtableBase {
-  R (*call_once)(__private::FnBoxStorageBase&&, CallArgs...);
-  R (*call_mut)(__private::FnBoxStorageBase&, CallArgs...);
-  R (*call)(const __private::FnBoxStorageBase&, CallArgs...);
-};
-
-template <class F>
-class FnBoxStorage final : public FnBoxStorageBase {
- public:
-  ~FnBoxStorage() override = default;
-
-  constexpr FnBoxStorage(F&& callable)
-    requires(!(std::is_member_function_pointer_v<std::remove_reference_t<F>> ||
-               std::is_member_object_pointer_v<std::remove_reference_t<F>>))
-      : callable_(::sus::move(callable)) {}
-  constexpr FnBoxStorage(F ptr)
-    requires(std::is_member_function_pointer_v<F> ||
-             std::is_member_object_pointer_v<F>)
-      : callable_(ptr) {}
-
-  template <class R, class... CallArgs>
-  static R call(const FnBoxStorageBase& self_base, CallArgs... callargs) {
-    const auto& self = static_cast<const FnBoxStorage&>(self_base);
-    return std::invoke(self.callable_, forward<CallArgs>(callargs)...);
-  }
-
-  template <class R, class... CallArgs>
-  static R call_mut(FnBoxStorageBase& self_base, CallArgs... callargs) {
-    auto& self = static_cast<FnBoxStorage&>(self_base);
-    return std::invoke(self.callable_, forward<CallArgs>(callargs)...);
-  }
-
-  template <class R, class... CallArgs>
-  static R call_once(FnBoxStorageBase&& self_base, CallArgs... callargs) {
-    auto&& self = static_cast<FnBoxStorage&&>(self_base);
-    return std::invoke(::sus::move(self.callable_),
-                       forward<CallArgs>(callargs)...);
-  }
-
-  F callable_;
-};
-
-}  // namespace sus::fn::__private
diff --git a/sus/fn/__private/fn_ref_invoker.h b/sus/fn/__private/fn_ref_invoker.h
deleted file mode 100644
index 0a2ba540b..000000000
--- a/sus/fn/__private/fn_ref_invoker.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright 2023 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// IWYU pragma: private
-// IWYU pragma: friend "sus/.*"
-#pragma once
-
-#include <functional>
-
-#include "sus/mem/forward.h"
-#include "sus/mem/move.h"
-
-namespace sus::fn::__private {
-
-union Storage {
-  void (*fnptr)();
-  void* object;
-};
-
-/// Functions to call a functor `F` that is stored in `Storage`. The choice of
-/// function encodes which member of `Storage` holds the functor.
-template <class F>
-struct Invoker {
-  /// Calls the `F` in `Storage`, allowing mutable overlaods, when it is a
-  /// function pointer.
-  template <class R, class... Args>
-  static R fnptr_call_mut(const union Storage& s, Args... args) {
-    F f = reinterpret_cast<F>(s.fnptr);
-    return std::invoke(*f, ::sus::forward<Args>(args)...);
-  }
-
-  /// Calls the `F` in `Storage`, as an lvalue, when it is a callable object.
-  template <class R, class... Args>
-  static R object_call_mut(const union Storage& s, Args... args) {
-    F& f = *static_cast<F*>(s.object);
-    return std::invoke(f, ::sus::forward<Args>(args)...);
-  }
-
-  /// Calls the `F` in `Storage`, as an rvalue, when it is a callable object.
-  template <class R, class... Args>
-  static R object_call_once(const union Storage& s, Args... args) {
-    F& f = *static_cast<F*>(s.object);
-    return std::invoke(::sus::move(f), ::sus::forward<Args>(args)...);
-  }
-
-  /// Calls the `F` in `Storage`, allowing only const overloads, when it is a
-  /// function pointer.
-  template <class R, class... Args>
-  static R fnptr_call_const(const union Storage& s, Args... args) {
-    const F f = reinterpret_cast<const F>(s.fnptr);
-    return std::invoke(*f, ::sus::forward<Args>(args)...);
-  }
-
-  /// Calls the `F` in `Storage`, as a const object, when it is a callable
-  /// object.
-  template <class R, class... Args>
-  static R object_call_const(const union Storage& s, Args... args) {
-    const F& f = *static_cast<const F*>(s.object);
-    return std::invoke(f, ::sus::forward<Args>(args)...);
-  }
-};
-
-/// A function pointer type that matches all the invoke functions the `Invoker`.
-template <class R, class... CallArgs>
-using InvokeFnPtr = R (*)(const union Storage& s, CallArgs... args);
-
-}  // namespace sus::fn::__private
diff --git a/sus/fn/bind.h b/sus/fn/bind.h
deleted file mode 100644
index f1e01df70..000000000
--- a/sus/fn/bind.h
+++ /dev/null
@@ -1,283 +0,0 @@
-// Copyright 2022 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// IWYU pragma: private, include "sus/fn/fn.h"
-// IWYU pragma: friend "sus/.*"
-#pragma once
-
-#include <type_traits>
-
-#include "sus/fn/callable.h"
-#include "sus/fn/fn_box_defn.h"
-#include "sus/macros/__private/compiler_bugs.h"
-#include "sus/macros/eval_macro.h"
-#include "sus/macros/for_each.h"
-#include "sus/macros/remove_parens.h"
-#include "sus/marker/unsafe.h"
-#include "sus/mem/forward.h"
-#include "sus/mem/move.h"
-
-/// Bind a const lambda to storage for its bound arguments. The output can be
-/// used to construct a FnOnceBox, FnMutBox, or FnBox.
-///
-/// The first argument is a list of variables that will be bound into storage
-/// for access from the lambda, wrapped in sus_store(). If there are no
-/// variables to mention, sus_store() can be empty, or use the sus_bind0() macro
-/// which omits this list.
-///
-/// The second argument is a lambda, which can include captures. Any captures of
-/// variables outside the lambda must be referenced in the sus_store() list.
-///
-/// Use `sus_take(x)` in the sus_store() list to move `x` into storage instead
-/// of copying it.
-///
-/// Use `sus_unsafe_pointer(x)` to store a pointer named `x`. This is dangerous
-/// and discouraged, and using smart pointers is strongly preferred.
-///
-/// # Example
-///
-/// This binds a lambda with 3 captures, the first two being variables from the
-/// outside scope. The second variable is used as a reference to the storage,
-/// rather that copying or moving it into the lambda.
-/// ```
-/// sus_bind(sus_store(a, b), [a, &b, c = 1]() {}))
-/// ```
-///
-/// # Implementation note
-/// The lambda may arrive in multiple arguments, if there is a comma in the
-/// definition of it. Thus we use variadic arguments to capture all of the
-/// lambda.
-#define sus_bind(names, lambda, ...)                                        \
-  [&]() {                                                                   \
-    [&]() consteval {                                                       \
-      sus_for_each(_sus__check_storage, sus_for_each_sep_none,              \
-                   _sus__unpack names)                                      \
-    }();                                                                    \
-    using ::sus::fn::__private::SusBind;                                    \
-    return SusBind(                                                         \
-        [sus_for_each(_sus__declare_storage, sus_for_each_sep_comma,        \
-                      _sus__unpack names)]<class... Args>(Args&&... args) { \
-          const auto x = lambda __VA_OPT__(, ) __VA_ARGS__;                 \
-          const bool is_const =                                             \
-              ::sus::fn::callable::CallableObjectConst<decltype(x)>;        \
-          if constexpr (!is_const) {                                        \
-            return ::sus::fn::__private::CheckCallableObjectConst<          \
-                is_const>::template error<void>();                          \
-          } else {                                                          \
-            return x(::sus::forward<Args>(args)...);                        \
-          }                                                                 \
-        });                                                                 \
-  }()
-
-/// A variant of `sus_bind()` which only takes a lambda, omitting the
-/// `sus_store()` list.  The output can be used to construct a FnOnceBox,
-/// FnMutBox, or FnBox.
-///
-/// Because there is no `sus_store()` list, the lambda can not capture variables
-/// from the outside scope, however it can still declare captures contained
-/// entirely inside the lambda.
-///
-/// # Example
-///
-/// This defines a lambda with a capture `a` of type `int`, and binds it so it
-/// can be used to construct a FnOnceBox, FnMutBox, or FnBox.
-/// ```
-/// sus_bind0([a = int(1)](char, int){})
-/// ```
-#define sus_bind0(lambda, ...) \
-  sus_bind(sus_store(), lambda __VA_OPT__(, ) __VA_ARGS__)
-
-/// Bind a mutable lambda to storage for its bound arguments. The output can be
-/// used to construct a FnOnceBox or FnMutBox.
-///
-/// Because the storage is mutable, the lambda may capture references to the
-/// storage and mutate it, and the lambda itself may be marked mutable.
-///
-/// The first argument is a list of variables that will be bound into storage
-/// for access from the lambda, wrapped in sus_store(). If there are no
-/// variables to mention, sus_store() can be empty, or use the sus_bind0() macro
-/// which omits this list.
-///
-/// The second argument is a lambda, which can include captures. Any captures of
-/// variables outside the lambda must be referenced in the sus_store() list.
-///
-/// Use `sus_take(x)` in the sus_store() list to move `x` into storage instead
-/// of copying it.
-///
-/// Use `sus_unsafe_pointer(x)` to store a pointer named `x`. This is dangerous
-/// and discouraged, and using smart pointers is strongly preferred.
-///
-/// # Example
-///
-/// This binds a lambda with 3 captures, the first two being variables from the
-/// outside scope. The second variable is used as a reference to the storage,
-/// rather that copying or moving it into the lambda.
-/// ```
-/// sus_bind_mut(sus_store(a, b), [a, &b, c = 1]() {}))
-/// ```
-///
-/// # Implementation note The lambda may arrive in multiple arguments, if there
-/// is a comma in the definition of it. Thus we use variadic arguments to
-/// capture all of the lambda.
-#define sus_bind_mut(names, lambda, ...)                                 \
-  [&]() {                                                                \
-    [&]() consteval {                                                    \
-      sus_for_each(_sus__check_storage, sus_for_each_sep_none,           \
-                   _sus__unpack names)                                   \
-    }();                                                                 \
-    return ::sus::fn::__private::SusBind(                                \
-        [sus_for_each(_sus__declare_storage_mut, sus_for_each_sep_comma, \
-                      _sus__unpack names)]<class... Args>(               \
-            Args&&... args) mutable {                                    \
-          auto x = lambda __VA_OPT__(, ) __VA_ARGS__;                    \
-          return x(::sus::mem::forward<Args>(args)...);                  \
-        });                                                              \
-  }()
-
-/// A variant of `sus_bind_mut()` which only takes a lambda, omitting the
-/// `sus_store()` list.  The output can be used to construct a FnOnceBox or
-/// FnMutBox.
-///
-/// Because there is no `sus_store()` list, the lambda can not capture variables
-/// from the outside scope, however it can still declare captures contained
-/// entirely inside the lambda.
-///
-/// Can be used with a mutable lambda that can mutate its captures.
-///
-/// # Example
-///
-/// This defines a lambda with a capture `a` of type `int`, and binds it so it
-/// can be used to construct a FnOnceBox, FnMutBox, or FnBox.
-/// ```
-/// sus_bind0_mut([a = int(1)](char, int){})
-/// ```
-#define sus_bind0_mut(lambda, ...) \
-  sus_bind_mut(sus_store(), lambda __VA_OPT__(, ) __VA_ARGS__)
-
-/// Declares the set of captures from the outside scope in `sus_bind()` or
-/// `sus_bind_mut()`.
-#define sus_store(...) (__VA_ARGS__)
-/// Marks a capture in the `sus_store()` list to be moved from the outside scope
-/// instead of copied.
-#define sus_take(x) (x, _sus__bind_move)
-/// Marks a capture in the `sus_store()` list as a pointer which is being
-/// intentionally and unsafely captured. Otherwise, pointers are not allowed to
-/// be captured.
-#define sus_unsafe_pointer(x) (x, _sus__bind_pointer)
-
-namespace sus::fn::__private {
-
-/// Helper type returned by sus_bind() and used to construct a closure.
-template <class F>
-struct SusBind final {
-  constexpr inline SusBind(F&& lambda) : lambda(::sus::move(lambda)) {}
-
-  /// The lambda generated by sus_bind() which holds the user-provided
-  /// lambda and any storage required for it.
-  F lambda;
-};
-
-// The type generated by sus_unsafe_pointer() for storage in sus_bind().
-template <class T>
-struct UnsafePointer;
-
-template <class T>
-struct UnsafePointer<T*> final {
-  constexpr inline UnsafePointer(::sus::marker::UnsafeFnMarker, T* pointer)
-      : pointer(pointer) {}
-  T* pointer;
-};
-
-template <class T>
-UnsafePointer(::sus::marker::UnsafeFnMarker, T*) -> UnsafePointer<T*>;
-
-template <class T>
-auto make_storage(T&& t) {
-  return std::decay_t<T>(forward<T>(t));
-}
-template <class T>
-auto make_storage(T*) {
-  static_assert(!std::is_pointer_v<T*>,
-                "Can not store a pointer in sus_bind() except through "
-                "sus_unsafe_pointer().");
-}
-template <class T>
-auto make_storage(UnsafePointer<T*> p) {
-  return static_cast<const T*>(p.pointer);
-}
-
-template <class T>
-auto make_storage_mut(T&& t) {
-  return std::decay_t<T>(forward<T>(t));
-}
-template <class T>
-auto make_storage_mut(T* t) {
-  make_storage(t);
-}
-template <class T>
-auto make_storage_mut(UnsafePointer<T*> p) {
-  return p.pointer;
-}
-
-// Verifies the input is an lvalue (a name), so we can bind it to that same
-// lvalue name in the resulting lambda.
-template <class T>
-std::true_type is_lvalue(T&);
-std::false_type is_lvalue(...);
-
-/// Helper used when verifying if a lambda is const. The template parameter
-/// represents the constness of the lambda. When false, the error() function
-/// generates a compiler error.
-template <bool = true>
-struct CheckCallableObjectConst final {
-  template <class U>
-  static constexpr inline auto error() {}
-};
-
-template <>
-struct CheckCallableObjectConst<false> final {
-  template <class U>
-  static consteval inline auto error() {
-    throw "Use sus_bind_mut() to bind a mutable lambda";
-  }
-};
-
-}  // namespace sus::fn::__private
-
-// Private helper.
-#define _sus__declare_storage(x)                                   \
-  sus_eval_macro(_sus__declare_storage_impl, sus_remove_parens(x), \
-                 _sus__bind_noop)
-#define _sus__declare_storage_impl(x, modify, ...) \
-  x = ::sus::fn::__private::make_storage(modify(x))
-#define _sus__declare_storage_mut(x)                                   \
-  sus_eval_macro(_sus__declare_storage_impl_mut, sus_remove_parens(x), \
-                 _sus__bind_noop)
-#define _sus__declare_storage_impl_mut(x, modify, ...) \
-  x = ::sus::fn::__private::make_storage_mut(modify(x))
-#define _sus__check_storage(x, ...)                              \
-  sus_eval_macro(_sus__check_storage_impl, sus_remove_parens(x), \
-                 _sus__bind_noop)
-#define _sus__check_storage_impl(x, modify, ...)                     \
-  static_assert(decltype(::sus::fn::__private::is_lvalue(x))::value, \
-                "sus_bind() can only bind to variable names (lvalues).");
-
-#define _sus__bind_noop(x) x
-#define _sus__bind_move(x) ::sus::move(x)
-#define _sus__bind_pointer(x) \
-  ::sus::fn::__private::UnsafePointer(::sus::marker::unsafe_fn, x)
-
-// Private helper.
-#define _sus__unpack sus_bind_stored_argumnts_should_be_wrapped_in_sus_store
-#define sus_bind_stored_argumnts_should_be_wrapped_in_sus_store(...) __VA_ARGS__
diff --git a/sus/fn/callable.h b/sus/fn/callable.h
deleted file mode 100644
index b996bac90..000000000
--- a/sus/fn/callable.h
+++ /dev/null
@@ -1,118 +0,0 @@
-// Copyright 2022 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// IWYU pragma: private, include "sus/fn/fn.h"
-// IWYU pragma: friend "sus/.*"
-#pragma once
-
-#include <concepts>
-#include <functional>
-#include <type_traits>
-
-#include "sus/mem/forward.h"
-
-namespace sus::fn::callable {
-
-template <class T>
-concept FunctionPointer = requires(const T& t) {
-  { std::is_pointer_v<decltype(+t)> };
-};
-
-/// Verifies that T is a function pointer (or captureless lambda) that returns
-/// a type convertible to `R` when called with `Args`.
-///
-/// This concept allows conversion of `Args` to the function's actual receiving
-/// types and conversion from the function's return type to `R`.
-///
-// clang-format off
-template <class T, class R, class... Args>
-concept FunctionPointerReturns = (
-    FunctionPointer<T> &&
-    std::convertible_to<std::invoke_result_t<T, Args...>, R> &&
-    // We verify that `T` can be stored in a function pointer. Types must match
-    // more strictly than just for invoking it.
-    requires (R(*p)(Args...), T& t) {
-        { p = t };
-    }
-);
-// clang-format on
-
-/// Verifies that T is a function pointer (or captureless lambda) that receives
-/// exactly `Args` as its parameters without conversion, and returns `R` without
-/// conversion.
-///
-/// This is concept is useful if you intend to store the pointer in a strongly
-/// typed function pointer, as the types must match exactly. If you only intend
-/// to call the function pointer, prefer `FunctionPointerReturns` which allows
-/// appropriate conversions.
-//
-// clang-format off
-template <class T, class R, class... Args>
-concept FunctionPointerMatches = (
-    FunctionPointer<T> &&
-    // We verify that `T` can be stored in a function pointer. Types must match
-    // more strictly than just for invoking it.
-    requires (R(*p)(Args...), T& t) {
-        { p = t };
-    }
-);
-// clang-format on
-
-// clang-format off
-template <class T, class... Args>
-concept FunctionPointerWith = (
-    FunctionPointer<T> &&
-    requires (T& t, Args&&... args) {
-        std::invoke(t, ::sus::mem::forward<Args>(args)...);
-    }
-);
-// clang-format on
-
-namespace __private {
-
-template <class T, class R, class... Args>
-inline constexpr bool callable_const(R (T::*)(Args...) const) {
-  return true;
-};
-
-}  // namespace __private
-
-template <class T, class R, class... Args>
-concept CallableObjectReturnsOnce =
-    !FunctionPointer<T> && requires(T& t, Args&&... args) {
-      {
-        std::invoke(static_cast<T&&>(t), ::sus::mem::forward<Args>(args)...)
-      } -> std::convertible_to<R>;
-    };
-
-template <class T, class R, class... Args>
-concept CallableObjectReturnsConst =
-    !FunctionPointer<T> && requires(const T& t, Args&&... args) {
-      {
-        std::invoke(t, ::sus::mem::forward<Args>(args)...)
-      } -> std::convertible_to<R>;
-    };
-
-template <class T, class R, class... Args>
-concept CallableObjectReturnsMut =
-    !FunctionPointer<T> && requires(T& t, Args&&... args) {
-      {
-        std::invoke(t, ::sus::mem::forward<Args>(args)...)
-      } -> std::convertible_to<R>;
-    };
-
-template <class T>
-concept CallableObjectConst = __private::callable_const(&T::operator());
-
-}  // namespace sus::fn::callable
diff --git a/sus/fn/fn.h b/sus/fn/fn.h
index f2a41a109..36af7b383 100644
--- a/sus/fn/fn.h
+++ b/sus/fn/fn.h
@@ -15,10 +15,6 @@
 #pragma once
 
 // IWYU pragma: begin_exports
-#include "sus/fn/bind.h"
-#include "sus/fn/fn_box_defn.h"
-#include "sus/fn/fn_box_impl.h"
 #include "sus/fn/fn_concepts.h"
-#include "sus/fn/fn_ref.h"
 #include "sus/fn/fn_dyn.h"
 // IWYU pragma: end_exports
diff --git a/sus/fn/fn_box_defn.h b/sus/fn/fn_box_defn.h
deleted file mode 100644
index d837d00ed..000000000
--- a/sus/fn/fn_box_defn.h
+++ /dev/null
@@ -1,694 +0,0 @@
-// Copyright 2022 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// IWYU pragma: private, include "sus/fn/fn.h"
-// IWYU pragma: friend "sus/.*"
-#pragma once
-
-#include "sus/fn/callable.h"
-#include "sus/lib/__private/forward_decl.h"
-#include "sus/mem/forward.h"
-#include "sus/mem/move.h"
-#include "sus/mem/never_value.h"
-#include "sus/mem/relocate.h"
-
-namespace sus::fn {
-
-namespace __private {
-
-/// The type-erased type (dropping the type of the internal lambda) of the
-/// closure's heap-allocated storage.
-struct FnBoxStorageBase;
-
-/// Helper type returned by sus_bind() and used to construct a closure.
-template <class F>
-struct SusBind;
-
-/// Helper to determine which functions need to be instantiated for the closure,
-/// to be called from FnOnceBox, FnMutBox, and/or FnBox.
-///
-/// This type indicates the closure can only be called from FnOnceBox.
-enum StorageConstructionFnOnceBoxType { StorageConstructionFnOnceBox };
-/// Helper to determine which functions need to be instantiated for the closure,
-/// to be called from FnOnceBox, FnMutBox, and/or FnBox.
-///
-/// This type indicates the closure can be called from FnMutBox or FnOnceBox.
-enum StorageConstructionFnMutBoxType { StorageConstructionFnMutBox };
-/// Helper to determine which functions need to be instantiated for the closure,
-/// to be called from FnOnceBox, FnMutBox, and/or FnBox.
-///
-/// This type indicates the closure can be called from FnBox, FnMutBox or
-/// FnOnceBox.
-enum StorageConstructionFnBoxType { StorageConstructionFnBox };
-
-/// Used to indicate if the closure is holding a function pointer or
-/// heap-allocated storage.
-enum FnBoxType {
-  /// Holds a function pointer or captureless lambda.
-  FnBoxPointer = 1,
-  /// Holds the type-erased output of sus_bind() in a heap allocation.
-  Storage = 2,
-};
-
-}  // namespace __private
-
-// TODO: Consider generic lambdas, it should be possible to bind them into
-// FnOnceBox/FnMutBox/FnBox?
-// Example:
-// ```
-//    auto even = [](const auto& i) { return i % 2 == 0; };
-//    auto r0 = sus::Array<int, 11>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
-//    10); auto result = r0.iter().filter(even);
-// ```
-
-// TODO: There's no way to capture an rvalue right now. Need something like
-// sus_take() but like sus_make(i, x.foo()) to bind `i = x.foo()`.
-
-// TODO: There's no way to capture a reference right now, sus_unsafe_ref()?
-
-/// A closure that erases the type of the internal callable object (lambda). A
-/// FnOnceBox may only be called a single time.
-///
-/// FnBox can be used as a FnMutBox, which can be used as a FnOnceBox.
-///
-/// Lambdas without captures can be converted into a FnOnceBox, FnMutBox, or
-/// FnBox directly. If the lambda has captured, it must be given to one of:
-///
-/// - `sus_bind(sus_store(..captures..), lambda)` to bind a const lambda which
-/// captures variables from local state. Variables to be captured in the lambda
-/// must also be named in sus_store(). `sus_bind()` only allows those named
-/// variables to be captured, and ensures they are stored by value instead of by
-/// reference.
-///
-/// - `sus_bind0(lambda)` to bind a const lambda which has bound variables that
-/// don't capture state from outside the lambda, such as `[i = 2]() { return i;
-/// }`.
-///
-/// - `sus_bind_mut(sus_store(...captures...), lambda)` to bind a mutable lambda
-/// which captures variables from local state.
-///
-/// - `sus_bind0_mut(lambda)` to bind a mutable lambda which has bound variables
-/// that don't capture state from outside the lambda, such as `[i = 2]() {
-/// return ++i; }`.
-///
-/// Within sus_store(), a variable name can be wrapped with a helper to capture
-/// in different ways:
-///
-/// - `sus_take(x)` will move `x` into the closure instead of copying it.
-///
-/// - `sus_unsafe_pointer(x)` will allow capturing a pointer. Otherwise it be
-/// disallowed, and it is strongly discouraged as it requires careful present
-/// and future understanding of the pointee's lifetime.
-///
-/// # Example
-///
-/// Moves `a` into the closure's storage, and copies b. The lambda then refers
-/// to the closure's stored values by reference.
-///
-/// ```
-/// int a = 1;
-/// int b = 2;
-/// FnOnceBox<void()> f = sus_bind_mut(
-///   sus_store(sus_take(a), b), [&a, &b]() mutable { a += b; }
-/// );
-/// ```
-///
-/// Copies `a` into the closure's storage and defines a `b` from an rvalue.
-/// Since `b` isn't referred to outside the FnBox it does not need to be bound.
-///
-/// ```
-/// int a = 1;
-/// FnOnceBox<void()> f = sus_bind_mut(
-///   sus_store(a), [&a, b = 2]() mutable { a += b; }
-/// );
-/// ```
-///
-/// TODO: There's no way to do this currently, since it won't know what to name
-/// the `x.foo()` value.
-///
-/// ```
-/// struct { int foo() { return 2; } } x;
-/// FnOnceBox<void()> f = sus_bind_mut(
-///   sus_store(x.foo()), [&a]() mutable { a += 1; }
-/// );
-/// ```
-///
-/// # Why can a "const" FnBox convert to a mutable FnMutBox or FnOnceBox?
-///
-/// A FnMutBox or FnOnceBox is _allowed_ to mutate its storage, but a "const"
-/// FnBox closure would just choose not to do so.
-///
-/// However, a `const FnBox` requires that the storage is not mutated, so it is
-/// not useful if converted to a `const FnMutBox` or `const FnOnceBox` which are
-/// only callable as mutable objects.
-///
-/// # Null pointers
-///
-/// A null function pointer is not allowed, constructing a FnOnceBox from a null
-/// pointer will panic.
-template <class R, class... CallArgs>
-class [[sus_trivial_abi]] FnOnceBox<R(CallArgs...)> {
- public:
-  /// Construction from a function pointer or captureless lambda.
-  ///
-  /// #[doc.overloads=ctor.fnpointer]
-  template <::sus::fn::callable::FunctionPointerMatches<R, CallArgs...> F>
-  FnOnceBox(F ptr) noexcept;
-
-  /// Construction from a method or data member pointer.
-  ///
-  /// #[doc.overloads=ctor.methodpointer]
-  template <::sus::fn::callable::CallableObjectReturnsOnce<R, CallArgs...> F>
-    requires(std::is_member_function_pointer_v<F> ||
-             std::is_member_object_pointer_v<F>)
-  FnOnceBox(F ptr) noexcept
-      : FnOnceBox(__private::StorageConstructionFnOnceBox, ptr) {}
-
-  /// Construction from a compatible FnOnceBox.
-  ///
-  /// #[doc.overloads=ctor.fnoncebox]
-  template <class U, class... UArgs>
-    requires(::sus::fn::callable::CallableObjectReturnsOnce<
-             FnOnceBox<U, UArgs...> &&, R, CallArgs...>)
-  FnOnceBox(FnOnceBox<U, UArgs...>&& box) noexcept
-      : FnOnceBox<R(CallArgs...)>(__private::StorageConstructionFnOnceBox,
-                                  ::sus::move(box)) {}
-
-  /// Construction from a compatible FnMutBox.
-  ///
-  /// #[doc.overloads=ctor.fnmutbox]
-  template <class U, class... UArgs>
-    requires(::sus::fn::callable::CallableObjectReturnsOnce<
-             FnMutBox<U, UArgs...>, R, CallArgs...>)
-  FnOnceBox(FnMutBox<U, UArgs...>&& box) noexcept
-      : FnOnceBox<R(CallArgs...)>(__private::StorageConstructionFnOnceBox,
-                                  ::sus::move(box)) {}
-
-  /// Construction from a compatible FnBox.
-  ///
-  /// #[doc.overloads=ctor.fnbox]
-  template <class U, class... UArgs>
-    requires(::sus::fn::callable::CallableObjectReturnsOnce<FnBox<U, UArgs...>,
-                                                            R, CallArgs...>)
-  FnOnceBox(FnBox<U, UArgs...>&& box) noexcept
-      : FnOnceBox<R(CallArgs...)>(__private::StorageConstructionFnOnceBox,
-                                  ::sus::move(box)) {}
-
-  /// Construction from the output of `sus_bind()`.
-  ///
-  /// #[doc.overloads=ctor.bind]
-  template <::sus::fn::callable::CallableObjectReturnsOnce<R, CallArgs...> F>
-  FnOnceBox(__private::SusBind<F>&& holder) noexcept
-      : FnOnceBox(__private::StorageConstructionFnOnceBox,
-                  ::sus::move(holder.lambda)) {}
-
-  ~FnOnceBox() noexcept;
-
-  FnOnceBox(FnOnceBox&& o) noexcept;
-  FnOnceBox& operator=(FnOnceBox&& o) noexcept;
-
-  FnOnceBox(const FnOnceBox&) noexcept = delete;
-  FnOnceBox& operator=(const FnOnceBox&) noexcept = delete;
-
-  /// Runs and consumes the closure.
-  inline R operator()(CallArgs... args) && noexcept;
-
-  /// `sus::construct::From` trait implementation.
-  //
-  // For function pointers or lambdas without captures.
-  template <::sus::fn::callable::FunctionPointerMatches<R, CallArgs...> F>
-  constexpr static auto from(F fn) noexcept {
-    return FnOnceBox(fn);
-  }
-  // For method or data member pointers.
-  template <::sus::fn::callable::CallableObjectReturnsOnce<R, CallArgs...> F>
-    requires(std::is_member_function_pointer_v<F> ||
-             std::is_member_object_pointer_v<F>)
-  constexpr static auto from(F fn) noexcept {
-    return FnOnceBox(fn);
-  }
-  // For compatible FnOnceBox.
-  template <class U, class... UArgs>
-    requires(::sus::fn::callable::CallableObjectReturnsOnce<
-             FnOnceBox<U, UArgs...> &&, R, CallArgs...>)
-  constexpr static auto from(FnOnceBox<U, UArgs...>&& box) noexcept {
-    return FnOnceBox(::sus::move(box));
-  }
-  // For compatible FnMutBox.
-  template <class U, class... UArgs>
-    requires(::sus::fn::callable::CallableObjectReturnsOnce<
-             FnMutBox<U, UArgs...>, R, CallArgs...>)
-  constexpr static auto from(FnMutBox<U, UArgs...>&& box) noexcept {
-    return FnOnceBox(::sus::move(box));
-  }
-  // For compatible FnBox.
-  template <class U, class... UArgs>
-    requires(::sus::fn::callable::CallableObjectReturnsOnce<FnBox<U, UArgs...>,
-                                                            R, CallArgs...>)
-  constexpr static auto from(FnBox<U, UArgs...>&& box) noexcept {
-    return FnOnceBox(::sus::move(box));
-  }
-  // For the output of `sus_bind()`.
-  template <::sus::fn::callable::CallableObjectReturnsOnce<R, CallArgs...> F>
-  constexpr static auto from(__private::SusBind<F>&& holder) noexcept {
-    return FnOnceBox(::sus::move(holder));
-  }
-
- protected:
-  template <class ConstructionType,
-            ::sus::fn::callable::CallableObjectReturnsOnce<R, CallArgs...> F>
-    requires(!(std::is_member_function_pointer_v<std::remove_reference_t<F>> ||
-               std::is_member_object_pointer_v<std::remove_reference_t<F>>))
-  FnOnceBox(ConstructionType, F&& lambda) noexcept;
-
-  template <class ConstructionType,
-            ::sus::fn::callable::CallableObjectReturnsOnce<R, CallArgs...> F>
-    requires(std::is_member_function_pointer_v<F> ||
-             std::is_member_object_pointer_v<F>)
-  FnOnceBox(ConstructionType, F ptr) noexcept;
-
-  union {
-    // Used when the closure is a function pointer (or a captureless lambda,
-    // which is converted to a function pointer).
-    R (*fn_ptr_)(CallArgs...);
-
-    // Used when the closure is a lambda with storage, generated by
-    // `sus_bind()`. This is a type-erased pointer to the heap storage.
-    __private::FnBoxStorageBase* storage_;
-  };
-  // TODO: Could we query the allocator to see if the pointer here is heap
-  // allocated or not, instead of storing a (pointer-sized, due to alignment)
-  // flag here?
-  __private::FnBoxType type_;
-
- private:
-  // Functions to construct and return a pointer to a static vtable object for
-  // the `__private::FnBoxStorage` being stored in `storage_`.
-  //
-  // A FnOnceBox needs to store only a single pointer, for call_once(). But a
-  // FnBox needs to store three, for call(), call_mut() and call_once() since it
-  // can be converted to a FnMutBox or FnOnceBox. For that reason we have 3
-  // overloads where each one instantiates only the functions it requires - to
-  // avoid trying to compile functions that aren't accessible and thus don't
-  // need to be able to compile.
-  template <class FnBoxStorage>
-  static void make_vtable(FnBoxStorage&,
-                          __private::StorageConstructionFnOnceBoxType) noexcept;
-  template <class FnBoxStorage>
-  static void make_vtable(FnBoxStorage&,
-                          __private::StorageConstructionFnMutBoxType) noexcept;
-  template <class FnBoxStorage>
-  static void make_vtable(FnBoxStorage&,
-                          __private::StorageConstructionFnBoxType) noexcept;
-
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(fn_ptr_),
-                                  decltype(storage_), decltype(type_));
-  // Set the never value field to FnBoxPointer to perform a no-op destruction as
-  // there is nothing cleaned up when holding a function pointer.
-  sus_class_never_value_field(::sus::marker::unsafe_fn, FnOnceBox, type_,
-                              static_cast<__private::FnBoxType>(0),
-                              __private::FnBoxType::FnBoxPointer);
-
- protected:
-  // For the NeverValueField.
-  explicit FnOnceBox(::sus::mem::NeverValueConstructor) noexcept
-      : type_(static_cast<__private::FnBoxType>(0)) {}
-};
-
-/// A closure that erases the type of the internal callable object (lambda). A
-/// FnMutBox may be called a multiple times, and may mutate its storage.
-///
-/// FnBox can be used as a FnMutBox, which can be used as a FnOnceBox.
-///
-/// Lambdas without captures can be converted into a FnOnceBox, FnMutBox, or
-/// FnBox directly. If the lambda has captured, it must be given to one of:
-///
-/// - `sus_bind(sus_store(..captures..), lambda)` to bind a const lambda which
-/// captures variables from local state. Variables to be captured in the
-/// lambda must also be named in sus_store(). `sus_bind()` only allows those
-/// named variables to be captured, and ensures they are stored by value
-/// instead of by reference.
-///
-/// - `sus_bind0(lambda)` to bind a const lambda which has bound variables
-/// that don't capture state from outside the lambda, such as `[i = 2]() {
-/// return i;
-/// }`.
-///
-/// - `sus_bind_mut(sus_store(...captures...), lambda)` to bind a mutable
-/// lambda which captures variables from local state.
-///
-/// - `sus_bind0_mut(lambda)` to bind a mutable lambda which has bound
-/// variables that don't capture state from outside the lambda, such as `[i =
-/// 2]() { return ++i; }`.
-///
-/// Within sus_store(), a variable name can be wrapped with a helper to
-/// capture in different ways:
-///
-/// - `sus_take(x)` will move `x` into the closure instead of copying it.
-///
-/// - `sus_unsafe_pointer(x)` will allow capturing a pointer. Otherwise it be
-/// disallowed, and it is strongly discouraged as it requires careful present
-/// and future understanding of the pointee's lifetime.
-///
-/// # Example
-///
-/// Moves `a` into the closure's storage, and copies b. The lambda then refers
-/// to the closure's stored values by reference.
-///
-/// ```
-/// int a = 1;
-/// int b = 2;
-/// FnMutBox<void()> f = sus_bind_mut(
-///   sus_store(sus_take(a), b), [&a, &b]() mutable { a += b; }
-/// );
-/// ```
-///
-/// # Why can a "const" FnBox convert to a mutable FnMutBox or FnOnceBox?
-///
-/// A FnMutBox or FnOnceBox is _allowed_ to mutate its storage, but a "const"
-/// FnBox closure would just choose not to do so.
-///
-/// However, a `const FnBox` requires that the storage is not mutated, so it
-/// is not useful if converted to a `const FnMutBox` or `const FnOnceBox`
-/// which are only callable as mutable objects.
-///
-/// # Null pointers
-///
-/// A null function pointer is not allowed, constructing a FnMutBox from a
-/// null pointer will panic.
-template <class R, class... CallArgs>
-class [[sus_trivial_abi]] FnMutBox<R(CallArgs...)>
-    : public FnOnceBox<R(CallArgs...)> {
- public:
-  /// Construction from a function pointer or captureless lambda.
-  ///
-  /// #[doc.overloads=ctor.fnpointer]
-  template <::sus::fn::callable::FunctionPointerMatches<R, CallArgs...> F>
-  FnMutBox(F ptr) noexcept : FnOnceBox<R(CallArgs...)>(::sus::move(ptr)) {}
-
-  /// Construction from a method or data member pointer.
-  ///
-  /// #[doc.overloads=ctor.methodpointer]
-  template <::sus::fn::callable::CallableObjectReturnsMut<R, CallArgs...> F>
-    requires(std::is_member_function_pointer_v<F> ||
-             std::is_member_object_pointer_v<F>)
-  FnMutBox(F ptr) noexcept
-      : FnOnceBox<R(CallArgs...)>(__private::StorageConstructionFnMutBox, ptr) {
-  }
-
-  /// Construction from a compatible FnMutBox.
-  ///
-  /// #[doc.overloads=ctor.fnmutbox]
-  template <class U, class... UArgs>
-    requires(::sus::fn::callable::CallableObjectReturnsMut<
-             FnMutBox<U, UArgs...>, R, CallArgs...>)
-  FnMutBox(FnMutBox<U, UArgs...>&& box) noexcept
-      : FnOnceBox<R(CallArgs...)>(__private::StorageConstructionFnMutBox,
-                                  ::sus::move(box)) {}
-
-  /// Construction from a compatible FnBox.
-  ///
-  /// #[doc.overloads=ctor.fnbox]
-  template <class U, class... UArgs>
-    requires(::sus::fn::callable::CallableObjectReturnsMut<FnBox<U, UArgs...>,
-                                                           R, CallArgs...>)
-  FnMutBox(FnBox<U, UArgs...>&& box) noexcept
-      : FnOnceBox<R(CallArgs...)>(__private::StorageConstructionFnMutBox,
-                                  ::sus::move(box)) {}
-
-  /// Construction from the output of `sus_bind()`.
-  ///
-  /// #[doc.overloads=ctor.bind]
-  template <::sus::fn::callable::CallableObjectReturnsMut<R, CallArgs...> F>
-  FnMutBox(__private::SusBind<F>&& holder) noexcept
-      : FnOnceBox<R(CallArgs...)>(__private::StorageConstructionFnMutBox,
-                                  ::sus::move(holder.lambda)) {}
-
-  ~FnMutBox() noexcept = default;
-
-  FnMutBox(FnMutBox&&) noexcept = default;
-  FnMutBox& operator=(FnMutBox&&) noexcept = default;
-
-  FnMutBox(const FnMutBox&) noexcept = delete;
-  FnMutBox& operator=(const FnMutBox&) noexcept = delete;
-
-  /// Runs the closure.
-  inline R operator()(CallArgs... args) & noexcept;
-  inline R operator()(CallArgs... args) && noexcept {
-    return static_cast<FnOnceBox<R(CallArgs...)>&&>(*this)(
-        forward<CallArgs>(args)...);
-  }
-
-  /// `sus::construct::From` trait implementation for function pointers or
-  /// lambdas without captures.
-  ///
-  /// #[doc.overloads=from.fnpointer]
-  template <::sus::fn::callable::FunctionPointerMatches<R, CallArgs...> F>
-  constexpr static auto from(F fn) noexcept {
-    return FnMutBox(fn);
-  }
-
-  /// `sus::construct::From` trait implementation for method or data member
-  /// pointers.
-  ///
-  /// #[doc.overloads=from.method]
-  template <::sus::fn::callable::CallableObjectReturnsMut<R, CallArgs...> F>
-    requires(std::is_member_function_pointer_v<F> ||
-             std::is_member_object_pointer_v<F>)
-  constexpr static auto from(F fn) noexcept {
-    return FnMutBox(fn);
-  }
-
-  /// `sus::construct::From` compatible FnMutBox.
-  ///
-  /// #[doc.overloads=from.fnmutbox]
-  template <class U, class... UArgs>
-    requires(::sus::fn::callable::CallableObjectReturnsMut<
-             FnMutBox<U, UArgs...>, R, CallArgs...>)
-  constexpr static auto from(FnMutBox<U, UArgs...>&& box) noexcept {
-    return FnMutBox(::sus::move(box));
-  }
-
-  /// `sus::construct::From` compatible FnBox.
-  ///
-  /// #[doc.overloads=from.fnbox]
-  template <class U, class... UArgs>
-    requires(::sus::fn::callable::CallableObjectReturnsMut<FnBox<U, UArgs...>,
-                                                           R, CallArgs...>)
-  constexpr static auto from(FnBox<U, UArgs...>&& box) noexcept {
-    return FnMutBox(::sus::move(box));
-  }
-
-  /// `sus::construct::From` trait implementation for the output of
-  /// `sus_bind()`.
-  ///
-  /// #[doc.overloads=from.callableobject]
-  template <::sus::fn::callable::CallableObjectReturnsMut<R, CallArgs...> F>
-  constexpr static auto from(__private::SusBind<F>&& holder) noexcept {
-    return FnMutBox(::sus::move(holder));
-  }
-
- protected:
-  // This class may only have trivially-destructible storage and must not
-  // do anything in its destructor, as `FnOnceBox` moves from itself, and it
-  // would slice that off.
-
-  template <class ConstructionType,
-            ::sus::fn::callable::CallableObjectReturnsMut<R, CallArgs...> F>
-  FnMutBox(ConstructionType c, F&& lambda) noexcept
-      : FnOnceBox<R(CallArgs...)>(c, ::sus::move(lambda)) {}
-
- private:
-  sus_class_trivially_relocatable_unchecked(::sus::marker::unsafe_fn);
-  // Copied from FnOnceBox base class.
-  sus_class_never_value_field(::sus::marker::unsafe_fn, FnMutBox,
-                              FnOnceBox<R(CallArgs...)>::type_,
-                              static_cast<__private::FnBoxType>(0),
-                              __private::FnBoxType::FnBoxPointer);
-
- protected:
-  explicit FnMutBox(::sus::mem::NeverValueConstructor c) noexcept
-      : FnOnceBox<R(CallArgs...)>(c) {}
-};
-
-/// A closure that erases the type of the internal callable object (lambda). A
-/// FnBox may be called a multiple times, and will not mutate its storage.
-///
-/// FnBox can be used as a FnMutBox, which can be used as a FnOnceBox.
-///
-/// Lambdas without captures can be converted into a FnOnceBox, FnMutBox, or
-/// FnBox directly. If the lambda has captured, it must be given to one of:
-///
-/// - `sus_bind(sus_store(..captures..), lambda)` to bind a const lambda which
-/// captures variables from local state. Variables to be captured in the
-/// lambda must also be named in sus_store(). `sus_bind()` only allows those
-/// named variables to be captured, and ensures they are stored by value
-/// instead of by reference.
-///
-/// - `sus_bind0(lambda)` to bind a const lambda which has bound variables
-/// that don't capture state from outside the lambda, such as `[i = 2]() {
-/// return i;
-/// }`.
-///
-/// - `sus_bind_mut(sus_store(...captures...), lambda)` to bind a mutable
-/// lambda which captures variables from local state.
-///
-/// - `sus_bind0_mut(lambda)` to bind a mutable lambda which has bound
-/// variables that don't capture state from outside the lambda, such as `[i =
-/// 2]() { return ++i; }`.
-///
-/// Within sus_store(), a variable name can be wrapped with a helper to
-/// capture in different ways:
-///
-/// - `sus_take(x)` will move `x` into the closure instead of copying it.
-///
-/// - `sus_unsafe_pointer(x)` will allow capturing a pointer. Otherwise it be
-/// disallowed, and it is strongly discouraged as it requires careful present
-/// and future understanding of the pointee's lifetime.
-///
-/// # Example
-///
-/// Moves `a` into the closure's storage, and copies b. The lambda then refers
-/// to the closure's stored values by reference.
-///
-/// ```
-/// int a = 1;
-/// int b = 2;
-/// FnBox<int()> f = sus_bind(
-///   sus_store(sus_take(a), b), [&a, &b]() { return a + b; }
-/// );
-/// ```
-///
-/// # Why can a "const" FnBox convert to a mutable FnMutBox or FnOnceBox?
-///
-/// A FnMutBox or FnOnceBox is _allowed_ to mutate its storage, but a "const"
-/// FnBox closure would just choose not to do so.
-///
-/// However, a `const FnBox` requires that the storage is not mutated, so it
-/// is not useful if converted to a `const FnMutBox` or `const FnOnceBox`
-/// which are only callable as mutable objects.
-///
-/// # Null pointers
-///
-/// A null function pointer is not allowed, constructing a FnBox from a null
-/// pointer will panic.
-template <class R, class... CallArgs>
-class [[sus_trivial_abi]] FnBox<R(CallArgs...)> final
-    : public FnMutBox<R(CallArgs...)> {
- public:
-  /// Construction from a function pointer or captureless lambda.
-  ///
-  /// #[doc.overloads=ctor.fnpointer]
-  template <::sus::fn::callable::FunctionPointerMatches<R, CallArgs...> F>
-  FnBox(F ptr) noexcept : FnMutBox<R(CallArgs...)>(ptr) {}
-
-  /// Construction from a method or data member pointer.
-  ///
-  /// #[doc.overloads=ctor.methodpointer]
-  template <::sus::fn::callable::CallableObjectReturnsConst<R, CallArgs...> F>
-    requires(std::is_member_function_pointer_v<F> ||
-             std::is_member_object_pointer_v<F>)
-  FnBox(F ptr) noexcept
-      : FnMutBox<R(CallArgs...)>(__private::StorageConstructionFnBox, ptr) {}
-
-  /// Construction from a compatible FnBox.
-  ///
-  /// #[doc.overloads=ctor.fnbox]
-  template <class U, class... UArgs>
-    requires(::sus::fn::callable::CallableObjectReturnsConst<FnBox<U, UArgs...>,
-                                                             R, CallArgs...>)
-  FnBox(FnBox<U, UArgs...>&& box) noexcept
-      : FnMutBox<R(CallArgs...)>(__private::StorageConstructionFnBox,
-                                 ::sus::move(box)) {}
-
-  /// Construction from the output of `sus_bind()`.
-  ///
-  /// #[doc.overloads=ctor.bind]
-  template <::sus::fn::callable::CallableObjectReturnsConst<R, CallArgs...> F>
-  FnBox(__private::SusBind<F>&& holder) noexcept
-      : FnMutBox<R(CallArgs...)>(__private::StorageConstructionFnBox,
-                                 ::sus::move(holder.lambda)) {}
-
-  ~FnBox() noexcept = default;
-
-  FnBox(FnBox&&) noexcept = default;
-  FnBox& operator=(FnBox&&) noexcept = default;
-
-  FnBox(const FnBox&) noexcept = delete;
-  FnBox& operator=(const FnBox&) noexcept = delete;
-
-  /// Runs the closure.
-  inline R operator()(CallArgs... args) const& noexcept;
-  inline R operator()(CallArgs... args) && noexcept {
-    return static_cast<FnOnceBox<R(CallArgs...)>&&>(*this)(
-        forward<CallArgs>(args)...);
-  }
-
-  /// `sus::construct::From` trait implementation for function pointers or
-  /// lambdas without captures.
-  ///
-  /// #[doc.overloads=from.fnpointer]
-  template <::sus::fn::callable::FunctionPointerMatches<R, CallArgs...> F>
-  constexpr static auto from(F fn) noexcept {
-    return FnBox(fn);
-  }
-
-  /// `sus::construct::From` trait implementation for method or data member
-  /// pointers.
-  ///
-  /// #[doc.overloads=from.method]
-  template <::sus::fn::callable::CallableObjectReturnsConst<R, CallArgs...> F>
-    requires(std::is_member_function_pointer_v<F> ||
-             std::is_member_object_pointer_v<F>)
-  constexpr static auto from(F fn) noexcept {
-    return FnBox(fn);
-  }
-
-  /// `sus::construct::From` compatible FnBox.
-  ///
-  /// #[doc.overloads=from.fnbox]
-  template <class U, class... UArgs>
-    requires(::sus::fn::callable::CallableObjectReturnsConst<FnBox<U, UArgs...>,
-                                                             R, CallArgs...>)
-  constexpr static auto from(FnBox<U, UArgs...>&& box) noexcept {
-    return FnMutBox(::sus::move(box));
-  }
-
-  /// `sus::construct::From` trait implementation for the output of
-  /// `sus_bind()`.
-  /// #[doc.overloads=1]
-  template <::sus::fn::callable::CallableObjectReturnsConst<R, CallArgs...> F>
-  constexpr static auto from(__private::SusBind<F>&& holder) noexcept {
-    return FnBox(::sus::move(holder));
-  }
-
- private:
-  // This class may only have trivially-destructible storage and must not
-  // do anything in its destructor, as `FnOnceBox` moves from itself, and it
-  // would slice that off.
-
-  template <::sus::fn::callable::CallableObjectReturnsConst<R, CallArgs...> F>
-  FnBox(__private::StorageConstructionFnBoxType, F&& fn) noexcept;
-
-  sus_class_trivially_relocatable_unchecked(::sus::marker::unsafe_fn);
-  // Copied from FnOnceBox base class.
-  sus_class_never_value_field(::sus::marker::unsafe_fn, FnBox,
-                              FnOnceBox<R(CallArgs...)>::type_,
-                              static_cast<__private::FnBoxType>(0),
-                              __private::FnBoxType::FnBoxPointer);
-  explicit FnBox(::sus::mem::NeverValueConstructor c) noexcept
-      : FnMutBox<R(CallArgs...)>(c) {}
-};
-
-}  // namespace sus::fn
diff --git a/sus/fn/fn_box_impl.h b/sus/fn/fn_box_impl.h
deleted file mode 100644
index 72453d650..000000000
--- a/sus/fn/fn_box_impl.h
+++ /dev/null
@@ -1,225 +0,0 @@
-// Copyright 2022 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// IWYU pragma: private, include "sus/fn/fn.h"
-// IWYU pragma: friend "sus/.*"
-#pragma once
-
-#include "sus/assertions/check.h"
-#include "sus/assertions/unreachable.h"
-#include "sus/fn/__private/fn_box_storage.h"
-#include "sus/fn/fn_box_defn.h"
-#include "sus/macros/__private/compiler_bugs.h"
-#include "sus/mem/replace.h"
-
-namespace sus::fn {
-
-template <class R, class... CallArgs>
-template <::sus::fn::callable::FunctionPointerMatches<R, CallArgs...> F>
-FnOnceBox<R(CallArgs...)>::FnOnceBox(F ptr) noexcept
-    : fn_ptr_(ptr), type_(__private::FnBoxPointer) {
-  ::sus::check(ptr != nullptr);
-}
-
-template <class R, class... CallArgs>
-template <class ConstructionType,
-          ::sus::fn::callable::CallableObjectReturnsOnce<R, CallArgs...> F>
-  requires(!(std::is_member_function_pointer_v<std::remove_reference_t<F>> ||
-             std::is_member_object_pointer_v<std::remove_reference_t<F>>))
-FnOnceBox<R(CallArgs...)>::FnOnceBox(ConstructionType construction,
-                                     F&& lambda) noexcept
-    : type_(__private::Storage) {
-  // TODO: Allow overriding the global allocator? Use the allocator in place of
-  // `new` and `delete` directly?
-  auto* s = new __private::FnBoxStorage<F>(::sus::move(lambda));
-  make_vtable(*s, construction);
-  storage_ = s;
-}
-
-template <class R, class... CallArgs>
-template <class ConstructionType,
-          ::sus::fn::callable::CallableObjectReturnsOnce<R, CallArgs...> F>
-  requires(std::is_member_function_pointer_v<F> ||
-           std::is_member_object_pointer_v<F>)
-FnOnceBox<R(CallArgs...)>::FnOnceBox(ConstructionType construction,
-                                     F ptr) noexcept
-    : type_(__private::Storage) {
-  ::sus::check(ptr != nullptr);
-  // TODO: Allow overriding the global allocator? Use the allocator in place of
-  // `new` and `delete` directly?
-  auto* s = new __private::FnBoxStorage<F>(ptr);
-  make_vtable(*s, construction);
-  storage_ = s;
-}
-
-template <class R, class... CallArgs>
-template <class FnBoxStorage>
-void FnOnceBox<R(CallArgs...)>::make_vtable(
-    FnBoxStorage& storage,
-    __private::StorageConstructionFnOnceBoxType) noexcept {
-  static __private::FnBoxStorageVtable<R, CallArgs...> vtable = {
-      .call_once = &FnBoxStorage::template call_once<R, CallArgs...>,
-      .call_mut = nullptr,
-      .call = nullptr,
-  };
-  storage.vtable.insert(vtable);
-}
-
-template <class R, class... CallArgs>
-template <class FnBoxStorage>
-void FnOnceBox<R(CallArgs...)>::make_vtable(
-    FnBoxStorage& storage,
-    __private::StorageConstructionFnMutBoxType) noexcept {
-  static __private::FnBoxStorageVtable<R, CallArgs...> vtable = {
-      .call_once = &FnBoxStorage::template call_once<R, CallArgs...>,
-      .call_mut = &FnBoxStorage::template call_mut<R, CallArgs...>,
-      .call = nullptr,
-  };
-  storage.vtable.insert(vtable);
-}
-
-template <class R, class... CallArgs>
-template <class FnBoxStorage>
-void FnOnceBox<R(CallArgs...)>::make_vtable(
-    FnBoxStorage& storage, __private::StorageConstructionFnBoxType) noexcept {
-  static __private::FnBoxStorageVtable<R, CallArgs...> vtable = {
-      .call_once = &FnBoxStorage::template call_once<R, CallArgs...>,
-      .call_mut = &FnBoxStorage::template call_mut<R, CallArgs...>,
-      .call = &FnBoxStorage::template call<R, CallArgs...>,
-  };
-  storage.vtable.insert(vtable);
-}
-
-template <class R, class... CallArgs>
-FnOnceBox<R(CallArgs...)>::~FnOnceBox() noexcept {
-  switch (type_) {
-    case __private::FnBoxPointer: break;
-    case __private::Storage: {
-      if (auto* s = ::sus::mem::replace(storage_, nullptr); s) delete s;
-      break;
-    }
-  }
-  // The NeverValue in `type_` means we get here and do nothing.
-}
-
-template <class R, class... CallArgs>
-FnOnceBox<R(CallArgs...)>::FnOnceBox(FnOnceBox&& o) noexcept : type_(o.type_) {
-  switch (type_) {
-    case __private::FnBoxPointer:
-      ::sus::check(o.fn_ptr_);  // Catch use-after-move.
-      fn_ptr_ = ::sus::mem::replace(o.fn_ptr_, nullptr);
-      break;
-    case __private::Storage:
-      ::sus::check(o.storage_);  // Catch use-after-move.
-      storage_ = ::sus::mem::replace(o.storage_, nullptr);
-      break;
-  }
-}
-
-template <class R, class... CallArgs>
-FnOnceBox<R(CallArgs...)>& FnOnceBox<R(CallArgs...)>::operator=(
-    FnOnceBox&& o) noexcept {
-  switch (type_) {
-    case __private::FnBoxPointer: break;
-    case __private::Storage:
-      if (auto* s = ::sus::mem::replace(storage_, nullptr); s) delete s;
-  }
-  switch (type_ = o.type_) {
-    case __private::FnBoxPointer:
-      ::sus::check(o.fn_ptr_);  // Catch use-after-move.
-      fn_ptr_ = ::sus::mem::replace(o.fn_ptr_, nullptr);
-      break;
-    case __private::Storage:
-      ::sus::check(o.storage_);  // Catch use-after-move.
-      storage_ = ::sus::mem::replace(o.storage_, nullptr);
-      break;
-  }
-  return *this;
-}
-
-template <class R, class... CallArgs>
-R FnOnceBox<R(CallArgs...)>::operator()(CallArgs... args) && noexcept {
-  switch (type_) {
-    case __private::FnBoxPointer: {
-      ::sus::check(fn_ptr_);  // Catch use-after-move.
-      auto* fn = ::sus::mem::replace(fn_ptr_, nullptr);
-      return std::invoke(fn, static_cast<CallArgs&&>(args)...);
-    }
-    case __private::Storage: {
-      ::sus::check(storage_);  // Catch use-after-move.
-      auto* storage = ::sus::mem::replace(storage_, nullptr);
-      auto& vtable =
-          static_cast<const __private::FnBoxStorageVtable<R, CallArgs...>&>(
-              storage->vtable.as_mut().unwrap());
-
-      // Delete storage, after the call_once() is complete.
-      //
-      // TODO: `storage` and `storage_` should be owning smart pointers.
-      struct DeleteStorage final {
-        sus_clang_bug_54040(
-            constexpr inline DeleteStorage(__private::FnBoxStorageBase* storage)
-            : storage(storage){});
-        ~DeleteStorage() { delete storage; }
-        __private::FnBoxStorageBase* storage;
-      } deleter(storage);
-
-      return vtable.call_once(
-          static_cast<__private::FnBoxStorageBase&&>(*storage),
-          forward<CallArgs>(args)...);
-    }
-  }
-  ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
-}
-
-template <class R, class... CallArgs>
-R FnMutBox<R(CallArgs...)>::operator()(CallArgs... args) & noexcept {
-  using Super = FnOnceBox<R(CallArgs...)>;
-  switch (Super::type_) {
-    case __private::FnBoxPointer:
-      ::sus::check(Super::fn_ptr_);  // Catch use-after-move.
-      return Super::fn_ptr_(static_cast<CallArgs&&>(args)...);
-    case __private::Storage: {
-      ::sus::check(Super::storage_);  // Catch use-after-move.
-      auto& vtable =
-          static_cast<const __private::FnBoxStorageVtable<R, CallArgs...>&>(
-              Super::storage_->vtable.as_mut().unwrap());
-      return vtable.call_mut(
-          static_cast<__private::FnBoxStorageBase&>(*Super::storage_),
-          ::sus::forward<CallArgs>(args)...);
-    }
-  }
-  ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
-}
-
-template <class R, class... CallArgs>
-R FnBox<R(CallArgs...)>::operator()(CallArgs... args) const& noexcept {
-  using Super = FnOnceBox<R(CallArgs...)>;
-  switch (Super::type_) {
-    case __private::FnBoxPointer:
-      ::sus::check(Super::fn_ptr_);  // Catch use-after-move.
-      return Super::fn_ptr_(static_cast<CallArgs&&>(args)...);
-    case __private::Storage: {
-      ::sus::check(Super::storage_);  // Catch use-after-move.
-      auto& vtable =
-          static_cast<const __private::FnBoxStorageVtable<R, CallArgs...>&>(
-              Super::storage_->vtable.as_mut().unwrap());
-      return vtable.call(
-          static_cast<const __private::FnBoxStorageBase&>(*Super::storage_),
-          ::sus::forward<CallArgs>(args)...);
-    }
-  }
-  ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
-}
-
-}  // namespace sus::fn
diff --git a/sus/fn/fn_box_unittest.cc b/sus/fn/fn_box_unittest.cc
deleted file mode 100644
index a07f75c94..000000000
--- a/sus/fn/fn_box_unittest.cc
+++ /dev/null
@@ -1,709 +0,0 @@
-// Copyright 2022 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <concepts>
-
-#include "googletest/include/gtest/gtest.h"
-#include "sus/construct/into.h"
-#include "sus/fn/fn.h"
-#include "sus/iter/iterator.h"
-#include "sus/mem/forward.h"
-#include "sus/mem/move.h"
-#include "sus/mem/replace.h"
-#include "sus/option/option.h"
-#include "sus/prelude.h"
-
-namespace {
-
-using sus::construct::Into;
-using sus::fn::FnBox;
-using sus::fn::FnMutBox;
-using sus::fn::FnOnceBox;
-
-struct Copyable {
-  Copyable(int i) : i(i) {}
-  Copyable(const Copyable& c) = default;
-  Copyable& operator=(const Copyable& c) = default;
-  ~Copyable() { i = -10000000; }
-
-  int i = 0;
-};
-
-struct MoveOnly {
-  MoveOnly(int i) : i(i) {}
-  MoveOnly(const MoveOnly& c) = delete;
-  MoveOnly& operator=(const MoveOnly& c) = delete;
-  MoveOnly(MoveOnly&& c) : i(::sus::mem::replace(c.i, -1)) {}
-  MoveOnly& operator=(MoveOnly&& c) {
-    i = ::sus::mem::replace(c.i, -1);
-    return *this;
-  }
-  ~MoveOnly() { i = -10000000; }
-
-  int i = 0;
-};
-
-// clang-format-off
-
-struct BaseClass {};
-struct SubClass : public BaseClass {};
-
-static_assert(sizeof(FnOnceBox<void()>) > sizeof(void (*)()));
-static_assert(sizeof(FnOnceBox<void()>) <= sizeof(void (*)()) * 2);
-
-void v_v_function() {}
-int i_f_function(float) { return 0; }
-void v_f_function(float) {}
-BaseClass* b_b_function(BaseClass* b) { return b; }
-SubClass* s_b_function(BaseClass* b) { return static_cast<SubClass*>(b); }
-SubClass* s_s_function(SubClass* b) { return b; }
-
-// These emulate binding with sus_bind(), but don't use it cuz capturing lambdas
-// in a constant expression won't work.
-auto b_b_lambda = sus::fn::__private::SusBind(
-    [a = 1](BaseClass* b) -> BaseClass* { return b; });
-auto s_b_lambda = sus::fn::__private::SusBind(
-    [a = 1](BaseClass* b) -> SubClass* { return static_cast<SubClass*>(b); });
-auto s_s_lambda = sus::fn::__private::SusBind(
-    [a = 1](SubClass* b) -> SubClass* { return b; });
-
-// FnBox types all have a never-value field.
-static_assert(sus::mem::NeverValueField<FnOnceBox<void()>>);
-static_assert(sus::mem::NeverValueField<FnMutBox<void()>>);
-static_assert(sus::mem::NeverValueField<FnBox<void()>>);
-// Which allows them to not require a flag in Option.
-static_assert(sizeof(sus::Option<FnOnceBox<void()>>) ==
-              sizeof(FnOnceBox<void()>));
-
-// Closures can not be copied, as their storage is uniquely owned.
-static_assert(!std::is_copy_constructible_v<FnOnceBox<void()>>);
-static_assert(!std::is_copy_assignable_v<FnOnceBox<void()>>);
-static_assert(!std::is_copy_constructible_v<FnMutBox<void()>>);
-static_assert(!std::is_copy_assignable_v<FnMutBox<void()>>);
-static_assert(!std::is_copy_constructible_v<FnBox<void()>>);
-static_assert(!std::is_copy_assignable_v<FnBox<void()>>);
-// Closures can be moved.
-static_assert(std::is_move_constructible_v<FnOnceBox<void()>>);
-static_assert(std::is_move_assignable_v<FnOnceBox<void()>>);
-static_assert(std::is_move_constructible_v<FnMutBox<void()>>);
-static_assert(std::is_move_assignable_v<FnMutBox<void()>>);
-static_assert(std::is_move_constructible_v<FnBox<void()>>);
-static_assert(std::is_move_assignable_v<FnBox<void()>>);
-
-// Closures are trivially relocatable.
-static_assert(sus::mem::relocate_by_memcpy<FnOnceBox<void()>>);
-static_assert(sus::mem::relocate_by_memcpy<FnMutBox<void()>>);
-static_assert(sus::mem::relocate_by_memcpy<FnBox<void()>>);
-
-// A function pointer, or convertible lambda, can be bound to FnOnceBox,
-// FnMutBox and FnBox.
-static_assert(std::is_constructible_v<FnOnceBox<void()>, decltype([]() {})>);
-static_assert(std::is_constructible_v<FnMutBox<void()>, decltype([]() {})>);
-static_assert(std::is_constructible_v<FnBox<void()>, decltype([]() {})>);
-static_assert(
-    std::is_constructible_v<FnOnceBox<void()>, decltype(v_v_function)>);
-static_assert(
-    std::is_constructible_v<FnMutBox<void()>, decltype(v_v_function)>);
-static_assert(std::is_constructible_v<FnBox<void()>, decltype(v_v_function)>);
-// Non-void types for the same.
-static_assert(std::is_constructible_v<FnOnceBox<int(float)>,
-                                      decltype([](float) { return 1; })>);
-static_assert(std::is_constructible_v<FnMutBox<int(float)>,
-                                      decltype([](float) { return 1; })>);
-static_assert(std::is_constructible_v<FnBox<int(float)>,
-                                      decltype([](float) { return 1; })>);
-static_assert(
-    std::is_constructible_v<FnOnceBox<int(float)>, decltype(i_f_function)>);
-static_assert(
-    std::is_constructible_v<FnMutBox<int(float)>, decltype(i_f_function)>);
-static_assert(
-    std::is_constructible_v<FnBox<int(float)>, decltype(i_f_function)>);
-
-// Lambdas with bound args can't be passed without sus_bind().
-static_assert(!std::is_constructible_v<FnOnceBox<void()>,
-                                       decltype([i = int(1)]() { (void)i; })>);
-static_assert(!std::is_constructible_v<
-              FnOnceBox<void()>, decltype([i = int(1)]() mutable { ++i; })>);
-
-// The return type of the FnBox must match that of the lambda. It will not allow
-// converting to void.
-static_assert(std::is_constructible_v<FnBox<SubClass*(BaseClass*)>,
-                                      decltype(s_b_function)>);
-static_assert(
-    !std::is_constructible_v<FnBox<void(BaseClass*)>, decltype(b_b_function)>);
-static_assert(!std::is_constructible_v<FnBox<SubClass*(BaseClass*)>,
-                                       decltype(b_b_function)>);
-static_assert(std::is_constructible_v<FnBox<SubClass*(BaseClass*)>,
-                                      decltype(s_b_lambda)>);
-static_assert(
-    !std::is_constructible_v<FnBox<void(BaseClass*)>, decltype(b_b_lambda)>);
-static_assert(!std::is_constructible_v<FnBox<SubClass*(BaseClass*)>,
-                                       decltype(b_b_lambda)>);
-// Similarly, argument types can't be converted to a different type.
-static_assert(std::is_constructible_v<FnBox<SubClass*(SubClass*)>,
-                                      decltype(s_s_function)>);
-static_assert(!std::is_constructible_v<FnBox<SubClass*(BaseClass*)>,
-                                       decltype(s_s_function)>);
-static_assert(
-    std::is_constructible_v<FnBox<SubClass*(SubClass*)>, decltype(s_s_lambda)>);
-static_assert(!std::is_constructible_v<FnBox<SubClass*(BaseClass*)>,
-                                       decltype(s_s_lambda)>);
-// But FnBox type is compatible with convertible return and argument types in
-// opposite directions.
-// - If the return type Y of a lambda is convertible _to_ X, then FnBox<X()> can
-// be
-//   used to store it.
-// - If the argument type Y of a lambda is convertible _from_ X, then FnBox<(X)>
-//   can be used to store it.
-//
-// In both cases, the FnBox is more strict than the lambda, guaranteeing that
-// the lambda's requirements are met.
-static_assert(std::is_constructible_v<FnBox<BaseClass*(BaseClass*)>,
-                                      decltype(s_b_lambda)>);
-static_assert(
-    std::is_constructible_v<FnBox<SubClass*(SubClass*)>, decltype(s_b_lambda)>);
-// HOWEVER: When FnBox is passed a function pointer, it stores a function
-// pointer. C++20 does not yet allow us to erase the type of that function
-// pointer in a constexpr context. So the types in the pointer must match
-// exactly to the FnBox's signature.
-static_assert(!std::is_constructible_v<FnBox<BaseClass*(BaseClass*)>,
-                                       decltype(s_b_function)>);
-static_assert(!std::is_constructible_v<FnBox<SubClass*(SubClass*)>,
-                                       decltype(s_b_function)>);
-
-// Lambdas with bound args can be passed with sus_bind(). Can use sus_bind0()
-// when there's no captured variables.
-static_assert(std::is_constructible_v<FnOnceBox<void()>, decltype([]() {
-                                        return sus_bind0([i = int(1)]() {});
-                                      }())>);
-// And use sus_bind0_mut for a mutable lambda.
-static_assert(std::is_constructible_v<FnOnceBox<void()>, decltype([]() {
-                                        return sus_bind0_mut(
-                                            [i = int(1)]() mutable { ++i; });
-                                      }())>);
-
-// FnBox that are compatible can be converted to.
-static_assert(std::is_constructible_v<FnBox<BaseClass*(SubClass*)>,
-                                      FnBox<SubClass*(BaseClass*)>>);
-static_assert(!std::is_constructible_v<FnBox<SubClass*(BaseClass*)>,
-                                       FnBox<BaseClass*(SubClass*)>>);
-static_assert(std::is_constructible_v<FnMutBox<BaseClass*(SubClass*)>,
-                                      FnMutBox<SubClass*(BaseClass*)>>);
-static_assert(!std::is_constructible_v<FnMutBox<SubClass*(BaseClass*)>,
-                                       FnMutBox<BaseClass*(SubClass*)>>);
-static_assert(std::is_constructible_v<FnOnceBox<BaseClass*(SubClass*)>,
-                                      FnOnceBox<SubClass*(BaseClass*)>>);
-static_assert(!std::is_constructible_v<FnOnceBox<SubClass*(BaseClass*)>,
-                                       FnOnceBox<BaseClass*(SubClass*)>>);
-
-static_assert(std::is_constructible_v<FnOnceBox<BaseClass*(SubClass*)>,
-                                      FnMutBox<SubClass*(BaseClass*)>>);
-static_assert(std::is_constructible_v<FnOnceBox<BaseClass*(SubClass*)>,
-                                      FnBox<SubClass*(BaseClass*)>>);
-static_assert(std::is_constructible_v<FnMutBox<BaseClass*(SubClass*)>,
-                                      FnBox<SubClass*(BaseClass*)>>);
-
-// This incorrectly uses sus_bind0 with a mutable lambda, which produces a
-// warning while also being non-constructible. But we build with errors enabled
-// so it fails to compile instead of just failing the assert.
-//
-// TODO: It doesn't seem possible to disable this error selectively here, as the
-// actual call happens in a template elsewhere. So that prevents us from
-// checking the non-constructibility if the warning isn't compiled as an error.
-//
-// It would be nice to be able to produce a nice warning while also failing
-// overload resolution nicely. But with -Werror the warning becomes an error,
-// and we can't explain why overload resolution is failing with extra
-// information in that error message.
-//
-// #pragma GCC diagnostic push
-// #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-// static_assert(!std::is_constructible_v<
-//     FnOnceBox<void()>,
-//     decltype([]() {
-//       return sus_bind0([i = int(1)]() mutable {++i;});
-//     }())
-// >);
-// #pragma GCC diagnostic pop
-
-template <class R, class Param, class Arg>
-concept can_run = requires(Arg arg, FnOnceBox<R(Param)> fnonce,
-                           FnMutBox<R(Param)> fnmut, FnBox<R(Param)> fn) {
-  { static_cast<FnOnceBox<R(Param)>&&>(fnonce)(sus::forward<Arg>(arg)) };
-  { static_cast<FnOnceBox<R(Param)>&&>(fnmut)(sus::forward<Arg>(arg)) };
-  { static_cast<FnOnceBox<R(Param)>&&>(fn)(sus::forward<Arg>(arg)) };
-};
-// clang-format on
-
-// Int is copyable, so references are copied when passed.
-static_assert(can_run<void, int, int>);
-static_assert(can_run<void, int, int&&>);
-static_assert(can_run<void, int, int&>);
-static_assert(can_run<void, int, const int>);
-static_assert(can_run<void, int, const int&>);
-static_assert(can_run<void, int, const int&&>);
-// But for a move-only type, it can only be passed along as a reference or an
-// rvalue.
-static_assert(can_run<void, MoveOnly, MoveOnly>);
-static_assert(can_run<void, MoveOnly, MoveOnly&&>);
-static_assert(!can_run<void, MoveOnly, MoveOnly&>);
-static_assert(!can_run<void, MoveOnly, const MoveOnly>);
-static_assert(!can_run<void, MoveOnly, const MoveOnly&>);
-static_assert(!can_run<void, MoveOnly, const MoveOnly&&>);
-static_assert(can_run<void, const MoveOnly&, MoveOnly&>);
-static_assert(can_run<void, const MoveOnly&, const MoveOnly&>);
-static_assert(can_run<void, MoveOnly&, MoveOnly&>);
-static_assert(!can_run<void, MoveOnly&, const MoveOnly&>);
-
-// Receiving a mutable reference means it must be passed as a mutable reference.
-static_assert(can_run<void, int&, int&>);
-static_assert(!can_run<void, int&, const int&>);
-static_assert(!can_run<void, int&, int>);
-
-// Receiving a const reference means it must be passed as a reference.
-static_assert(can_run<void, const int&, int&>);
-static_assert(can_run<void, const int&, const int&>);
-static_assert(!can_run<void, int&, int>);
-static_assert(!can_run<void, int&, const int>);
-static_assert(!can_run<void, int&, int&&>);
-static_assert(!can_run<void, int&, const int&&>);
-
-TEST(FnBox, Pointer) {
-  {
-    auto fn = FnOnceBox<int(int, int)>([](int a, int b) { return a * 2 + b; });
-    EXPECT_EQ(sus::move(fn)(1, 2), 4);
-  }
-  {
-    auto fn = FnMutBox<int(int, int)>([](int a, int b) { return a * 2 + b; });
-    EXPECT_EQ(fn(1, 2), 4);
-  }
-  {
-    auto fn = FnBox<int(int, int)>([](int a, int b) { return a * 2 + b; });
-    EXPECT_EQ(sus::move(fn)(1, 2), 4);
-  }
-}
-
-TEST(FnBox, InlineCapture) {
-  {
-    auto fn =
-        FnOnceBox<int(int)>(sus_bind0([a = 1](int b) { return a * 2 + b; }));
-    EXPECT_EQ(sus::move(fn)(2), 4);
-  }
-  {
-    auto fn =
-        FnMutBox<int(int)>(sus_bind0([a = 1](int b) { return a * 2 + b; }));
-    EXPECT_EQ(sus::move(fn)(2), 4);
-  }
-  {
-    auto fn = FnBox<int(int)>(sus_bind0([a = 1](int b) { return a * 2 + b; }));
-    EXPECT_EQ(sus::move(fn)(2), 4);
-  }
-}
-
-TEST(FnBox, OutsideCapture) {
-  int a = 1;
-  {
-    auto fn = FnOnceBox<int(int)>(
-        sus_bind(sus_store(a), [a](int b) { return a * 2 + b; }));
-    EXPECT_EQ(sus::move(fn)(2), 4);
-  }
-  {
-    auto fn = FnMutBox<int(int)>(
-        sus_bind(sus_store(a), [a](int b) { return a * 2 + b; }));
-    EXPECT_EQ(sus::move(fn)(2), 4);
-  }
-  {
-    auto fn = FnBox<int(int)>(
-        sus_bind(sus_store(a), [a](int b) { return a * 2 + b; }));
-    EXPECT_EQ(sus::move(fn)(2), 4);
-  }
-}
-
-TEST(FnBox, BothCapture) {
-  int a = 1;
-  {
-    auto fn = FnOnceBox<int()>(
-        sus_bind(sus_store(a), [a, b = 2]() { return a * 2 + b; }));
-    EXPECT_EQ(sus::move(fn)(), 4);
-  }
-  {
-    auto fn = FnMutBox<int()>(
-        sus_bind(sus_store(a), [a, b = 2]() { return a * 2 + b; }));
-    EXPECT_EQ(sus::move(fn)(), 4);
-  }
-  {
-    auto fn = FnBox<int()>(
-        sus_bind(sus_store(a), [a, b = 2]() { return a * 2 + b; }));
-    EXPECT_EQ(sus::move(fn)(), 4);
-  }
-}
-
-TEST(FnBox, CopyFromCapture) {
-  auto c = Copyable(1);
-  {
-    auto fn = FnOnceBox<int(int)>(
-        sus_bind(sus_store(c), [c](int b) { return c.i * 2 + b; }));
-    EXPECT_EQ(sus::move(fn)(2), 4);
-  }
-  {
-    auto fn = FnMutBox<int(int)>(
-        sus_bind(sus_store(c), [c](int b) { return c.i * 2 + b; }));
-    EXPECT_EQ(sus::move(fn)(2), 4);
-  }
-  {
-    auto fn = FnBox<int(int)>(
-        sus_bind(sus_store(c), [c](int b) { return c.i * 2 + b; }));
-    EXPECT_EQ(sus::move(fn)(2), 4);
-  }
-}
-
-TEST(FnBox, MoveFromCapture) {
-  {
-    auto m = MoveOnly(1);
-    auto fn = FnOnceBox<int(int)>(sus_bind_mut(
-        sus_store(sus_take(m)),
-        [m = static_cast<MoveOnly&&>(m)](int b) { return m.i * 2 + b; }));
-    EXPECT_EQ(sus::move(fn)(2), 4);
-  }
-  {
-    auto m = MoveOnly(1);
-    auto fn = FnMutBox<int(int)>(sus_bind_mut(
-        sus_store(sus_take(m)),
-        [m = static_cast<MoveOnly&&>(m)](int b) { return m.i * 2 + b; }));
-    EXPECT_EQ(fn(2), 4);
-    // The stored value was moved into the run lambda (so `m` holds `-1`).
-    EXPECT_EQ(m.i, -1);
-    EXPECT_EQ(fn(-2), -4);
-    EXPECT_EQ(sus::move(fn)(-2), -4);
-  }
-  // Can't hold sus_bind_mut() in FnBox.
-}
-
-TEST(FnBox, MoveIntoCapture) {
-  {
-    auto m = MoveOnly(1);
-    auto fn = FnOnceBox<int(int)>(
-        sus_bind(sus_store(sus_take(m)), [&m](int b) { return m.i * 2 + b; }));
-    EXPECT_EQ(sus::move(fn)(2), 4);
-  }
-  {
-    auto m = MoveOnly(1);
-    auto fn = FnMutBox<int(int)>(
-        sus_bind(sus_store(sus_take(m)), [&m](int b) { return m.i * 2 + b; }));
-    EXPECT_EQ(fn(2), 4);
-    EXPECT_EQ(fn(2), 4);
-  }
-  // Can modify the captured m with sus_bind_mut().
-  {
-    auto m = MoveOnly(1);
-    auto fn = FnMutBox<int(int)>(sus_bind_mut(
-        sus_store(sus_take(m)), [&m](int b) { return m.i++ * 2 + b; }));
-    EXPECT_EQ(fn(2), 4);
-    EXPECT_EQ(fn(2), 6);
-  }
-  {
-    auto m = MoveOnly(1);
-    auto fn = FnBox<int(int)>(
-        sus_bind(sus_store(sus_take(m)), [&m](int b) { return m.i * 2 + b; }));
-    EXPECT_EQ(fn(2), 4);
-    EXPECT_EQ(fn(2), 4);
-  }
-}
-
-TEST(FnBox, MoveFnBox) {
-  {
-    auto fn = FnOnceBox<int(int, int)>([](int a, int b) { return a * 2 + b; });
-    auto fn2 = sus::move(fn);
-    EXPECT_EQ(sus::move(fn2)(1, 2), 4);
-  }
-  {
-    auto fn =
-        FnOnceBox<int(int)>(sus_bind0([a = 1](int b) { return a * 2 + b; }));
-    auto fn2 = sus::move(fn);
-    EXPECT_EQ(sus::move(fn2)(2), 4);
-  }
-  {
-    auto fn = FnMutBox<int(int, int)>([](int a, int b) { return a * 2 + b; });
-    auto fn2 = sus::move(fn);
-    EXPECT_EQ(sus::move(fn2)(1, 2), 4);
-  }
-  {
-    auto fn =
-        FnMutBox<int(int)>(sus_bind0([a = 1](int b) { return a * 2 + b; }));
-    auto fn2 = sus::move(fn);
-    EXPECT_EQ(sus::move(fn2)(2), 4);
-  }
-  {
-    auto fn = FnBox<int(int, int)>([](int a, int b) { return a * 2 + b; });
-    auto fn2 = sus::move(fn);
-    EXPECT_EQ(sus::move(fn2)(1, 2), 4);
-  }
-  {
-    auto fn = FnBox<int(int)>(sus_bind0([a = 1](int b) { return a * 2 + b; }));
-    auto fn2 = sus::move(fn);
-    EXPECT_EQ(sus::move(fn2)(2), 4);
-  }
-}
-
-TEST(FnBox, FnBoxIsFnMutBox) {
-  {
-    auto fn = FnBox<int(int, int)>([](int a, int b) { return a * 2 + b; });
-    auto mut = FnMutBox<int(int, int)>(sus::move(fn));
-    EXPECT_EQ(mut(1, 2), 4);
-  }
-  {
-    auto fn = FnBox<int(int)>(sus_bind0([a = 1](int b) { return a * 2 + b; }));
-    auto mut = FnMutBox<int(int)>(sus::move(fn));
-    EXPECT_EQ(mut(2), 4);
-  }
-}
-
-TEST(FnBox, FnBoxIsFnOnceBox) {
-  {
-    auto fn = FnBox<int(int, int)>([](int a, int b) { return a * 2 + b; });
-    auto once = FnOnceBox<int(int, int)>(sus::move(fn));
-    EXPECT_EQ(sus::move(once)(1, 2), 4);
-  }
-  {
-    auto fn = FnBox<int(int)>(sus_bind0([a = 1](int b) { return a * 2 + b; }));
-    auto once = FnOnceBox<int(int)>(sus::move(fn));
-    EXPECT_EQ(sus::move(once)(2), 4);
-  }
-}
-
-TEST(FnBox, FnMutBoxIsFnOnceBox) {
-  {
-    auto fn = FnMutBox<int(int, int)>([](int a, int b) { return a * 2 + b; });
-    auto once = FnOnceBox<int(int, int)>(sus::move(fn));
-    EXPECT_EQ(sus::move(once)(1, 2), 4);
-  }
-  {
-    auto fn =
-        FnMutBox<int(int)>(sus_bind0([a = 1](int b) { return a * 2 + b; }));
-    auto once = FnOnceBox<int(int)>(sus::move(fn));
-    EXPECT_EQ(sus::move(once)(2), 4);
-  }
-}
-
-TEST(FnBox, BindUnsafePointer) {
-  int a = 1;
-  int* pa = &a;
-  int b = 2;
-  auto fn =
-      FnBox<int()>(sus_bind(sus_store(sus_unsafe_pointer(pa), b), [pa, b]() {
-        // sus_bind() will store pointers as const.
-        static_assert(std::is_const_v<std::remove_reference_t<decltype(*pa)>>);
-        return *pa * 2 + b;
-      }));
-  EXPECT_EQ(fn(), 4);
-
-  auto fnmut = FnMutBox<int()>(
-      sus_bind_mut(sus_store(sus_unsafe_pointer(pa), b), [pa, b]() {
-        // sus_bind_mut() will store pointers as mutable.
-        static_assert(!std::is_const_v<std::remove_reference_t<decltype(*pa)>>);
-        return (*pa)++ * 2 + b;
-      }));
-  EXPECT_EQ(fnmut(), 4);
-}
-
-TEST(FnBox, Into) {
-  auto into_fnonce = []<Into<FnOnceBox<int(int)>> F>(F into_f) {
-    FnOnceBox<int(int)> f = sus::move_into(into_f);
-    return sus::move(f)(1);
-  };
-  EXPECT_EQ(into_fnonce([](int i) { return i + 1; }), 2);
-  EXPECT_EQ(into_fnonce(sus_bind0([](int i) { return i + 1; })), 2);
-
-  auto into_fnmut = []<Into<FnMutBox<int(int)>> F>(F into_f) {
-    return FnMutBox<int(int)>::from(::sus::move(into_f))(1);
-  };
-  EXPECT_EQ(into_fnmut([](int i) { return i + 1; }), 2);
-  EXPECT_EQ(into_fnmut(sus_bind0([](int i) { return i + 1; })), 2);
-
-  auto into_fn = []<Into<FnBox<int(int)>> F>(F into_f) {
-    FnBox<int(int)> f = sus::move_into(into_f);
-    return sus::move(f)(1);
-  };
-  EXPECT_EQ(into_fn([](int i) { return i + 1; }), 2);
-  EXPECT_EQ(into_fn(sus_bind0([](int i) { return i + 1; })), 2);
-}
-
-TEST(FnBoxDeathTest, NullPointer) {
-  void (*f)() = nullptr;
-#if GTEST_HAS_DEATH_TEST
-  EXPECT_DEATH(FnOnceBox<void()>::from(f), "");
-#endif
-#if GTEST_HAS_DEATH_TEST
-  EXPECT_DEATH(FnMutBox<void()>::from(f), "");
-#endif
-#if GTEST_HAS_DEATH_TEST
-  EXPECT_DEATH(FnBox<void()>::from(f), "");
-#endif
-}
-
-TEST(FnBoxDeathTest, CallAfterMoveConstruct) {
-  {
-    auto x = FnOnceBox<void()>::from([]() {});
-    [[maybe_unused]] auto y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(sus::move(x)(), "");
-#endif
-  }
-  {
-    auto x = FnMutBox<void()>::from([]() {});
-    [[maybe_unused]] auto y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(x(), "");
-#endif
-  }
-  {
-    auto x = FnBox<void()>::from([]() {});
-    [[maybe_unused]] auto y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(x(), "");
-#endif
-  }
-  {
-    auto x = FnOnceBox<void()>::from(sus_bind0([]() {}));
-    [[maybe_unused]] auto y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(sus::move(x)(), "");
-#endif
-  }
-  {
-    auto x = FnMutBox<void()>::from(sus_bind0([]() {}));
-    [[maybe_unused]] auto y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(x(), "");
-#endif
-  }
-  {
-    auto x = FnBox<void()>::from(sus_bind0([]() {}));
-    [[maybe_unused]] auto y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(x(), "");
-#endif
-  }
-}
-
-TEST(FnBoxDeathTest, CallAfterMoveAssign) {
-  {
-    auto x = FnOnceBox<void()>::from([]() {});
-    auto y = FnOnceBox<void()>::from([]() {});
-    y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(sus::move(x)(), "");
-#endif
-  }
-  {
-    auto x = FnMutBox<void()>::from([]() {});
-    auto y = FnOnceBox<void()>::from([]() {});
-    y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(x(), "");
-#endif
-  }
-  {
-    auto x = FnBox<void()>::from([]() {});
-    auto y = FnOnceBox<void()>::from([]() {});
-    y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(x(), "");
-#endif
-  }
-  {
-    auto x = FnOnceBox<void()>::from(sus_bind0([]() {}));
-    auto y = FnOnceBox<void()>::from([]() {});
-    y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(sus::move(x)(), "");
-#endif
-  }
-  {
-    auto x = FnMutBox<void()>::from(sus_bind0([]() {}));
-    auto y = FnOnceBox<void()>::from([]() {});
-    y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(x(), "");
-#endif
-  }
-  {
-    auto x = FnBox<void()>::from(sus_bind0([]() {}));
-    auto y = FnOnceBox<void()>::from([]() {});
-    y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(x(), "");
-#endif
-  }
-}
-
-TEST(FnBoxDeathTest, CallAfterCall) {
-  {
-    auto x = FnOnceBox<void()>::from([]() {});
-    sus::move(x)();
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(sus::move(x)(), "");
-#endif
-  }
-  {
-    auto x = FnMutBox<void()>::from([]() {});
-    sus::move(x)();
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(sus::move(x)(), "");
-#endif
-  }
-  {
-    auto x = FnBox<void()>::from([]() {});
-    sus::move(x)();
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(sus::move(x)(), "");
-#endif
-  }
-  {
-    auto x = FnOnceBox<void()>::from(sus_bind0([]() {}));
-    sus::move(x)();
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(sus::move(x)(), "");
-#endif
-  }
-  {
-    auto x = FnMutBox<void()>::from(sus_bind0([]() {}));
-    sus::move(x)();
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(sus::move(x)(), "");
-#endif
-  }
-  {
-    auto x = FnBox<void()>::from(sus_bind0([]() {}));
-    sus::move(x)();
-#if GTEST_HAS_DEATH_TEST
-    EXPECT_DEATH(sus::move(x)(), "");
-#endif
-  }
-}
-
-struct Class {
-  Class(i32 value) : value_(value) {}
-  i32 value() const { return value_; }
-
- private:
-  i32 value_;
-};
-
-TEST(FnBox, Method) {
-  auto it = sus::Option<Class>(Class(42)).into_iter().map(&Class::value);
-  sus::check(it.next() == sus::some(42));
-}
-
-}  // namespace
diff --git a/sus/fn/fn_concepts.h b/sus/fn/fn_concepts.h
index bb1903b0e..1520aa1cd 100644
--- a/sus/fn/fn_concepts.h
+++ b/sus/fn/fn_concepts.h
@@ -53,9 +53,7 @@ struct Anything {
 /// The version of a callable object that may be called only once.
 ///
 /// A `FnOnce` is typically the best fit for any callable that will
-/// only be called at most once. However when a template (or constexpr) is not
-/// required, receiving a `FnOnceRef` instead of `FnOnce auto&&` will typically
-/// produce less code by using type erasure to avoid template instantiation.
+/// only be called at most once.
 ///
 /// A type that satisfies `FnOnce` will return a type that can be converted to
 /// `R` when called with the arguments `Args...`. `FnOnce` is satisfied by
@@ -77,11 +75,15 @@ struct Anything {
 /// an lvalue in the caller.
 ///
 /// A `FnOnce` should be called by moving it with `sus::move()` when passing it
-/// to `sus::fn::call_once()` along with any arguments. It is moved-from after
-/// calling, and it should only be called once.
-///
-/// Calling a `FnOnce` multiple times may panic or cause Undefined Behaviour.
-/// Not moving the `FnOnce` when calling it may fail to compile, panic, or cause
+/// to `sus::fn::call_once()` along with any arguments. This ensures the
+/// correct overload is called on the object and that method pointers are
+/// called correctly. It is moved-from after calling, and it should only be
+/// called once.
+///
+/// Calling a `FnOnce` multiple times may [`panic`]($sus::assertions::panic)
+/// or cause Undefined Behaviour.
+/// Not moving the `FnOnce` when calling it may fail to compile,
+/// [`panic`]($sus::assertions::panic), or cause
 /// Undefined Behaviour depending on the type that is being used to satisfy
 /// `FnOnce`.
 ///
@@ -92,15 +94,6 @@ struct Anything {
 /// well, `FnOnce` is allowed to mutate internal state, but it does not have to,
 /// which is compatible with the const nature of `Fn`.
 ///
-/// # Subspace types that satisfy `FnOnce`
-/// The `FnOnceRef` and `FnOnceBox` types in the Subspace library satisfy
-/// `FnOnce`. They must be moved from when called, and they panic if called more
-/// than once, as that implies a use-after-move.
-///
-/// Like the concepts, `FnRef` is convertible to `FnMutRef` is convertible to
-/// `FnOnceRef`. And `FnBox` is convertible to `FnMutBox` is convertible to
-/// `FnOnceBox`.
-///
 /// # Examples
 /// A function that receives a `FnOnce` matching type and calls it:
 /// ```
@@ -165,12 +158,8 @@ concept FnOnce = requires {
 /// The version of a callable object that is allowed to mutate internal state
 /// and may be called multiple times.
 ///
-/// A `FnMut` is typically the best fit for
-/// any callable that may be called one or more times. However when a template
-/// (or constexpr) is not required, receiving a `FnMutRef` instead of `FnMut
-/// auto` will typically produce less code by using type erasure to avoid
-/// template instantiation.
-///
+/// A `FnMut` is typically the best fit for any callable that may be called one
+/// or more times.
 /// Because a `FnMut` is able to mutate internal state, it may return different
 /// values each time it is called with the same inputs.
 ///
@@ -189,13 +178,13 @@ concept FnOnce = requires {
 /// ```
 ///
 /// # Use of `FnMut`
-/// `FnMut` should be received by value typically. If received as a rvalue
-/// (universal) reference, it should be constrained by
-/// [`IsMoveRef<decltype(f)>`]($sus::mem::IsMoveRef) to avoid moving out of
-/// an lvalue in the caller.
+/// `FnMut` should be received by value typically, though it can be received by
+/// reference if mutations should be visible to the caller.
 ///
 /// A `FnMut` should be called by passing it to `sus::fn::call_mut()` along with
-/// any arguments. A `FnMut` may be called any number of times, unlike `FnOnce`,
+/// any arguments. This ensures the correct overload is called on the object and
+/// that method pointers are called correctly.
+/// A `FnMut` may be called any number of times, unlike `FnOnce`,
 /// and should not be moved when called.
 ///
 /// # Compatibility
@@ -205,15 +194,6 @@ concept FnOnce = requires {
 /// well, `FnOnce` is allowed to mutate internal state, but it does not have to,
 /// which is compatible with the const nature of `Fn`.
 ///
-/// # Subspace types that satisfy `FnMut`
-/// The `FnMutRef` and `FnMutBox` types in the Subspace library satisfy `FnMut`
-/// (and thus `FnOnce` as well). They may be called any number of times and are
-/// able to mutate internal state.
-///
-/// Like the concepts, `FnRef` is convertible to `FnMutRef` is convertible to
-/// `FnOnceRef`. And `FnBox` is convertible to `FnMutBox` is convertible to
-/// `FnOnceBox`.
-///
 /// # Examples
 /// A function that receives a `FnMut` matching type and calls it:
 /// ```
@@ -281,27 +261,25 @@ concept FnMut = requires {
 /// The version of a callable object that may be called multiple times without
 /// mutating internal state.
 ///
-/// A `Fn` is useful for a callable that is received as
-/// a const reference to indicate it and may be called one or more times and
-/// does not change between call. However when a template (or constexpr) is not
-/// required, receiving a `FnRef` instead of `const Fn auto&` will typically
-/// produce less code by using type erasure to avoid template instantiation.
+/// A `Fn` is useful for a callable that is expected to be called one or more
+/// times and whose results do not change between calls. This is of course
+/// possible to violate with `mutable` or global state, but it is discouraged
+/// as it violates the `Fn` protocol expectations of the caller.
+/// [`FnMut`]($sus::fn::FnMut) should be used when the function will
+/// mutate anything and can return different values as a result.
 ///
-/// Because a `FnMut` is able to mutate internal state, it may return different
-/// values each time it is called with the same inputs.
-///
-/// A type that satisfies `FnMut` will return a type that can be converted to
-/// `R` when called with the arguments `Args...`. `FnMut` is satisfied by
-/// being callable as an lvalue (which is done by providing an operator() that
-/// is not `&&`-qualified). Mutable and const lambdas will satisfy
-/// `FnMut`.
+/// A type that satisfies `Fn` will return a type that can be converted to
+/// `R` when called with the arguments `Args...`. `Fn` is satisfied by
+/// being callable as a const lvalue (which is done by providing an operator()
+/// that is `const`- or `const&`-qualified). Const lambdas will satisfy
+/// `Fn` but mutable ones will not.
 ///
 /// The second argument of `Fn<F, S>` is a function signature with the format
 /// `ReturnType(Args...)`, where `Args...` are the arguments that will be passed
 /// to the `Fn` and `ReturnType` is what is expected to be received back. It
 /// would appear as a matching concept as:
 /// ```
-/// void function(const Fn<ReturnType(Args...)> auto& f) { ... }
+/// void function(Fn<ReturnType(Args...)> auto f) { ... }
 /// ```
 ///
 /// # Use of `Fn`
@@ -309,9 +287,10 @@ concept FnMut = requires {
 /// const reference.
 ///
 /// A `Fn` should be called by passing it to `std::fn::call()` along with any
-/// arguments. This ensures the correct overload is called on the object. A `Fn`
-/// may be called any number of times, unlike `FnOnce`, and should not be moved
-/// when called.
+/// arguments. This ensures the correct overload is called on the object and
+/// that method pointers are called correctly.
+/// 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
@@ -320,21 +299,12 @@ concept FnMut = requires {
 /// are able to mutate state when run, they are not required to and a constant
 /// `Fn` satisfies them.
 ///
-/// # Subspace types that satisfy `FnMut`
-/// The `FnRef` and `FnBox` types in the Subspace library satisfy `Fn` (and thus
-/// `FnMut` and `FnOnce` as well). They may be called any number of times and
-/// are callable as a const object.
-///
-/// Like the concepts, `FnRef` is convertible to `FnMutRef` is convertible to
-/// `FnOnceRef`. And `FnBox` is convertible to `FnMutBox` is convertible to
-/// `FnOnceBox`.
-///
 /// # Examples
 /// A function that receives a `Fn` matching type and calls it:
 /// ```
 /// // Accepts any type that can be called once with (Option<i32>) and returns
 /// // i32.
-/// static i32 do_stuff(const sus::fn::Fn<i32(sus::Option<i32>)> auto& f) {
+/// static i32 do_stuff(sus::fn::Fn<i32(sus::Option<i32>)> auto f) {
 ///   return sus::fn::call(f, sus::some(400)) +
 ///          sus::fn::call(f, sus::some(100));
 /// }
diff --git a/sus/fn/fn_ref.h b/sus/fn/fn_ref.h
deleted file mode 100644
index ee4f220d6..000000000
--- a/sus/fn/fn_ref.h
+++ /dev/null
@@ -1,511 +0,0 @@
-// Copyright 2022 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// IWYU pragma: private, include "sus/fn/fn.h"
-// IWYU pragma: friend "sus/.*"
-#pragma once
-
-#include "sus/assertions/unreachable.h"
-#include "sus/fn/__private/callable_types.h"
-#include "sus/fn/__private/fn_ref_invoker.h"
-#include "sus/lib/__private/forward_decl.h"
-#include "sus/macros/lifetimebound.h"
-#include "sus/mem/addressof.h"
-#include "sus/mem/forward.h"
-#include "sus/mem/never_value.h"
-#include "sus/mem/relocate.h"
-#include "sus/mem/replace.h"
-
-namespace sus::fn {
-
-/// A closure that erases the type of the internal callable object (lambda). A
-/// FnMutRef may be called multiple times, and holds a const callable object, so
-/// it will return the same value each call with the same inputs.
-///
-/// FnRef can be used as a FnMutRef, which can be used as a FnOnceRef. Lambdas
-/// can be converted into a FnOnceRef, FnMutRef, or FnRef directly.
-///
-/// FnOnceRef, FnMutRef and FnRef are only safe to appear as lvalues when they
-/// are a function parameter, and a clang-tidy check is provided to enforce
-/// this. They only hold a reference to the underlying lambda so they must not
-/// outlive the lambda.
-///
-/// # Why can a "const" FnRef convert to a mutable FnMutRef or FnOnceRef?
-///
-/// A FnMutRef or FnOnceRef is _allowed_ to mutate its storage, but a "const"
-/// FnRef closure would just choose not to do so.
-///
-/// However, a `const FnRef` requires that the storage is not mutated, so it is
-/// not useful if converted to a `const FnMutRef` or `const FnOnceRef` which are
-/// only callable as mutable objects.
-///
-/// # Null pointers
-///
-/// A null function pointer is not allowed, constructing a FnOnceRef from a null
-/// pointer will panic.
-template <class R, class... CallArgs>
-class [[sus_trivial_abi]] FnRef<R(CallArgs...)> {
- public:
-  /// Construction from a function pointer.
-  ///
-  /// #[doc.overloads=ctor.fnpointer]
-  template <__private::FunctionPointer<R, CallArgs...> F>
-  FnRef(F ptr) noexcept {
-    ::sus::check(ptr != nullptr);
-    storage_.fnptr = reinterpret_cast<void (*)()>(ptr);
-    invoke_ = &__private::Invoker<F>::template fnptr_call_const<R, CallArgs...>;
-  }
-
-  /// Construction from a non-capturing lambda.
-  ///
-  /// #[doc.overloads=ctor.lambda]
-  template <__private::CallableConst<R, CallArgs...> F>
-    requires(__private::ConvertsToFunctionPointer<F>)
-  constexpr FnRef(F&& object sus_lifetimebound) noexcept {
-    storage_.object = ::sus::mem::addressof(object);
-    invoke_ = &__private::Invoker<
-        std::remove_reference_t<F>>::template object_call_const<R, CallArgs...>;
-  }
-
-  /// Construction from a capturing lambda or other callable object.
-  ///
-  /// #[doc.overloads=ctor.capturelambda]
-  template <__private::CallableConst<R, CallArgs...> F>
-    requires(!__private::ConvertsToFunctionPointer<F>)
-  constexpr FnRef(F&& object sus_lifetimebound) noexcept {
-    storage_.object = ::sus::mem::addressof(object);
-    invoke_ = &__private::Invoker<
-        std::remove_reference_t<F>>::template object_call_const<R, CallArgs...>;
-  }
-
-  ~FnRef() noexcept = default;
-
-  constexpr FnRef(FnRef&& o) noexcept
-      : storage_(o.storage_), invoke_(::sus::mem::replace(o.invoke_, nullptr)) {
-    ::sus::check(invoke_);  // Catch use-after-move.
-  }
-  constexpr FnRef& operator=(FnRef&& o) noexcept {
-    storage_ = o.storage_;
-    invoke_ = ::sus::mem::replace(o.invoke_, nullptr);
-    ::sus::check(invoke_);  // Catch use-after-move.
-    return *this;
-  }
-
-  // Not copyable.
-  FnRef(const FnRef&) noexcept = delete;
-  FnRef& operator=(const FnRef&) noexcept = delete;
-
-  /// sus::mem::Clone trait.
-  constexpr FnRef clone() const {
-    ::sus::check(invoke_);  // Catch use-after-move.
-    return FnRef(storage_, invoke_);
-  }
-
-  /// Runs the closure.
-  ///
-  /// #[doc.overloads=call.const]
-  inline R operator()(CallArgs... args) const& {
-    ::sus::check(invoke_);  // Catch use-after-move.
-    return (*invoke_)(storage_, ::sus::forward<CallArgs>(args)...);
-  }
-
-  /// Runs and consumes the closure.
-  ///
-  /// #[doc.overloads=call.rvalue]
-  inline R operator()(CallArgs... args) && {
-    ::sus::check(invoke_);  // Catch use-after-move.
-    return (*::sus::mem::replace(invoke_, nullptr))(
-        storage_, ::sus::forward<CallArgs>(args)...);
-  }
-
-  /// `sus::construct::From` trait implementation.
-  ///
-  /// FnRef satisfies `From<T>` for the same types that it is constructible
-  /// from: function pointers that exactly match its own signature, and
-  /// const-callable objects (lambdas) that are compatible with its signature.
-  template <class F>
-    requires(std::constructible_from<FnRef, F &&>)
-  constexpr static auto from(F&& object sus_lifetimebound) noexcept {
-    return FnRef(::sus::forward<F>(object));
-  }
-
- private:
-  template <class RR, class... AArgs>
-  friend class FnOnceRef;
-  template <class RR, class... AArgs>
-  friend class FnMutRef;
-
-  constexpr FnRef(union __private::Storage storage,
-                  __private::InvokeFnPtr<R, CallArgs...> invoke)
-      : storage_(storage), invoke_(invoke) {}
-
-  union __private::Storage storage_;
-  /// The `invoke_` pointer is set to null to indicate the FnRef is moved-from.
-  /// It uses another pointer value as its never-value.
-  __private::InvokeFnPtr<R, CallArgs...> invoke_;
-
-  // A function pointer to use as a never-value for InvokeFnPointer.
-  static R invoke_never_value(const union __private::Storage&, CallArgs...) {
-    sus::unreachable();
-  }
-
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn,
-                                  decltype(storage_.fnptr),
-                                  decltype(storage_.object), decltype(invoke_));
-  sus_class_never_value_field(::sus::marker::unsafe_fn, FnRef, invoke_,
-                              &invoke_never_value, &invoke_never_value);
-  // For the NeverValueField.
-  explicit constexpr FnRef(::sus::mem::NeverValueConstructor) noexcept
-      : invoke_(&invoke_never_value) {}
-};
-
-/// A closure that erases the type of the internal callable object (lambda) that
-/// may mutate internal state. A FnMutRef may be called multiple times, and may
-/// return a different value on each call with the same inputs.
-///
-/// FnRef can be used as a FnMutRef, which can be used as a FnOnceRef. Lambdas
-/// can be converted into a FnOnceRef, FnMutRef, or FnRef directly.
-///
-/// FnOnceRef, FnMutRef and FnRef are only safe to appear as lvalues when they
-/// are a function parameter, and a clang-tidy check is provided to enforce
-/// this. They only hold a reference to the underlying lambda so they must not
-/// outlive the lambda.
-///
-/// # Why can a "const" FnRef convert to a mutable FnMutRef or FnOnceRef?
-///
-/// A FnMutRef or FnOnceRef is _allowed_ to mutate its storage, but a "const"
-/// FnRef closure would just choose not to do so.
-///
-/// However, a `const FnRef` requires that the storage is not mutated, so it is
-/// not useful if converted to a `const FnMutRef` or `const FnOnceRef` which are
-/// only callable as mutable objects.
-///
-/// # Null pointers
-///
-/// A null function pointer is not allowed, constructing a FnOnceRef from a null
-/// pointer will panic.
-template <class R, class... CallArgs>
-class [[sus_trivial_abi]] FnMutRef<R(CallArgs...)> {
- public:
-  /// Construction from a function pointer or captureless lambda.
-  ///
-  /// #[doc.overloads=ctor.fnpointer]
-  template <__private::FunctionPointer<R, CallArgs...> F>
-  FnMutRef(F ptr) noexcept {
-    ::sus::check(ptr != nullptr);
-    storage_.fnptr = reinterpret_cast<void (*)()>(ptr);
-    invoke_ = &__private::Invoker<F>::template fnptr_call_mut<R, CallArgs...>;
-  }
-
-  /// Construction from a non-capturing lambda.
-  ///
-  /// #[doc.overloads=ctor.lambda]
-  template <__private::CallableMut<R, CallArgs...> F>
-    requires(__private::ConvertsToFunctionPointer<F>)
-  constexpr FnMutRef(F&& object sus_lifetimebound) noexcept {
-    storage_.object = ::sus::mem::addressof(object);
-    invoke_ = &__private::Invoker<
-        std::remove_reference_t<F>>::template object_call_mut<R, CallArgs...>;
-  }
-
-  /// Construction from a capturing lambda or other callable object.
-  ///
-  /// #[doc.overloads=ctor.capturelambda]
-  template <__private::CallableMut<R, CallArgs...> F>
-    requires(!__private::ConvertsToFunctionPointer<F>)
-  constexpr FnMutRef(F&& object sus_lifetimebound) noexcept {
-    storage_.object = ::sus::mem::addressof(object);
-    invoke_ = &__private::Invoker<
-        std::remove_reference_t<F>>::template object_call_mut<R, CallArgs...>;
-  }
-
-  /// Construction from FnRef.
-  ///
-  /// Since FnRef is callable, FnMutRef is already constructible from it, but
-  /// this constructor avoids extra indirections being inserted when converting,
-  /// since otherwise an extra invoker call would be introduced.
-  ///
-  /// #[doc.overloads=ctor.fnref]
-  constexpr FnMutRef(FnRef<R(CallArgs...)>&& o sus_lifetimebound) noexcept
-      : storage_(o.storage_), invoke_(::sus::mem::replace(o.invoke_, nullptr)) {
-    ::sus::check(invoke_);  // Catch use-after-move.
-  }
-
-  ~FnMutRef() noexcept = default;
-
-  constexpr FnMutRef(FnMutRef&& o) noexcept
-      : storage_(o.storage_), invoke_(::sus::mem::replace(o.invoke_, nullptr)) {
-    ::sus::check(invoke_);  // Catch use-after-move.
-  }
-  constexpr FnMutRef& operator=(FnMutRef&& o) noexcept {
-    storage_ = o.storage_;
-    invoke_ = ::sus::mem::replace(o.invoke_, nullptr);
-    ::sus::check(invoke_);  // Catch use-after-move.
-    return *this;
-  }
-
-  // Not copyable.
-  FnMutRef(const FnMutRef&) noexcept = delete;
-  FnMutRef& operator=(const FnMutRef&) noexcept = delete;
-
-  /// sus::mem::Clone trait.
-  constexpr FnMutRef clone() const {
-    ::sus::check(invoke_);  // Catch use-after-move.
-    return FnMutRef(storage_, invoke_);
-  }
-
-  /// Runs the closure.
-  ///
-  /// #[doc.overloads=call.mut]
-  inline R operator()(CallArgs... args) & {
-    ::sus::check(invoke_);  // Catch use-after-move.
-    return (*invoke_)(storage_, ::sus::forward<CallArgs>(args)...);
-  }
-
-  /// Runs and consumes the closure.
-  ///
-  /// #[doc.overloads=call.rvalue]
-  inline R operator()(CallArgs... args) && {
-    ::sus::check(invoke_);  // Catch use-after-move.
-    return (*::sus::mem::replace(invoke_, nullptr))(
-        storage_, ::sus::forward<CallArgs>(args)...);
-  }
-
-  /// `sus::construct::From` trait implementation.
-  ///
-  /// FnMutRef satisfies `From<T>` for the same types that it is constructible
-  /// from: function pointers that exactly match its own signature, and callable
-  /// objects (lambdas) that are compatible with its signature.
-  template <class F>
-    requires(std::constructible_from<FnMutRef, F &&>)
-  constexpr static auto from(F&& object sus_lifetimebound) noexcept {
-    return FnMutRef(::sus::forward<F>(object));
-  }
-
- private:
-  template <class RR, class... AArgs>
-  friend class FnOnceRef;
-
-  constexpr FnMutRef(union __private::Storage storage,
-                     __private::InvokeFnPtr<R, CallArgs...> invoke)
-      : storage_(storage), invoke_(invoke) {}
-
-  union __private::Storage storage_;
-  /// The `invoke_` pointer is set to null to indicate the `FnMutRef` is
-  /// moved-from. It uses another pointer value as its never-value.
-  __private::InvokeFnPtr<R, CallArgs...> invoke_;
-
-  // A function pointer to use as a never-value for InvokeFnPointer.
-  static R invoke_never_value(const union __private::Storage&, CallArgs...) {
-    sus::unreachable();
-  }
-
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn,
-                                  decltype(storage_.fnptr),
-                                  decltype(storage_.object), decltype(invoke_));
-  sus_class_never_value_field(::sus::marker::unsafe_fn, FnMutRef, invoke_,
-                              &invoke_never_value, &invoke_never_value);
-  // For the NeverValueField.
-  explicit constexpr FnMutRef(::sus::mem::NeverValueConstructor) noexcept
-      : invoke_(&invoke_never_value) {}
-};
-
-/// A closure that erases the type of the internal callable object (lambda). A
-/// FnOnceRef may only be called a single time.
-///
-/// FnRef can be used as a FnMutRef, which can be used as a FnOnceRef. Lambdas
-/// can be converted into a FnOnceRef, FnMutRef, or FnRef directly.
-///
-/// FnOnceRef, FnMutRef and FnRef are only safe to appear as lvalues when they
-/// are a function parameter, and a clang-tidy check is provided to enforce
-/// this. They only hold a reference to the underlying lambda so they must not
-/// outlive the lambda.
-///
-/// # Why can a "const" FnRef convert to a mutable FnMutRef or FnOnceRef?
-///
-/// A FnMutRef or FnOnceRef is _allowed_ to mutate its storage, but a "const"
-/// FnRef closure would just choose not to do so.
-///
-/// However, a `const FnRef` requires that the storage is not mutated, so it is
-/// not useful if converted to a `const FnMutRef` or `const FnOnceRef` which are
-/// only callable as mutable objects.
-///
-/// # Null pointers
-///
-/// A null function pointer is not allowed, constructing a FnOnceRef from a null
-/// pointer will panic.
-template <class R, class... CallArgs>
-class [[sus_trivial_abi]] FnOnceRef<R(CallArgs...)> {
- public:
-  /// Construction from a function pointer or captureless lambda.
-  ///
-  /// #[doc.overloads=ctor.fnpointer]
-  template <__private::FunctionPointer<R, CallArgs...> F>
-  FnOnceRef(F ptr) noexcept {
-    ::sus::check(ptr != nullptr);
-    storage_.fnptr = reinterpret_cast<void (*)()>(ptr);
-    invoke_ = &__private::Invoker<F>::template fnptr_call_mut<R, CallArgs...>;
-  }
-
-  /// Construction from a non-capturing lambda.
-  ///
-  /// #[doc.overloads=ctor.lambda]
-  template <__private::CallableOnceMut<R, CallArgs...> F>
-    requires(__private::ConvertsToFunctionPointer<F>)
-  constexpr FnOnceRef(F&& object sus_lifetimebound) noexcept {
-    storage_.object = ::sus::mem::addressof(object);
-    invoke_ = &__private::Invoker<
-        std::remove_reference_t<F>>::template object_call_once<R, CallArgs...>;
-  }
-
-  /// Construction from a capturing lambda or other callable object.
-  ///
-  /// #[doc.overloads=ctor.capturelambda]
-  template <__private::CallableOnceMut<R, CallArgs...> F>
-    requires(!__private::ConvertsToFunctionPointer<F>)
-  constexpr FnOnceRef(F&& object sus_lifetimebound) noexcept {
-    storage_.object = ::sus::mem::addressof(object);
-    invoke_ = &__private::Invoker<
-        std::remove_reference_t<F>>::template object_call_once<R, CallArgs...>;
-  }
-
-  /// Construction from FnMutRef.
-  ///
-  /// Since FnMutRef is callable, FnOnceRef is already constructible from it,
-  /// but this constructor avoids extra indirections being inserted when
-  /// converting, since otherwise an extra invoker call would be introduced.
-  ///
-  /// #[doc.overloads=ctor.fnmutref]
-  constexpr FnOnceRef(FnMutRef<R(CallArgs...)>&& o sus_lifetimebound) noexcept
-      : storage_(o.storage_), invoke_(::sus::mem::replace(o.invoke_, nullptr)) {
-    ::sus::check(invoke_);  // Catch use-after-move.
-  }
-
-  /// Construction from FnRef.
-  ///
-  /// Since FnRef is callable, FnOnceRef is already constructible from it, but
-  /// this constructor avoids extra indirections being inserted when converting,
-  /// since otherwise an extra invoker call would be introduced.
-  ///
-  /// #[doc.overloads=ctor.fnref]
-  constexpr FnOnceRef(FnRef<R(CallArgs...)>&& o sus_lifetimebound) noexcept
-      : storage_(o.storage_), invoke_(::sus::mem::replace(o.invoke_, nullptr)) {
-    ::sus::check(invoke_);  // Catch use-after-move.
-  }
-
-  ~FnOnceRef() noexcept = default;
-
-  constexpr FnOnceRef(FnOnceRef&& o) noexcept
-      : storage_(o.storage_), invoke_(::sus::mem::replace(o.invoke_, nullptr)) {
-    ::sus::check(invoke_);  // Catch use-after-move.
-  }
-  constexpr FnOnceRef& operator=(FnOnceRef&& o) noexcept {
-    storage_ = o.storage_;
-    invoke_ = ::sus::mem::replace(o.invoke_, nullptr);
-    ::sus::check(invoke_);  // Catch use-after-move.
-    return *this;
-  }
-
-  // Not copyable.
-  FnOnceRef(const FnOnceRef&) noexcept = delete;
-  FnOnceRef& operator=(const FnOnceRef&) noexcept = delete;
-
-  /// A split FnOnceRef object, which can be used to construct other FnOnceRef
-  /// objects, but enforces that only one of them is called.
-  ///
-  /// The Split object must not outlive the FnOnceRef it's constructed from or
-  /// Undefined Behaviour results.
-  class Split {
-   public:
-    Split(FnOnceRef& fn sus_lifetimebound) : fn_(fn) {}
-
-    // Not Copy or Move, only used to construct FnOnceRef objects, which are
-    // constructible from this type.
-    Split(Split&&) = delete;
-    Split& operator=(Split&&) = delete;
-
-    /// Runs the underlying `FnOnceRef`. The `FnOnceRef` may only be called a
-    /// single time and will panic on the second call.
-    R operator()(CallArgs... args) && {
-      return ::sus::move(fn_)(::sus::forward<CallArgs>(args)...);
-    }
-
-   private:
-    FnOnceRef& fn_;
-  };
-
-  /// A `FnOnceRef` can be split into any number of `FnOnceRef` objects, while
-  /// enforcing that the underlying function is only called a single time.
-  ///
-  /// This method returns a type that can convert into any number of `FnOnceRef`
-  /// objects. If two of them are called, the second call will panic.
-  ///
-  /// The returned object must not outlive the `FnOnceRef` object it is
-  /// constructed from, this is normally enforced by only using the `FnOnceRef`
-  /// type in function parameters, which ensures it lives for the entire
-  /// function body, and calling `split()` to construct temporary objects for
-  /// passing to other functions that receive a `FnOnceRef`. The result of
-  /// `split()` should never be stored as a member of an object.
-  ///
-  /// Only callable on an lvalue FnOnceRef (typically written as a function
-  /// parameter) as an rvalue can be simply passed along without splitting.
-  constexpr Split split() & noexcept sus_lifetimebound { return Split(*this); }
-
-  /// Runs and consumes the closure.
-  inline R operator()(CallArgs... args) && {
-    ::sus::check(invoke_);  // Catch use-after-move.
-    return (*::sus::mem::replace(invoke_, nullptr))(
-        storage_, ::sus::forward<CallArgs>(args)...);
-  }
-
-  /// `sus::construct::From` trait implementation.
-  ///
-  /// FnOnceRef satisfies `From<T>` for the same types that it is constructible
-  /// from: function pointers that exactly match its own signature, and callable
-  /// objects (lambdas) that are compatible with its signature.
-  template <class F>
-    requires(std::constructible_from<FnOnceRef, F &&>)
-  constexpr static auto from(F&& object sus_lifetimebound) noexcept {
-    return FnOnceRef(::sus::forward<F>(object));
-  }
-
- private:
-  friend FnMutRef<R, CallArgs...>;
-  friend FnRef<R, CallArgs...>;
-
-  constexpr FnOnceRef(union __private::Storage storage,
-                      __private::InvokeFnPtr<R, CallArgs...> invoke)
-      : storage_(storage), invoke_(invoke) {}
-
-  union __private::Storage storage_;
-  /// The `invoke_` pointer is set to null to indicate the FnOnceRef is
-  /// moved-from. It uses another pointer value as its never-value.
-  __private::InvokeFnPtr<R, CallArgs...> invoke_;
-
-  // A function pointer to use as a never-value for InvokeFnPointer.
-  static R invoke_never_value(const union __private::Storage&, CallArgs...) {
-    sus::unreachable();
-  }
-
-  sus_class_trivially_relocatable(::sus::marker::unsafe_fn,
-                                  decltype(storage_.fnptr),
-                                  decltype(storage_.object), decltype(invoke_));
-  sus_class_never_value_field(::sus::marker::unsafe_fn, FnOnceRef, invoke_,
-                              &invoke_never_value, &invoke_never_value);
-  // For the NeverValueField.
-  explicit constexpr FnOnceRef(::sus::mem::NeverValueConstructor) noexcept
-      : invoke_(&invoke_never_value) {}
-};
-
-}  // namespace sus::fn
diff --git a/sus/fn/fn_ref_unittest.cc b/sus/fn/fn_ref_unittest.cc
deleted file mode 100644
index f25b2f38f..000000000
--- a/sus/fn/fn_ref_unittest.cc
+++ /dev/null
@@ -1,891 +0,0 @@
-// Copyright 2022 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <concepts>
-
-#include "googletest/include/gtest/gtest.h"
-#include "sus/construct/into.h"
-#include "sus/fn/fn.h"
-#include "sus/mem/forward.h"
-#include "sus/mem/move.h"
-#include "sus/mem/never_value.h"
-#include "sus/mem/relocate.h"
-#include "sus/mem/replace.h"
-#include "sus/option/option.h"
-#include "sus/prelude.h"
-
-namespace {
-
-using sus::construct::Into;
-using sus::fn::FnMutRef;
-using sus::fn::FnOnceRef;
-using sus::fn::FnRef;
-
-static_assert(sus::mem::NeverValueField<FnRef<void()>>);
-static_assert(sus::mem::NeverValueField<FnMutRef<void()>>);
-static_assert(sus::mem::NeverValueField<FnOnceRef<void()>>);
-static_assert(sus::mem::relocate_by_memcpy<FnRef<void()>>);
-static_assert(sus::mem::relocate_by_memcpy<FnMutRef<void()>>);
-static_assert(sus::mem::relocate_by_memcpy<FnOnceRef<void()>>);
-
-struct Copyable {
-  Copyable(int i) : i(i) {}
-  Copyable(const Copyable& c) = default;
-  Copyable& operator=(const Copyable& c) = default;
-  ~Copyable() { i = -10000000; }
-
-  int i = 0;
-};
-
-struct MoveOnly {
-  MoveOnly(int i) : i(i) {}
-  MoveOnly(const MoveOnly& c) = delete;
-  MoveOnly& operator=(const MoveOnly& c) = delete;
-  MoveOnly(MoveOnly&& c) : i(::sus::mem::replace(c.i, -1)) {}
-  MoveOnly& operator=(MoveOnly&& c) {
-    i = ::sus::mem::replace(c.i, -1);
-    return *this;
-  }
-  ~MoveOnly() { i = -10000000; }
-
-  int i = 0;
-};
-
-// clang-format-off
-
-struct BaseClass {};
-struct SubClass : public BaseClass {};
-
-static_assert(sizeof(FnOnceRef<void()>) == 2 * sizeof(void (*)()));
-
-void v_v_function() {}
-int i_f_function(float) { return 0; }
-void v_f_function(float) {}
-BaseClass* b_b_function(BaseClass* b) { return b; }
-SubClass* s_b_function(BaseClass* b) { return static_cast<SubClass*>(b); }
-SubClass* s_s_function(SubClass* b) { return b; }
-
-auto b_b_lambda = [a = 1](BaseClass* b) -> BaseClass* { return b; };
-auto s_b_lambda = [a = 1](BaseClass* b) -> SubClass* {
-  return static_cast<SubClass*>(b);
-};
-auto s_s_lambda = [a = 1](SubClass* b) -> SubClass* { return b; };
-
-// FnRef types all have a never-value field.
-static_assert(sus::mem::NeverValueField<FnOnceRef<void()>>);
-static_assert(sus::mem::NeverValueField<FnMutRef<void()>>);
-static_assert(sus::mem::NeverValueField<FnRef<void()>>);
-//  Which allows them to not require a flag in Option.
-static_assert(sizeof(sus::Option<FnOnceRef<void()>>) ==
-              sizeof(FnOnceRef<void()>));
-
-// Closures are not copyable.
-static_assert(!std::is_copy_constructible_v<FnOnceRef<void()>>);
-static_assert(!std::is_copy_assignable_v<FnOnceRef<void()>>);
-static_assert(!std::is_copy_constructible_v<FnMutRef<void()>>);
-static_assert(!std::is_copy_assignable_v<FnMutRef<void()>>);
-static_assert(!std::is_copy_constructible_v<FnRef<void()>>);
-static_assert(!std::is_copy_assignable_v<FnRef<void()>>);
-// Closures can be moved.
-static_assert(std::is_move_constructible_v<FnOnceRef<void()>>);
-static_assert(std::is_move_assignable_v<FnOnceRef<void()>>);
-static_assert(std::is_move_constructible_v<FnMutRef<void()>>);
-static_assert(std::is_move_assignable_v<FnMutRef<void()>>);
-static_assert(std::is_move_constructible_v<FnRef<void()>>);
-static_assert(std::is_move_assignable_v<FnRef<void()>>);
-
-// FnMutRef and FnRef are Clone, but not FnOnceRef. None of them are Copy.
-static_assert(sus::mem::Move<FnOnceRef<void()>>);
-static_assert(sus::mem::Move<FnMutRef<void()>>);
-static_assert(sus::mem::Move<FnRef<void()>>);
-static_assert(!sus::mem::Copy<FnOnceRef<void()>>);
-static_assert(!sus::mem::Copy<FnMutRef<void()>>);
-static_assert(!sus::mem::Copy<FnRef<void()>>);
-static_assert(!sus::mem::Clone<FnOnceRef<void()>>);
-static_assert(sus::mem::Clone<FnMutRef<void()>>);
-static_assert(sus::mem::Clone<FnRef<void()>>);
-
-// Closures are trivially relocatable.
-static_assert(sus::mem::relocate_by_memcpy<FnOnceRef<void()>>);
-static_assert(sus::mem::relocate_by_memcpy<FnMutRef<void()>>);
-static_assert(sus::mem::relocate_by_memcpy<FnRef<void()>>);
-
-// clang-format off
-
-// A function pointer, or convertible lambda, can be bound to FnOnceRef, FnMutRef and
-// FnRef.
-static_assert(std::is_constructible_v<FnOnceRef<void()>, decltype([]() {})>);
-static_assert(std::is_constructible_v<FnMutRef<void()>, decltype([]() {})>);
-static_assert(std::is_constructible_v<FnRef<void()>, decltype([]() {})>);
-static_assert(std::is_constructible_v<FnOnceRef<void()>, decltype(v_v_function)>);
-static_assert(std::is_constructible_v<FnMutRef<void()>, decltype(v_v_function)>);
-static_assert(std::is_constructible_v<FnRef<void()>, decltype(v_v_function)>);
-//  Non-void types for the same.
-static_assert(std::is_constructible_v<
-    FnOnceRef<int(float)>, decltype([](float) { return 1; })>
-);
-static_assert(std::is_constructible_v<
-    FnMutRef<int(float)>, decltype([](float) { return 1; })>
-);
-static_assert(std::is_constructible_v<
-    FnRef<int(float)>, decltype([](float) { return 1; })>
-);
-static_assert(std::is_constructible_v<
-    FnOnceRef<int(float)>, decltype(i_f_function)>
-);
-static_assert(std::is_constructible_v<
-    FnMutRef<int(float)>, decltype(i_f_function)>
-);
-static_assert(std::is_constructible_v<
-    FnRef<int(float)>, decltype(i_f_function)>
-);
-// Lambdas with bound args can be bound to FnOnceRef, FnMutRef and FnRef.
-static_assert(std::is_constructible_v<
-    FnOnceRef<void()>, decltype([i = int(1)]() { (void)i; })>
-);
-static_assert(std::is_constructible_v<
-    FnOnceRef<void()>, decltype([i = int(1)]() mutable { ++i; })>
-);
-static_assert(std::is_constructible_v<
-    FnMutRef<void()>, decltype([i = int(1)]() { (void)i; })>
-);
-static_assert(std::is_constructible_v<
-    FnMutRef<void()>, decltype([i = int(1)]() mutable { ++i; })>
-);
-static_assert(std::is_constructible_v<
-    FnRef<void()>, decltype([i = int(1)]() { (void)i; })>
-);
-// But FnRef, which is const, can't hold a mutable lambda.
-static_assert(!std::is_constructible_v<
-    FnRef<void()>, decltype([i = int(1)]() mutable { ++i; })>
-);
-
-// The return type of the FnOnceRef must match that of the lambda. It will not
-// allow converting to void.
-static_assert(std::is_constructible_v<
-    FnOnceRef<SubClass*(BaseClass*)>, decltype(s_b_function)>
-);
-static_assert(!std::is_constructible_v<
-    FnOnceRef<void(BaseClass*)>, decltype(b_b_function)>
-);
-static_assert(!std::is_constructible_v<
-    FnOnceRef<SubClass*(BaseClass*)>, decltype(b_b_function)>
-);
-static_assert(std::is_constructible_v<
-    FnOnceRef<SubClass*(BaseClass*)>, decltype(s_b_lambda)>
-);
-static_assert(!std::is_constructible_v<
-    FnOnceRef<void(BaseClass*)>, decltype(b_b_lambda)>
-);
-static_assert(!std::is_constructible_v<
-    FnOnceRef<SubClass*(BaseClass*)>, decltype(b_b_lambda)>
-);
-// Similarly, argument types can't be converted to a different type.
-static_assert(std::is_constructible_v<
-    FnOnceRef<SubClass*(SubClass*)>, decltype(s_s_function)>
-);
-static_assert(!std::is_constructible_v<
-    FnOnceRef<SubClass*(BaseClass*)>, decltype(s_s_function)>
-);
-static_assert(std::is_constructible_v<
-    FnOnceRef<SubClass*(SubClass*)>, decltype(s_s_lambda)>
-);
-static_assert(!std::is_constructible_v<
-    FnOnceRef<SubClass*(BaseClass*)>, decltype(s_s_lambda)>
-);
-// But FnOnceRef type is compatible with convertible return and argument types in
-// opposite directions.
-// - If the return type Y of a lambda is convertible _to_ X, then FnOnceRef<X()>
-// can be
-//   used to store it.
-// - If the argument type Y of a lambda is convertible _from_ X, then
-// FnOnceRef<(X)>
-//   can be used to store it.
-//
-// In both cases, the FnOnceRef is more strict than the lambda, guaranteeing that
-// the lambda's requirements are met.
-static_assert(std::is_constructible_v<
-    FnOnceRef<BaseClass*(BaseClass*)>, decltype(s_b_lambda)>
-);
-static_assert(std::is_constructible_v<
-    FnOnceRef<SubClass*(SubClass*)>, decltype(s_b_lambda)>
-);
-static_assert(std::is_constructible_v<
-    FnOnceRef<BaseClass*(BaseClass*)>, decltype(s_b_function)>
-);
-static_assert(std::is_constructible_v<
-    FnOnceRef<SubClass*(SubClass*)>, decltype(s_b_function)>
-);
-
-// clang-format on
-
-template <class R, class Param, class Arg>
-concept can_run =
-    requires(Arg&& arg, FnOnceRef<R(Param)> fnonce, FnMutRef<R(Param)> FnMutRef
-             //,
-             //  FnRef<R(Param)> FnRef
-    ) {
-      { sus::move(fnonce)(sus::forward<Arg>(arg)) };
-      { FnMutRef(sus::forward<Arg>(arg)) };
-      //{ sus::move(FnRef)(sus::forward<Arg>(arg)) };
-    };
-// clang-format on
-
-// Int is copyable, so references are copied when passed.
-static_assert(can_run<void, int, int>);
-static_assert(can_run<void, int, int&&>);
-static_assert(can_run<void, int, int&>);
-static_assert(can_run<void, int, const int>);
-static_assert(can_run<void, int, const int&>);
-static_assert(can_run<void, int, const int&&>);
-// But for a move-only type, it can only be passed along as a reference or an
-// rvalue.
-static_assert(can_run<void, MoveOnly, MoveOnly>);
-static_assert(can_run<void, MoveOnly, MoveOnly&&>);
-static_assert(!can_run<void, MoveOnly, MoveOnly&>);
-static_assert(!can_run<void, MoveOnly, const MoveOnly>);
-static_assert(!can_run<void, MoveOnly, const MoveOnly&>);
-static_assert(!can_run<void, MoveOnly, const MoveOnly&&>);
-static_assert(can_run<void, const MoveOnly&, MoveOnly&>);
-static_assert(can_run<void, const MoveOnly&, const MoveOnly&>);
-static_assert(can_run<void, MoveOnly&, MoveOnly&>);
-static_assert(!can_run<void, MoveOnly&, const MoveOnly&>);
-
-// Receiving a mutable reference means it must be passed as a mutable reference.
-static_assert(can_run<void, int&, int&>);
-static_assert(!can_run<void, int&, const int&>);
-static_assert(!can_run<void, int&, int>);
-
-// Receiving a const reference means it must be passed as a reference.
-static_assert(can_run<void, const int&, int&>);
-static_assert(can_run<void, const int&, const int&>);
-static_assert(!can_run<void, int&, int>);
-static_assert(!can_run<void, int&, const int>);
-static_assert(!can_run<void, int&, int&&>);
-static_assert(!can_run<void, int&, const int&&>);
-
-TEST(FnRef, Pointer) {
-  {
-    auto receive_fn = [](FnOnceRef<i32(i32, i32)> f, i32 a, i32 b) {
-      return sus::move(f)(a, b);
-    };
-    auto* ptr = +[](i32 a, i32 b) { return a * 2 + b; };
-    EXPECT_EQ(receive_fn(ptr, 1, 2), 4);
-  }
-  {
-    auto receive_fn = [](FnMutRef<i32(i32, i32)> f, i32 a, i32 b) {
-      f(a, b);
-      return sus::move(f)(a, b);
-    };
-    auto* ptr = +[](i32 a, i32 b) { return a * 2 + b; };
-    EXPECT_EQ(receive_fn(ptr, 1, 2), 4);
-  }
-  {
-    {
-      auto receive_fn = [](FnRef<i32(i32, i32)> f, i32 a, i32 b) {
-        f(a, b);
-        return sus::move(f)(a, b);
-      };
-      auto* ptr = +[](i32 a, i32 b) { return a * 2 + b; };
-      EXPECT_EQ(receive_fn(ptr, 1, 2), 4);
-    }
-  }
-}
-
-TEST(FnRef, CapturelessLambda) {
-  {
-    auto receive_fn = [](FnOnceRef<i32(i32, i32)> f, i32 a, i32 b) {
-      return sus::move(f)(a, b);
-    };
-    auto lambda = [](i32 a, i32 b) { return a * 2 + b; };
-    EXPECT_EQ(receive_fn(lambda, 1, 2), 4);
-  }
-  {
-    auto receive_fn = [](FnMutRef<i32(i32, i32)> f, i32 a, i32 b) {
-      f(a, b);
-      return sus::move(f)(a, b);
-    };
-    auto lambda = [i = 1_i32](i32 a, i32 b) mutable {
-      i += 1;
-      return a * 2 + b;
-    };
-    EXPECT_EQ(receive_fn(lambda, 1, 2), 4);
-  }
-  {
-    {
-      auto receive_fn = [](FnRef<i32(i32, i32)> f, i32 a, i32 b) {
-        f(a, b);
-        return sus::move(f)(a, b);
-      };
-      auto lambda = [](i32 a, i32 b) { return a * 2 + b; };
-      EXPECT_EQ(receive_fn(lambda, 1, 2), 4);
-    }
-  }
-}
-
-TEST(FnRef, Lambda) {
-  {
-    auto receive_fn = [](FnOnceRef<i32(i32)> f, i32 b) {
-      return sus::move(f)(b);
-    };
-    auto lambda = [a = 1_i32](i32 b) { return a * 2 + b; };
-    EXPECT_EQ(receive_fn(lambda, 2), 4);
-  }
-  {
-    auto receive_fn = [](FnMutRef<i32(i32)> f, i32 b) {
-      f(b);
-      return sus::move(f)(b);
-    };
-    auto lambda = [a = 1_i32](i32 b) mutable {
-      a += 1;
-      return a * 2 + b;
-    };
-    EXPECT_EQ(receive_fn(lambda, 2), 8);
-  }
-  {
-    auto receive_fn = [](FnRef<i32(i32)> f, i32 b) {
-      f(b);
-      return sus::move(f)(b);
-    };
-    auto lambda = [a = 1_i32](i32 b) { return a * 2 + b; };
-    EXPECT_EQ(receive_fn(lambda, 2), 4);
-  }
-}
-
-TEST(FnRef, TemplateLambda) {
-  {
-    auto receive_fn = [](FnOnceRef<i32(i32)> f, i32 b) {
-      return sus::move(f)(b);
-    };
-    auto lambda = [a = 1_i32](auto b) { return a * 2 + b; };
-    EXPECT_EQ(receive_fn(lambda, 2), 4);
-  }
-  {
-    auto receive_fn = [](FnMutRef<i32(i32)> f, i32 b) {
-      f(b);
-      return sus::move(f)(b);
-    };
-    auto lambda = [a = 1_i32](auto b) mutable {
-      a += 1;
-      return a * 2 + b;
-    };
-    EXPECT_EQ(receive_fn(lambda, 2), 8);
-  }
-  {
-    auto receive_fn = [](FnRef<i32(i32)> f, i32 b) {
-      f(b);
-      return sus::move(f)(b);
-    };
-    auto lambda = [a = 1_i32](auto b) { return a * 2 + b; };
-    EXPECT_EQ(receive_fn(lambda, 2), 4);
-  }
-}
-
-TEST(FnDeathTest, NullPointer) {
-  void (*f)() = nullptr;
-#if GTEST_HAS_DEATH_TEST
-  EXPECT_DEATH((FnOnceRef<void()>(f)), "");
-#endif
-#if GTEST_HAS_DEATH_TEST
-  EXPECT_DEATH((FnMutRef<void()>(f)), "");
-#endif
-#if GTEST_HAS_DEATH_TEST
-  EXPECT_DEATH((FnRef<void()>(f)), "");
-#endif
-}
-
-TEST(FnDeathTest, CallAfterMoveConstruct) {
-  {
-    [](FnOnceRef<void()> x) {
-      [](auto) {}(sus::move(x));
-#if GTEST_HAS_DEATH_TEST
-      EXPECT_DEATH(sus::move(x)(), "");
-#endif
-    }([]() {});
-  }
-  {
-    [](FnMutRef<void()> x) {
-      [](auto) {}(sus::move(x));
-#if GTEST_HAS_DEATH_TEST
-      EXPECT_DEATH(sus::move(x)(), "");
-#endif
-    }([]() {});
-  }
-  {
-    [](FnRef<void()> x) {
-      [](auto) {}(sus::move(x));
-#if GTEST_HAS_DEATH_TEST
-      EXPECT_DEATH(sus::move(x)(), "");
-#endif
-    }([]() {});
-  }
-}
-
-TEST(FnDeathTest, CallAfterMoveAssign) {
-  {
-    [](FnOnceRef<void()> x, FnOnceRef<void()> y) {
-      y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-      EXPECT_DEATH(sus::move(x)(), "");
-#endif
-    }([]() {}, []() {});
-  }
-  {
-    [](FnMutRef<void()> x, FnMutRef<void()> y) {
-      y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-      EXPECT_DEATH(sus::move(x)(), "");
-#endif
-    }([]() {}, []() {});
-  }
-  {
-    [](FnRef<void()> x, FnRef<void()> y) {
-      y = sus::move(x);
-#if GTEST_HAS_DEATH_TEST
-      EXPECT_DEATH(sus::move(x)(), "");
-#endif
-    }([]() {}, []() {});
-  }
-}
-
-TEST(FnDeathTest, CallAfterCall) {
-  {
-    [](FnOnceRef<void()> x) {
-      sus::move(x)();
-#if GTEST_HAS_DEATH_TEST
-      EXPECT_DEATH(sus::move(x)(), "");
-#endif
-    }([]() {});
-  }
-  {
-    [](FnMutRef<void()> x) {
-      sus::move(x)();
-#if GTEST_HAS_DEATH_TEST
-      EXPECT_DEATH(sus::move(x)(), "");
-#endif
-    }([]() {});
-  }
-  {
-    [](FnRef<void()> x) {
-      sus::move(x)();
-#if GTEST_HAS_DEATH_TEST
-      EXPECT_DEATH(sus::move(x)(), "");
-#endif
-    }([]() {});
-  }
-}
-
-TEST(FnMutRef, ConvertToFnOnce) {
-  auto receive_fnonce = [](FnOnceRef<i32()> x) { return sus::move(x)(); };
-  auto receive_fnmut = [&](FnMutRef<i32()> x) {
-    return receive_fnonce(sus::move(x));
-  };
-  EXPECT_EQ(receive_fnmut([]() { return 2_i32; }), 2);
-}
-
-TEST(FnRef, ConvertToFnOnce) {
-  auto receive_fnonce = [](FnOnceRef<i32()> x) { return sus::move(x)(); };
-  auto receive_fn = [&](FnRef<i32()> x) {
-    return receive_fnonce(sus::move(x));
-  };
-  EXPECT_EQ(receive_fn([]() { return 2_i32; }), 2);
-}
-
-TEST(FnRef, ConvertToFnMut) {
-  auto receive_fnmut = [](FnMutRef<i32()> x) { return sus::move(x)(); };
-  auto receive_fn = [&](FnRef<i32()> x) { return receive_fnmut(sus::move(x)); };
-  EXPECT_EQ(receive_fn([]() { return 2_i32; }), 2);
-}
-
-TEST(FnRef, ConstructionFromConstMut) {
-  struct Captureless {
-    i32 operator()() const { return 2; }
-  };
-  struct Capture {
-    i32 operator()() const { return i; }
-    i32 i = 2;
-  };
-
-  // Const callable can be put in all the FnRef types.
-  static_assert(sus::fn::__private::CallableMut<Captureless, i32>);
-  EXPECT_EQ(2,
-            [](FnOnceRef<i32()> m) { return sus::move(m)(); }(Captureless()));
-  EXPECT_EQ(2, [](FnMutRef<i32()> m) { return sus::move(m)(); }(Captureless()));
-  EXPECT_EQ(2, [](FnRef<i32()> m) { return sus::move(m)(); }(Captureless()));
-  static_assert(sus::fn::__private::CallableMut<Capture, i32>);
-  EXPECT_EQ(2, [](FnOnceRef<i32()> m) { return sus::move(m)(); }(Capture()));
-  EXPECT_EQ(2, [](FnMutRef<i32()> m) { return sus::move(m)(); }(Capture()));
-  EXPECT_EQ(2, [](FnRef<i32()> m) { return sus::move(m)(); }(Capture()));
-
-  struct CapturelessMut {
-    i32 operator()() { return 2; }
-  };
-  struct CaptureMut {
-    i32 operator()() { return i; }
-    i32 i = 2;
-  };
-
-  // Mutable callable can only be put in the mutable FnRef types.
-  static_assert(sus::fn::__private::CallableMut<CapturelessMut, i32>);
-  static_assert(std::is_constructible_v<FnOnceRef<i32()>, CapturelessMut&&>);
-  static_assert(std::is_constructible_v<FnMutRef<i32()>, CapturelessMut&&>);
-  static_assert(!std::is_constructible_v<FnRef<i32()>, CapturelessMut&&>);
-  EXPECT_EQ(
-      2, [](FnOnceRef<i32()> m) { return sus::move(m)(); }(CapturelessMut()));
-  EXPECT_EQ(2,
-            [](FnMutRef<i32()> m) { return sus::move(m)(); }(CapturelessMut()));
-
-  static_assert(sus::fn::__private::CallableMut<CaptureMut, i32>);
-  static_assert(std::is_constructible_v<FnOnceRef<i32()>, CaptureMut&&>);
-  static_assert(std::is_constructible_v<FnMutRef<i32()>, CaptureMut&&>);
-  static_assert(!std::is_constructible_v<FnRef<i32()>, CaptureMut&&>);
-  EXPECT_EQ(2, [](FnOnceRef<i32()> m) { return sus::move(m)(); }(CaptureMut()));
-  EXPECT_EQ(2, [](FnMutRef<i32()> m) { return sus::move(m)(); }(CaptureMut()));
-}
-
-TEST(FnRef, IntoFromConstMut) {
-  i32 (*f)() = +[]() { return 2_i32; };
-
-  // Function pointer can be put in all the FnRef types.
-  static_assert(sus::construct::Into<decltype(f), FnOnceRef<i32()>>);
-  static_assert(sus::construct::Into<decltype(f), FnMutRef<i32()>>);
-  static_assert(sus::construct::Into<decltype(f), FnRef<i32()>>);
-  EXPECT_EQ(2, FnOnceRef<i32()>::from(f)());
-  EXPECT_EQ(2, FnMutRef<i32()>::from(f)());
-  EXPECT_EQ(2, FnRef<i32()>::from(f)());
-
-  struct Captureless {
-    i32 operator()() const { return 2; }
-  };
-  struct Capture {
-    i32 operator()() const { return i; }
-    i32 i = 2;
-  };
-
-  // Const callable can be put in all the FnRef types.
-  static_assert(sus::construct::Into<Captureless, FnOnceRef<i32()>>);
-  static_assert(sus::construct::Into<Captureless, FnMutRef<i32()>>);
-  static_assert(sus::construct::Into<Captureless, FnRef<i32()>>);
-  EXPECT_EQ(2, FnOnceRef<i32()>::from(Captureless())());
-  EXPECT_EQ(2, FnMutRef<i32()>::from(Captureless())());
-  EXPECT_EQ(2, FnRef<i32()>::from(Captureless())());
-  static_assert(sus::construct::Into<Capture, FnOnceRef<i32()>>);
-  static_assert(sus::construct::Into<Capture, FnMutRef<i32()>>);
-  static_assert(sus::construct::Into<Capture, FnRef<i32()>>);
-  EXPECT_EQ(2, FnOnceRef<i32()>::from(Capture())());
-  EXPECT_EQ(2, FnMutRef<i32()>::from(Capture())());
-  EXPECT_EQ(2, FnRef<i32()>::from(Capture())());
-
-  struct CapturelessMut {
-    i32 operator()() { return 2; }
-  };
-  struct CaptureMut {
-    i32 operator()() { return i; }
-    i32 i = 2;
-  };
-
-  // Mutable callable can only be put in the mutable FnRef types.
-  static_assert(sus::construct::Into<CapturelessMut, FnOnceRef<i32()>>);
-  static_assert(sus::construct::Into<CapturelessMut, FnMutRef<i32()>>);
-  static_assert(!sus::construct::Into<CapturelessMut, FnRef<i32()>>);
-  EXPECT_EQ(2, FnOnceRef<i32()>::from(CapturelessMut())());
-  EXPECT_EQ(2, FnMutRef<i32()>::from(CapturelessMut())());
-
-  static_assert(sus::construct::Into<CaptureMut, FnOnceRef<i32()>>);
-  static_assert(sus::construct::Into<CaptureMut, FnMutRef<i32()>>);
-  static_assert(!sus::construct::Into<CaptureMut, FnRef<i32()>>);
-  EXPECT_EQ(2, FnOnceRef<i32()>::from(CaptureMut())());
-  EXPECT_EQ(2, FnMutRef<i32()>::from(CaptureMut())());
-}
-
-TEST(FnRef, CallsCorrectOverload) {
-  static i32 const_calls;
-  static i32 mut_calls;
-  struct S {
-    void operator()() const { const_calls += 1; }
-    void operator()() { mut_calls += 1; }
-  };
-
-  [](FnOnceRef<void()> m) { sus::move(m)(); }(S());
-  EXPECT_EQ(const_calls, 0);
-  EXPECT_EQ(mut_calls, 1);
-
-  [](FnMutRef<void()> m) { m(); }(S());
-  EXPECT_EQ(const_calls, 0);
-  EXPECT_EQ(mut_calls, 2);
-
-  [](FnRef<void()> m) { m(); }(S());
-  EXPECT_EQ(const_calls, 1);
-  EXPECT_EQ(mut_calls, 2);
-
-  // The FnRef is converted to FnMutRef but still calls the const overload.
-  [](FnRef<void()> m) { [](FnMutRef<void()> m) { m(); }(sus::move(m)); }(S());
-  EXPECT_EQ(const_calls, 2);
-  EXPECT_EQ(mut_calls, 2);
-
-  // The FnRef is converted to FnOnceRef but still calls the const overload.
-  [](FnRef<void()> m) {
-    [](FnOnceRef<void()> m) { sus::move(m)(); }(sus::move(m));
-  }(S());
-  EXPECT_EQ(const_calls, 3);
-  EXPECT_EQ(mut_calls, 2);
-}
-
-TEST(FnRef, Clone) {
-  static_assert(sus::mem::Clone<FnRef<i32()>>);
-  auto clones_fn = [](FnRef<i32()> f) {
-    return [](FnOnceRef<i32()> f1) { return sus::move(f1)(); }(f.clone()) +
-           [](FnOnceRef<i32()> f2) { return sus::move(f2)(); }(f.clone());
-  };
-  EXPECT_EQ(4, clones_fn([]() { return 2_i32; }));
-
-  static_assert(sus::mem::Clone<FnMutRef<i32()>>);
-  auto clones_fnmut = [](FnMutRef<i32()> f) {
-    return [](FnOnceRef<i32()> f1) { return sus::move(f1)(); }(f.clone()) +
-           [](FnOnceRef<i32()> f2) { return sus::move(f2)(); }(f.clone());
-  };
-  EXPECT_EQ(5, clones_fnmut([i = 1_i32]() mutable {
-              i += 1;
-              return i;
-            }));
-
-  static_assert(!sus::mem::Clone<FnOnceRef<i32()>>);
-}
-
-TEST(FnOnceRef, Split) {
-  // The return type of split() is not Copy or Move
-  static_assert(
-      !::sus::mem::Copy<decltype(std::declval<FnOnceRef<void()>&>().split())>);
-  static_assert(
-      !::sus::mem::Move<decltype(std::declval<FnOnceRef<void()>&>().split())>);
-  // It's only used to build more FnOnceRef objects.
-  static_assert(::sus::construct::Into<
-                decltype(std::declval<FnOnceRef<void()>&>().split()),
-                FnOnceRef<void()>>);
-  // And not FnMutRef or FnRef, as that loses the intention to only call it
-  // once. This is implemented by making the operator() callable as an rvalue
-  // only.
-  static_assert(!::sus::construct::Into<
-                decltype(std::declval<FnOnceRef<void()>&>().split()),
-                FnMutRef<void()>>);
-  static_assert(
-      !::sus::construct::Into<
-          decltype(std::declval<FnOnceRef<void()>&>().split()), FnRef<void()>>);
-
-  // split() as rvalues. First split is run.
-  auto rsplits_fnonce = [](FnOnceRef<i32()> f) {
-    i32 a = [](FnOnceRef<i32()> f) { return sus::move(f)(); }(f.split());
-    i32 b = [](FnOnceRef<i32()>) {
-      // Don't run the `FnOnceRef` as only one of the splits may run the
-      // FnOnceRef.
-      return 0_i32;
-    }(f.split());
-    return a + b;
-  };
-  EXPECT_EQ(2, rsplits_fnonce([i = 1_i32]() mutable {
-              i += 1;
-              return i;
-            }));
-
-  // split() as rvalues. Second split is run.
-  auto rsplits_fnonce2 = [](FnOnceRef<i32()> f) {
-    i32 a = [](FnOnceRef<i32()>) {
-      // Don't run the `FnOnceRef` as only one of the splits may run the
-      // FnOnceRef.
-      return 0_i32;
-    }(f.split());
-    i32 b = [](FnOnceRef<i32()> f) { return sus::move(f)(); }(f.split());
-    return a + b;
-  };
-  EXPECT_EQ(2, rsplits_fnonce([i = 1_i32]() mutable {
-              i += 1;
-              return i;
-            }));
-
-  // split() as lvalues. First split is run.
-  auto lsplits_fnonce = [](FnOnceRef<i32()> f) {
-    auto split = f.split();
-    i32 a = [](FnOnceRef<i32()> f) { return sus::move(f)(); }(f);
-    i32 b = [](FnOnceRef<i32()>) {
-      // Don't run the `FnOnceRef` as only one of the splits may run the
-      // FnOnceRef.
-      return 0_i32;
-    }(f);
-    return a + b;
-  };
-  EXPECT_EQ(2, lsplits_fnonce([i = 1_i32]() mutable {
-              i += 1;
-              return i;
-            }));
-
-  // split() as lvalues. Second split is run.
-  auto lsplits_fnonce2 = [](FnOnceRef<i32()> f) {
-    auto split = f.split();
-    i32 a = [](FnOnceRef<i32()>) {
-      // Don't run the `FnOnceRef` as only one of the splits may run the
-      // FnOnceRef.
-      return 0_i32;
-    }(f);
-    i32 b = [](FnOnceRef<i32()> f) { return sus::move(f)(); }(f);
-    return a + b;
-  };
-  EXPECT_EQ(2, lsplits_fnonce([i = 1_i32]() mutable {
-              i += 1;
-              return i;
-            }));
-}
-
-struct C {
-  i32 method(i32 p) const& { return p + 1; }
-  i32 method(i32 p) & { return p + 2; }
-  i32 method(i32 p) && { return p + 3; }
-
-  i32 simple() const { return 99; }
-};
-
-TEST(FnOnceRef, Methods) {
-  {
-    auto test_simple = [](FnOnceRef<i32(const C&)> y) {
-      const C c;
-      return call_once(sus::move(y), c);
-    };
-    EXPECT_EQ(test_simple(&C::simple), 99);
-  }
-  {
-    auto test_simple = [](FnOnceRef<i32(C&)> y) {
-      C c;
-      return call_once(sus::move(y), c);
-    };
-    EXPECT_EQ(test_simple(&C::simple), 99);
-  }
-  {
-    auto test_simple = [](FnOnceRef<i32(C&&)> y) {
-      return call_once(sus::move(y), C());
-    };
-    EXPECT_EQ(test_simple(&C::simple), 99);
-  }
-
-  // Overloaded methods.
-  {
-    auto test_const = [](FnOnceRef<i32(const C&, i32)> y) {
-      return call_once(sus::move(y), C(), 10_i32);
-    };
-    EXPECT_EQ(  //
-        test_const(static_cast<i32 (C::*)(i32) const&>(&C::method)), 10 + 1);
-
-    auto test_mut = [](FnOnceRef<i32(C&, i32)> y) {
-      C c;
-      return call_once(sus::move(y), c, 10_i32);
-    };
-    EXPECT_EQ(  //
-        test_mut(static_cast<i32 (C::*)(i32)&>(&C::method)), 10 + 2);
-
-    auto test_rvalue = [](FnOnceRef<i32(C&&, i32)> y) {
-      C c;
-      return call_once(sus::move(y), sus::move(c), 10_i32);
-    };
-    EXPECT_EQ(  //
-        test_rvalue(static_cast<i32 (C::*)(i32) &&>(&C::method)), 10 + 3);
-  }
-}
-
-TEST(FnMutRef, Methods) {
-  {
-    auto test_simple = [](FnMutRef<i32(const C&)> y) {
-      const C c;
-      return call_mut(y, c);
-    };
-    EXPECT_EQ(test_simple(&C::simple), 99);
-  }
-  {
-    auto test_simple = [](FnMutRef<i32(C&)> y) {
-      C c;
-      return call_mut(y, c);
-    };
-    EXPECT_EQ(test_simple(&C::simple), 99);
-  }
-  {
-    auto test_simple = [](FnMutRef<i32(C&&)> y) { return call_mut(y, C()); };
-    EXPECT_EQ(test_simple(&C::simple), 99);
-  }
-
-  // Overloaded methods.
-  {
-    auto test_const = [](FnMutRef<i32(const C&, i32)> y) {
-      return call_mut(y, C(), 10_i32);
-    };
-    EXPECT_EQ(  //
-        test_const(static_cast<i32 (C::*)(i32) const&>(&C::method)), 10 + 1);
-
-    auto test_mut = [](FnMutRef<i32(C&, i32)> y) {
-      C c;
-      return call_mut(y, c, 10_i32);
-    };
-    EXPECT_EQ(  //
-        test_mut(static_cast<i32 (C::*)(i32)&>(&C::method)), 10 + 2);
-
-    auto test_rvalue = [](FnMutRef<i32(C&&, i32)> y) {
-      C c;
-      return call_mut(y, sus::move(c), 10_i32);
-    };
-    EXPECT_EQ(  //
-        test_rvalue(static_cast<i32 (C::*)(i32) &&>(&C::method)), 10 + 3);
-  }
-}
-
-TEST(FnRef, Methods) {
-  {
-    auto test_simple = [](FnRef<i32(const C&)> y) {
-      const C c;
-      return call(y, c);
-    };
-    EXPECT_EQ(test_simple(&C::simple), 99);
-  }
-  {
-    auto test_simple = [](FnRef<i32(C&)> y) {
-      C c;
-      return call(y, c);
-    };
-    EXPECT_EQ(test_simple(&C::simple), 99);
-  }
-  {
-    auto test_simple = [](FnRef<i32(C&&)> y) { return call(y, C()); };
-    EXPECT_EQ(test_simple(&C::simple), 99);
-  }
-
-  // Overloaded methods.
-  {
-    auto test_const = [](FnRef<i32(const C&, i32)> y) {
-      return call(y, C(), 10_i32);
-    };
-    EXPECT_EQ(  //
-        test_const(static_cast<i32 (C::*)(i32) const&>(&C::method)), 10 + 1);
-
-    auto test_mut = [](FnRef<i32(C&, i32)> y) {
-      C c;
-      return call(y, c, 10_i32);
-    };
-    EXPECT_EQ(  //
-        test_mut(static_cast<i32 (C::*)(i32)&>(&C::method)), 10 + 2);
-
-    auto test_rvalue = [](FnRef<i32(C&&, i32)> y) {
-      C c;
-      return call(y, sus::move(c), 10_i32);
-    };
-    EXPECT_EQ(  //
-        test_rvalue(static_cast<i32 (C::*)(i32) &&>(&C::method)), 10 + 3);
-  }
-}
-
-}  // namespace
diff --git a/sus/iter/__private/iter_compare.h b/sus/iter/__private/iter_compare.h
index e466ff3c2..fd287d47c 100644
--- a/sus/iter/__private/iter_compare.h
+++ b/sus/iter/__private/iter_compare.h
@@ -16,6 +16,7 @@
 
 #include "sus/fn/fn_concepts.h"
 #include "sus/iter/iterator_concept.h"
+#include "sus/option/option.h"
 
 namespace sus::iter::__private {
 
diff --git a/sus/iter/adaptors/filter.h b/sus/iter/adaptors/filter.h
index 0c56dccb1..9a310157f 100644
--- a/sus/iter/adaptors/filter.h
+++ b/sus/iter/adaptors/filter.h
@@ -16,7 +16,7 @@
 // IWYU pragma: friend "sus/.*"
 #pragma once
 
-#include "sus/fn/fn_box_defn.h"
+#include "sus/fn/fn_concepts.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/mem/move.h"
 #include "sus/mem/relocate.h"
diff --git a/sus/iter/adaptors/filter_map.h b/sus/iter/adaptors/filter_map.h
index e60d4310e..f92b800b2 100644
--- a/sus/iter/adaptors/filter_map.h
+++ b/sus/iter/adaptors/filter_map.h
@@ -16,7 +16,7 @@
 // IWYU pragma: friend "sus/.*"
 #pragma once
 
-#include "sus/fn/fn_box_defn.h"
+#include "sus/fn/fn_concepts.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/mem/move.h"
 #include "sus/mem/relocate.h"
diff --git a/sus/iter/adaptors/flat_map.h b/sus/iter/adaptors/flat_map.h
index 55b5eae12..db25351fd 100644
--- a/sus/iter/adaptors/flat_map.h
+++ b/sus/iter/adaptors/flat_map.h
@@ -16,7 +16,7 @@
 // IWYU pragma: friend "sus/.*"
 #pragma once
 
-#include "sus/fn/fn_box_defn.h"
+#include "sus/fn/fn_concepts.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/mem/move.h"
 #include "sus/mem/relocate.h"
diff --git a/sus/iter/adaptors/fuse.h b/sus/iter/adaptors/fuse.h
index 66e2f8c40..c74b88c97 100644
--- a/sus/iter/adaptors/fuse.h
+++ b/sus/iter/adaptors/fuse.h
@@ -16,7 +16,7 @@
 // IWYU pragma: friend "sus/.*"
 #pragma once
 
-#include "sus/fn/fn_box_defn.h"
+#include "sus/fn/fn_concepts.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/mem/move.h"
 #include "sus/mem/relocate.h"
diff --git a/sus/iter/adaptors/inspect.h b/sus/iter/adaptors/inspect.h
index c6a04a953..f4be59ab2 100644
--- a/sus/iter/adaptors/inspect.h
+++ b/sus/iter/adaptors/inspect.h
@@ -16,7 +16,7 @@
 // IWYU pragma: friend "sus/.*"
 #pragma once
 
-#include "sus/fn/fn_box_defn.h"
+#include "sus/fn/fn_concepts.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/mem/move.h"
 #include "sus/mem/relocate.h"
diff --git a/sus/iter/adaptors/map.h b/sus/iter/adaptors/map.h
index aad8b8be8..e297e78b6 100644
--- a/sus/iter/adaptors/map.h
+++ b/sus/iter/adaptors/map.h
@@ -16,7 +16,7 @@
 // IWYU pragma: friend "sus/.*"
 #pragma once
 
-#include "sus/fn/fn_box_defn.h"
+#include "sus/fn/fn_concepts.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/mem/move.h"
 #include "sus/mem/relocate.h"
diff --git a/sus/iter/adaptors/map_while.h b/sus/iter/adaptors/map_while.h
index d175a0787..e3088d3d4 100644
--- a/sus/iter/adaptors/map_while.h
+++ b/sus/iter/adaptors/map_while.h
@@ -16,7 +16,7 @@
 // IWYU pragma: friend "sus/.*"
 #pragma once
 
-#include "sus/fn/fn_box_defn.h"
+#include "sus/fn/fn_concepts.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/mem/move.h"
 #include "sus/mem/relocate.h"
diff --git a/sus/iter/adaptors/reverse.h b/sus/iter/adaptors/reverse.h
index 30bc4256f..a21859c19 100644
--- a/sus/iter/adaptors/reverse.h
+++ b/sus/iter/adaptors/reverse.h
@@ -16,7 +16,7 @@
 // IWYU pragma: friend "sus/.*"
 #pragma once
 
-#include "sus/fn/fn_box_defn.h"
+#include "sus/fn/fn_concepts.h"
 #include "sus/iter/iterator_concept.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/mem/move.h"
diff --git a/sus/iter/adaptors/scan.h b/sus/iter/adaptors/scan.h
index 2bf791ea3..5e1f4c717 100644
--- a/sus/iter/adaptors/scan.h
+++ b/sus/iter/adaptors/scan.h
@@ -16,7 +16,7 @@
 // IWYU pragma: friend "sus/.*"
 #pragma once
 
-#include "sus/fn/fn_box_defn.h"
+#include "sus/fn/fn_concepts.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/mem/move.h"
 #include "sus/mem/relocate.h"
diff --git a/sus/iter/adaptors/skip_while.h b/sus/iter/adaptors/skip_while.h
index a8f660d6e..aea9dadf6 100644
--- a/sus/iter/adaptors/skip_while.h
+++ b/sus/iter/adaptors/skip_while.h
@@ -16,7 +16,7 @@
 // IWYU pragma: friend "sus/.*"
 #pragma once
 
-#include "sus/fn/fn_box_defn.h"
+#include "sus/fn/fn_concepts.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/mem/move.h"
 #include "sus/mem/relocate.h"
diff --git a/sus/iter/once_with.h b/sus/iter/once_with.h
index e4fe09eda..f92511e6c 100644
--- a/sus/iter/once_with.h
+++ b/sus/iter/once_with.h
@@ -14,7 +14,7 @@
 
 #pragma once
 
-#include "sus/fn/fn_box_defn.h"
+#include "sus/fn/fn_concepts.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/mem/move.h"
 #include "sus/mem/relocate.h"
diff --git a/sus/iter/repeat_with.h b/sus/iter/repeat_with.h
index 5b12b9e51..23f49c714 100644
--- a/sus/iter/repeat_with.h
+++ b/sus/iter/repeat_with.h
@@ -14,7 +14,7 @@
 
 #pragma once
 
-#include "sus/fn/fn_box_defn.h"
+#include "sus/fn/fn_concepts.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/mem/move.h"
 #include "sus/mem/relocate.h"
diff --git a/sus/iter/successors.h b/sus/iter/successors.h
index d9ff3455f..9ca89e28b 100644
--- a/sus/iter/successors.h
+++ b/sus/iter/successors.h
@@ -14,7 +14,7 @@
 
 #pragma once
 
-#include "sus/fn/fn_box_defn.h"
+#include "sus/fn/fn_concepts.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/mem/move.h"
 #include "sus/mem/relocate.h"
diff --git a/sus/ops/ord.h b/sus/ops/ord.h
index 0cc0bbba2..0fc95a285 100644
--- a/sus/ops/ord.h
+++ b/sus/ops/ord.h
@@ -21,7 +21,6 @@
 
 #include "sus/assertions/check.h"
 #include "sus/fn/fn_concepts.h"
-#include "sus/fn/fn_ref.h"
 #include "sus/macros/lifetimebound.h"
 #include "sus/mem/forward.h"
 
diff --git a/sus/result/result.h b/sus/result/result.h
index c795c805e..ef115deb9 100644
--- a/sus/result/result.h
+++ b/sus/result/result.h
@@ -23,7 +23,7 @@
 #include "fmt/format.h"
 #include "sus/assertions/check.h"
 #include "sus/assertions/unreachable.h"
-#include "sus/fn/fn_ref.h"
+#include "sus/fn/fn_concepts.h"
 #include "sus/iter/into_iterator.h"
 #include "sus/iter/iterator_defn.h"
 #include "sus/iter/once.h"

From 5c47bd0c46a9b7421626934261c140404c1b28ae Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 20:27:16 -0400
Subject: [PATCH 30/31] Provide a way to construct a Box<T> for non-Move T

Box::with_args() will pass the args to the ctor of T to construct
it directly on the heap.
---
 sus/boxed/box.h           | 22 ++++++++++++++++-
 sus/boxed/box_unittest.cc | 18 ++++++++++++++
 sus/boxed/dyn.h           | 50 +++++++++++++++++++++++++++++++++++++++
 sus/boxed/dyn_unittest.cc | 26 ++++++++++++++++++++
 4 files changed, 115 insertions(+), 1 deletion(-)

diff --git a/sus/boxed/box.h b/sus/boxed/box.h
index e27664570..16e6b001c 100644
--- a/sus/boxed/box.h
+++ b/sus/boxed/box.h
@@ -52,7 +52,11 @@ namespace sus::boxed {
 /// * Const correctness. A `const Box` treats the inner object as `const` and
 ///   does not expose mutable access to it.
 /// * Never null. A `Box` always holds a value until it is moved-from. It is
-///   constructed from a value, not a pointer.
+///   constructed from a value, not a pointer. Alternatively it can be
+///   constructed from the constructor arguments by
+///   [`with_args`]($sus::boxed::Box::with_args), like [`std::make_unique`](
+///   https://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique)
+///   but built into the type.
 ///   A moved-from `Box` may not be used except to be assigned to or destroyed.
 ///   Using a moved-from `Box` will [`panic`]($sus::assertions::panic) and
 ///   terminate the program rather than operate on a null. This prevents
@@ -132,6 +136,22 @@ class [[sus_trivial_abi]] Box final {
     if (t_) delete t_;
   }
 
+  /// Constructs a Box by calling the constructor of `T` with `args`.
+  ///
+  /// This allows construction of `T` directly on the heap, which is required
+  /// for types which do not satisfy [`Move`]($sus::mem::Move). This is a common
+  /// case for virtual clases which require themselves to be heap allocated.
+  ///
+  /// For type-erasure of concept objects using [`DynConcept`](
+  /// $sus::boxed::DynConcept), such as [`DynError`]($sus::error::DynError),
+  /// the [`from`]($sus::boxed::Box::from!dync) constructor method
+  /// can be used to type erase the concept object and move it to the heap.
+  template <class... Args>
+    requires(std::constructible_from<T, Args && ...>)
+  constexpr static Box with_args(Args&&... args) noexcept {
+    return Box(FROM_POINTER, new T(::sus::forward<Args>(args)...));
+  }
+
   /// Converts `U` into a [`Box<T>`]($sus::boxed::Box).
   ///
   /// The conversion allocates on the heap and moves `u` into it.
diff --git a/sus/boxed/box_unittest.cc b/sus/boxed/box_unittest.cc
index 4c9715504..07953d21a 100644
--- a/sus/boxed/box_unittest.cc
+++ b/sus/boxed/box_unittest.cc
@@ -62,6 +62,24 @@ TEST(Box, Construct) {
   }
 }
 
+TEST(Box, WithArgs) {
+  struct NoMove {
+    NoMove(i32 i) : i(i) {}
+
+    NoMove(NoMove&&) = delete;
+    NoMove& operator=(NoMove&&) = delete;
+
+    i32 i;
+  };
+  static_assert(!sus::mem::Move<NoMove>);
+
+  auto b = Box<NoMove>::with_args(3);
+  EXPECT_EQ(b->i, 3);
+
+  auto b2 = sus::move(b);
+  EXPECT_EQ(b2->i, 3);
+}
+
 TEST(Box, FromT) {
   i32 i = 3;
   {
diff --git a/sus/boxed/dyn.h b/sus/boxed/dyn.h
index a81472ded..f6f3dc973 100644
--- a/sus/boxed/dyn.h
+++ b/sus/boxed/dyn.h
@@ -93,6 +93,8 @@ namespace sus::boxed {
 ///
 /// # Examples
 ///
+/// ## Implementing concept type-erasure
+///
 /// Providing the mechanism to type erase objects that satisfy a concept named
 /// `MyConcept` through a `DynMyConcept` class:
 /// ```
@@ -205,6 +207,54 @@ namespace sus::boxed {
 ///   d(sus::dyn<const DynMyConcept>(MyConceptType()));
 /// }
 /// ```
+///
+/// ## Holding dyn() in a stack variable
+///
+/// When a function receives a type-erased `DynC&` by reference, it allows the
+/// caller to avoid heap allocations should they wish. In the easy case, the
+/// caller will simply call `sus::dyn()` directly in the function arguments to
+/// construct the `DynC&` reference, which ensures it outlives the function
+/// call.
+///
+/// In a more complicated scenario, the caller may wish to conditionally decide
+/// to pass an Option<DynC&> with or without a reference, or to choose between
+/// different references. It is not possible to return the result of
+/// `sus::dyn()` without creating a dangling stack reference, which will be
+/// caught by clang in most cases. This means in particular that lambdas such
+/// as those passed to functions like [`Option::map`]($sus::option::Option::map)
+/// can not be used to construct the `DynC&` reference.
+///
+/// In order to ensure the target of the `DynC&` reference outlives the function
+/// it can be constructed as a stack variable before calling the function.
+/// ```
+/// std::srand(sus::mog<unsigned>(std::time(nullptr)));
+///
+/// auto x = [](sus::Option<sus::fn::DynFn<std::string()>&> fn) {
+///   if (fn.is_some())
+///     return sus::move(fn).unwrap()();
+///   else
+///     return std::string("tails");
+/// };
+///
+/// auto heads = [] { return std::string("heads"); };
+/// // Type-erased `Fn<std::string()>` that represents `heads`. Placed on the
+/// // stack to outlive its use in the `Option` and the call to `x(cb)`.
+/// auto dyn_heads = sus::dyn<sus::fn::DynFn<std::string()>>(heads);
+/// // Conditionally holds a type-erased reference to `heads`. This requires a
+/// // type-erasure that outlives the `cb` variable.
+/// auto cb = [&]() -> sus::Option<sus::fn::DynFn<std::string()>&> {
+///   if (std::rand() % 2) return sus::some(dyn_heads);
+///   return sus::none();
+/// }();
+///
+/// std::string s = x(cb);
+///
+/// fmt::println("{}", s);  // Prints one of "heads" or "tails.
+/// ```
+/// It can greatly simplify correctness of code to use owned type-erased
+/// concept objects through [`Box`]($sus::boxed::Box), such as
+/// `Box<DynFn<std::string()>>` in the above example. Though references can be
+/// useful, especially in simple or perf-critical code paths.
 template <class DynC, class ConcreteT>
 concept DynConcept = requires {
   // The types are not qualified or references.
diff --git a/sus/boxed/dyn_unittest.cc b/sus/boxed/dyn_unittest.cc
index a0f436243..b3b6773eb 100644
--- a/sus/boxed/dyn_unittest.cc
+++ b/sus/boxed/dyn_unittest.cc
@@ -338,4 +338,30 @@ TEST(Dyn, Example_Macro) {
 
 }  // namespace example_macro
 
+TEST(Dyn, Example_Stack) {
+  std::srand(sus::mog<unsigned>(std::time(nullptr)));
+
+  auto x = [](sus::Option<sus::fn::DynFn<std::string()>&> fn) {
+    if (fn.is_some())
+      return sus::move(fn).unwrap()();
+    else
+      return std::string("tails");
+  };
+
+  auto heads = [] { return std::string("heads"); };
+  // Type-erased `Fn<std::string()>` that represents `heads`. Placed on the
+  // stack to outlive its use in the `Option` and the call to `x(cb)`.
+  auto dyn_heads = sus::dyn<sus::fn::DynFn<std::string()>>(heads);
+  // Conditionally holds a type-erased reference to `heads`. This requires a
+  // type-erasure that outlives the `cb` variable.
+  auto cb = [&]() -> sus::Option<sus::fn::DynFn<std::string()>&> {
+    if (std::rand() % 2) return sus::some(dyn_heads);
+    return sus::none();
+  }();
+
+  std::string s = x(cb);
+
+  fmt::println("{}", s);  // Prints one of "heads" or "tails.
+}
+
 }  // namespace

From 6cc13f1de0e8161a22f62eb442b737526e53e477 Mon Sep 17 00:00:00 2001
From: Dana Jansens <danakj@chromium.org>
Date: Sun, 10 Sep 2023 21:59:09 -0400
Subject: [PATCH 31/31] Syntax-highlight colourize comments in pre blocks

---
 subdoc/gen_tests/markdown/Syntax.html  | 82 ++++++++++++++++++++++++++
 subdoc/gen_tests/markdown/index.html   | 13 ++++
 subdoc/gen_tests/markdown/test.cc      |  8 +++
 subdoc/gen_tests/subdoc-test-style.css |  3 +
 subdoc/lib/gen/markdown_to_html.cc     | 34 +++++++++++
 5 files changed, 140 insertions(+)
 create mode 100644 subdoc/gen_tests/markdown/Syntax.html

diff --git a/subdoc/gen_tests/markdown/Syntax.html b/subdoc/gen_tests/markdown/Syntax.html
new file mode 100644
index 000000000..7aabe2982
--- /dev/null
+++ b/subdoc/gen_tests/markdown/Syntax.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+
+<head>
+  <meta name="generator" content="subdoc"></meta>
+  <meta name="viewport" content="width=device-width, initial-scale=1"></meta>
+  <meta property="og:type" content="website"></meta>
+  <meta property="og:site_name" content="PROJECT NAME"></meta>
+  <title>Syntax - PROJECT NAME</title>
+  <meta property="og:title" content="Syntax - PROJECT NAME"></meta>
+  <meta name="description" content="A code block with syntax highlighting."></meta>
+  <meta property="og:description" content="A code block with syntax highlighting."></meta>
+  <link rel="stylesheet" href="../subdoc-test-style.css">
+  <link rel="icon" type="image/svg+xml" href="../icon.svg">
+  <link rel="alternate icon" type="image/png" href="../icon.png">
+  <meta property="og:image" content="../icon.svg"></meta>
+</head>
+
+<body>
+  <nav class="topbar">
+    <button class="sidebar-menu-button" onclick="let e = document.getElementsByClassName('sidebar')[0];e.classList.toggle('shown');">
+      ☰
+    </button>
+    <a class="topbar-logo-link" href="index.html"><div class="topbar-logo-border">
+        <img class="topbar-logo" src="PROJECT LOGO.png"></img>
+      </div></a>
+    <span class="topbar-text-area">
+      <span class="topbar-title">
+        <a href="#">Syntax</a>
+      </span>
+    </span>
+  </nav>
+  <nav class="sidebar">
+    <a class="sidebar-logo-link" href="index.html"><div class="sidebar-logo-border">
+        <img class="sidebar-logo" src="PROJECT LOGO.png"></img>
+      </div></a>
+    <div class="sidebar-pretitle sidebar-text">
+      struct
+    </div>
+    <div class="sidebar-title sidebar-text">
+      <a href="#">Syntax</a>
+    </div>
+    <div class="sidebar-subtitle sidebar-text">
+    </div>
+    <div class="sidebar-links sidebar-text">
+      <ul>
+      </ul>
+    </div>
+  </nav>
+  <main>
+    <div class="type record struct">
+      <div class="section overview">
+        <div class="section-header">
+          <span>
+            Struct
+          </span>
+          <a class="project-name" href="index.html">PROJECT NAME</a>
+          <span class="namespace-dots">::</span>
+          <a class="type-name" href="#">Syntax</a>
+        </div>
+        <div class="type-signature">
+          <span class="struct">
+            struct
+          </span>
+          <span class="type-name">
+            Syntax
+          </span>
+          <div class="record-body">
+            { ... };
+          </div>
+        </div>
+        <div class="description long">
+          <p>A code block with syntax highlighting.</p>
+<pre><code>A comment;  <span class="comment">// At the end of the line.</span>
+<span class="comment">// At the start of the line.</span>
+  <span class="comment">// And after some whitespace.</span>
+</code></pre>
+
+        </div>
+      </div>
+    </div>
+  </main>
+</body>
diff --git a/subdoc/gen_tests/markdown/index.html b/subdoc/gen_tests/markdown/index.html
index cf65fd554..e7d7f0e57 100644
--- a/subdoc/gen_tests/markdown/index.html
+++ b/subdoc/gen_tests/markdown/index.html
@@ -52,6 +52,9 @@
         <li>
           <a class="sidebar-item" href="S.html">S</a>
         </li>
+        <li>
+          <a class="sidebar-item" href="Syntax.html">Syntax</a>
+        </li>
       </ul>
     </div>
   </nav>
@@ -91,6 +94,16 @@
               <p>The <code>summary</code> has <b>html tags</b> in it.</p>
             </div>
           </li>
+          <li class="section-item">
+            <div class="item-name">
+              <div class="type-signature">
+                <a class="type-name" href="Syntax.html">Syntax</a>
+              </div>
+            </div>
+            <div class="description short">
+              <p>A code block with syntax highlighting.</p>
+            </div>
+          </li>
         </ul>
       </div>
     </div>
diff --git a/subdoc/gen_tests/markdown/test.cc b/subdoc/gen_tests/markdown/test.cc
index 549f3e47c..c16505663 100644
--- a/subdoc/gen_tests/markdown/test.cc
+++ b/subdoc/gen_tests/markdown/test.cc
@@ -8,3 +8,11 @@ struct S {};
 /// newlines in
 /// it.
 struct N {};
+
+/// A code block with syntax highlighting.
+/// ```
+/// A comment;  // At the end of the line.
+/// // At the start of the line.
+///   // And after some whitespace.
+/// ```
+struct Syntax {};
diff --git a/subdoc/gen_tests/subdoc-test-style.css b/subdoc/gen_tests/subdoc-test-style.css
index 34a3c2575..6687ced58 100644
--- a/subdoc/gen_tests/subdoc-test-style.css
+++ b/subdoc/gen_tests/subdoc-test-style.css
@@ -206,6 +206,9 @@ main {
     color:rgb(230, 230, 230);
     overflow-x: auto;
 }
+pre > code span.comment {
+    color: #3ff9bd;
+}
 
 .section-header {
     font-size: 125%;
diff --git a/subdoc/lib/gen/markdown_to_html.cc b/subdoc/lib/gen/markdown_to_html.cc
index 4f5c7ce8a..32ed410c7 100644
--- a/subdoc/lib/gen/markdown_to_html.cc
+++ b/subdoc/lib/gen/markdown_to_html.cc
@@ -256,6 +256,40 @@ sus::Result<MarkdownToHtml, MarkdownToHtmlError> markdown_to_html(
     }
   }
   std::string str = sus::move(parsed).str();
+  usize pos;
+  while (true) {
+    pos = str.find("<pre>", pos);
+    if (pos == std::string::npos) break;
+    usize end_pos = str.find("</pre>", pos + 5u);
+    if (end_pos == std::string::npos) break;
+
+    while (true) {
+      usize comment_pos = str.find("// ", pos);
+      if (comment_pos == std::string::npos) {
+        pos = str.size();
+        break;
+      }
+      if (comment_pos >= end_pos) {
+        // If we went past </pre> then back up and look for the next <pre>.
+        pos = end_pos + 6u;
+        break;
+      }
+
+      const std::string_view open = "<span class=\"comment\">";
+      const std::string_view close = "</span>";
+
+      str.insert(comment_pos, open);
+      comment_pos += open.size();
+      end_pos += open.size();
+
+      usize eol_pos = str.find("\n", comment_pos);
+      if (eol_pos == std::string::npos) eol_pos = str.size();
+      str.insert(eol_pos, close);
+      eol_pos += close.size();
+      end_pos += close.size();
+      pos = eol_pos;
+    }
+  }
   return sus::ok(MarkdownToHtml{
       .full_html = sus::clone(str),
       .summary_html = summarize_html(str),