Support hiding the Option<T> flag inside the T object.

The Fn, FnMut, and FnOnce types indicate that their enum
state is never 0, and the Option<Fn> is thus the same size
as a Fn.

We add a NonNull<T> which is a never-null T*, and which indicates
that its pointer field is never zero as a result.

Then we implement Option<T&> on top of NonNull<T>.

Author: danakj

CMakeLists.txt

@@ -55,6 +55,7 @@ add_library(subspace STATIC
     "mem/forward.h"
     "mem/move.h"
     "mem/mref.h"
+    "mem/nonnull.h"
     "mem/pass.h"
     "mem/relocate.h"
     "mem/replace.h"
@@ -75,7 +76,9 @@ add_library(subspace STATIC
     "num/num_concepts.h"
     "num/unsigned_integer.h"
     "option/__private/is_option_type.h"
+    "option/__private/storage.h"
     "option/option.h"
+    "option/state.h"
     "result/__private/is_result_type.h"
     "result/result.h"
     "tuple/__private/storage.h"

fn/fn_defn.h

@@ -15,8 +15,10 @@
 #pragma once
 
 #include "fn/callable.h"
-#include "mem/relocate.h"
 #include "mem/forward.h"
+#include "mem/layout.h"
+#include "mem/relocate.h"
+#include "num/types.h"
 
 namespace sus::fn {
 
@@ -50,9 +52,9 @@ enum StorageConstructionFnType { StorageConstructionFn };
 /// heap-allocated storage.
 enum FnType {
   /// Holds a function pointer or captureless lambda.
-  FnPointer,
+  FnPointer = 1,
   /// Holds the type-erased output of sus_bind() in a heap allocation.
-  Storage,
+  Storage = 2,
 };
 
 }  // namespace __private
@@ -208,6 +210,7 @@ class [[sus_trivial_abi]] FnOnce<R(CallArgs...)> {
 
  private:
   sus_class_trivial_relocatable(unsafe_fn);
+  sus_class_nonzero_field(unsafe_fn, FnOnce, type_);
 };
 
 /// A closure that erases the type of the internal callable object (lambda). A

fn/fn_unittest.cc

@@ -20,6 +20,7 @@
 #include "mem/forward.h"
 #include "mem/move.h"
 #include "mem/replace.h"
+#include "option/option.h"
 #include "third_party/googletest/googletest/include/gtest/gtest.h"
 
 namespace {
@@ -67,6 +68,13 @@ SubClass* s_s_function(SubClass* b) { return b; }
 
 // clang-format off
 
+// Fn types all have a non-zero field.
+static_assert(sus::mem::layout::nonzero_field<FnOnce<void()>>::has_field);
+static_assert(sus::mem::layout::nonzero_field<FnMut<void()>>::has_field);
+static_assert(sus::mem::layout::nonzero_field<Fn<void()>>::has_field);
+// Which allows them to not require a flag in Option.
+static_assert(sizeof(sus::Option<FnOnce<void()>>) == sizeof(FnOnce<void()>));
+
 // Closures can not be copied, as their storage is uniquely owned.
 static_assert(!std::is_copy_constructible_v<FnOnce<void()>>);
 static_assert(!std::is_copy_assignable_v<FnOnce<void()>>);

mem/layout.h

@@ -32,10 +32,14 @@ struct layout_nonzero_tag final {
     return true;
   };
 
-  static constexpr bool is_non_zero(const T* t) {
+  static constexpr bool is_non_zero(const T* t)
+  {
     return t->SusUnsafeNonZeroIsNonZero();
   };
-  static constexpr void set_zero(T* t) { t->SusUnsafeNonZeroSetZero(); };
+  static constexpr void set_zero(T* t)
+  {
+    t->SusUnsafeNonZeroSetZero();
+  };
 };
 
 }  // namespace __private
@@ -46,10 +50,14 @@ struct nonzero_field {
       __private::layout_nonzero_tag<T>::has_field(0);
 
   static constexpr bool is_non_zero(::sus::marker::UnsafeFnMarker,
-                                    const T* t) noexcept {
+                                    const T* t) noexcept
+    requires(has_field)
+  {
     return __private::layout_nonzero_tag<T>::is_non_zero(t);
   }
-  static constexpr void set_zero(::sus::marker::UnsafeFnMarker, T* t) noexcept {
+  static constexpr void set_zero(::sus::marker::UnsafeFnMarker, T* t) noexcept
+    requires(has_field)
+  {
     __private::layout_nonzero_tag<T>::set_zero(t);
   }
 };

mem/take.h

@@ -46,4 +46,13 @@ constexpr T take_and_destruct(::sus::marker::UnsafeFnMarker,
   return taken;
 }
 
+template <class T>
+  requires std::is_move_constructible_v<T>
+constexpr T take_and_destruct(::sus::marker::UnsafeFnMarker,
+                              T& t) noexcept {
+  T taken(static_cast<T&&>(t));
+  t.~T();
+  return taken;
+}
+
 }  // namespace sus::mem

option/__private/storage.h

@@ -78,7 +78,7 @@ struct Storage<T, false> final {
     state_ = Some;
   }
 
-  [[nodiscard]] constexpr inline void set_some(T&& t) noexcept {
+  constexpr inline void set_some(T&& t) noexcept {
     if (state_ == None)
       construct_from_none(static_cast<T&&>(t));
     else
@@ -143,6 +143,17 @@ struct Storage<T, true> final {
     new (&val_) T(static_cast<T&&>(t));
   }
 
+  constexpr inline void set_some(T&& t) noexcept {
+    if (state() == None)
+      construct_from_none(static_cast<T&&>(t));
+    else
+      ::sus::mem::replace_and_discard(mref(val_), static_cast<T&&>(t));
+  }
+
+  [[nodiscard]] constexpr inline T replace_some(T&& t) noexcept {
+    return ::sus::mem::replace(mref(val_), static_cast<T&&>(t));
+  }
+
   [[nodiscard]] constexpr inline T take_and_set_none() noexcept {
     T t = take_and_destruct(unsafe_fn, mref(val_));
     ::sus::mem::layout::nonzero_field<T>::set_zero(unsafe_fn, &val_);