Use lifetimebound and normalize the Array API

get() should return Option<const T&> to match get_mut().

Author: danakj

subspace/choice/choice.h

@@ -27,6 +27,7 @@
 #include "subspace/choice/__private/storage.h"
 #include "subspace/choice/__private/type_list.h"
 #include "subspace/choice/choice_types.h"
+#include "subspace/macros/lifetimebound.h"
 #include "subspace/macros/no_unique_address.h"
 #include "subspace/marker/unsafe.h"
 #include "subspace/mem/clone.h"
@@ -614,7 +615,7 @@ class Choice<__private::TypeList<Ts...>, Tags...> final {
 /// types is not known here.
 template <auto Tag, class... Ts>
 [[nodiscard]] inline constexpr auto choice(
-    Ts&&... vs sus_if_clang([[clang::lifetimebound]])) noexcept {
+    Ts&&... vs sus_lifetimebound) noexcept {
   if constexpr (sizeof...(Ts) == 0) {
     return __private::ChoiceMarkerVoid<Tag>();
   } else if constexpr (sizeof...(Ts) == 1) {

subspace/containers/array.h

@@ -26,10 +26,9 @@
 #include "subspace/containers/__private/array_marker.h"
 #include "subspace/containers/__private/slice_iter.h"
 #include "subspace/containers/slice.h"
-#include "subspace/fn/fn_box_defn.h"
 #include "subspace/fn/fn_concepts.h"
 #include "subspace/fn/run_fn.h"
-#include "subspace/macros/compiler.h"
+#include "subspace/macros/lifetimebound.h"
 #include "subspace/marker/unsafe.h"
 #include "subspace/mem/clone.h"
 #include "subspace/mem/copy.h"
@@ -172,17 +171,17 @@ class Array final {
   constexpr usize len() const& noexcept { return N; }
 
   /// Returns a const reference to the element at index `i`.
-  constexpr Option<const T&> at(usize i) const& noexcept
+  constexpr Option<const T&> get(usize i) const& noexcept sus_lifetimebound
     requires(N > 0)
   {
     if (i.primitive_value >= N) [[unlikely]]
       return Option<const T&>::none();
     return Option<const T&>::some(storage_.data_[i.primitive_value]);
   }
-  constexpr Option<const T&> at(usize i) && = delete;
+  constexpr Option<const T&> get(usize i) && = delete;
 
   /// Returns a mutable reference to the element at index `i`.
-  constexpr Option<T&> get_mut(usize i) & noexcept
+  constexpr Option<T&> get_mut(usize i) & noexcept sus_lifetimebound
     requires(N > 0)
   {
     if (i.primitive_value >= N) [[unlikely]]
@@ -195,8 +194,8 @@ class Array final {
   /// # Safety
   /// The index `i` must be inside the bounds of the array or Undefined
   /// Behaviour results.
-  constexpr inline const T& get_unchecked(::sus::marker::UnsafeFnMarker,
-                                          usize i) const& noexcept
+  constexpr inline const T& get_unchecked(
+      ::sus::marker::UnsafeFnMarker, usize i) const& noexcept sus_lifetimebound
     requires(N > 0)
   {
     return storage_.data_[i.primitive_value];
@@ -210,63 +209,64 @@ class Array final {
   /// The index `i` must be inside the bounds of the array or Undefined
   /// Behaviour results.
   constexpr inline T& get_unchecked_mut(::sus::marker::UnsafeFnMarker,
-                                        usize i) & noexcept
+                                        usize i) & noexcept sus_lifetimebound
     requires(N > 0)
   {
     return storage_.data_[i.primitive_value];
   }
 
-  constexpr inline const T& operator[](usize i) const& noexcept {
+  constexpr inline const T& operator[](usize i) const& noexcept
+      sus_lifetimebound {
     check(i.primitive_value < N);
     return storage_.data_[i.primitive_value];
   }
   constexpr inline const T& operator[](usize i) && = delete;
 
-  constexpr inline T& operator[](usize i) & noexcept {
+  constexpr inline T& operator[](usize i) & noexcept sus_lifetimebound {
     check(i.primitive_value < N);
     return storage_.data_[i.primitive_value];
   }
 
   /// Returns a const pointer to the first element in the array.
-  inline const T* as_ptr() const& noexcept
+  inline const T* as_ptr() const& noexcept sus_lifetimebound
     requires(N > 0)
   {
     return storage_.data_;
   }
   const T* as_ptr() && = delete;
 
   /// Returns a mutable pointer to the first element in the array.
-  inline T* as_mut_ptr() & noexcept
+  inline T* as_mut_ptr() & noexcept sus_lifetimebound
     requires(N > 0)
   {
     return storage_.data_;
   }
 
   // Returns a slice that references all the elements of the array as const
   // references.
-  constexpr Slice<const T> as_ref() const& noexcept {
+  constexpr Slice<const T> as_slice() const& noexcept sus_lifetimebound {
     return Slice<const T>::from(storage_.data_);
   }
-  constexpr Slice<const T> as_ref() && = delete;
+  constexpr Slice<const T> as_slice() && = delete;
 
   // Returns a slice that references all the elements of the array as mutable
   // references.
-  constexpr Slice<T> as_mut() & noexcept {
+  constexpr Slice<T> as_mut_slice() & noexcept sus_lifetimebound {
     return Slice<T>::from(storage_.data_);
   }
 
   /// Returns an iterator over all the elements in the array, visited in the
   /// same order they appear in the array. The iterator gives const access to
   /// each element.
-  constexpr SliceIter<const T&> iter() const& noexcept {
+  constexpr SliceIter<const T&> iter() const& noexcept sus_lifetimebound {
     return SliceIter<const T&>::with(storage_.data_, N);
   }
   constexpr SliceIter<const T&> iter() && = delete;
 
   /// Returns an iterator over all the elements in the array, visited in the
   /// same order they appear in the array. The iterator gives mutable access to
   /// each element.
-  constexpr SliceIterMut<T&> iter_mut() & noexcept {
+  constexpr SliceIterMut<T&> iter_mut() & noexcept sus_lifetimebound {
     return SliceIterMut<T&>::with(storage_.data_, N);
   }
 
@@ -331,7 +331,8 @@ class Array final {
   template <class U, size_t... Is>
   constexpr inline auto eq_impl(const Array<U, N>& r,
                                 std::index_sequence<Is...>) const& noexcept {
-    return (... && (at(Is) == r.at(Is)));
+    return (... && (get_unchecked(::sus::marker::unsafe_fn, Is) ==
+                    r.get_unchecked(::sus::marker::unsafe_fn, Is)));
   };
 
   // Using a union ensures that the default constructor doesn't initialize
@@ -350,7 +351,8 @@ namespace __private {
 template <size_t I, class O, class T, class U, size_t N>
 constexpr inline bool array_cmp_impl(O& val, const Array<T, N>& l,
                                      const Array<U, N>& r) noexcept {
-  auto cmp = l.at(I) <=> r.at(I);
+  auto cmp = l.get_unchecked(::sus::marker::unsafe_fn, I) <=>
+             r.get_unchecked(::sus::marker::unsafe_fn, I);
   // Allow downgrading from equal to equivalent, but not the inverse.
   if (cmp != 0) val = cmp;
   // Short circuit by returning true when we find a difference.
@@ -432,7 +434,7 @@ auto get(Array<T, N>&& a) noexcept {
 template <class... Ts>
   requires(sizeof...(Ts) > 0)
 [[nodiscard]] inline constexpr auto array(
-    Ts&&... vs sus_if_clang([[clang::lifetimebound]])) noexcept {
+    Ts&&... vs sus_lifetimebound) noexcept {
   return __private::ArrayMarker<Ts...>(
       ::sus::tuple_type::Tuple<Ts&&...>::with(::sus::forward<Ts>(vs)...));
 }

subspace/containers/array_unittest.cc

@@ -232,14 +232,14 @@ TEST(Array, Get) {
     constexpr auto r = []() constexpr {
       constexpr auto a =
           Array<int, 5>::with_initializer([i = 0]() mutable { return ++i; });
-      return a.at(2_usize).unwrap();
+      return a.get(2_usize).unwrap();
     }();
     static_assert(std::same_as<decltype(r), const int>);
     EXPECT_EQ(3, r);
   }
   {
     auto a = Array<int, 5>::with_initializer([i = 0]() mutable { return ++i; });
-    EXPECT_EQ(3, a.at(2_usize).unwrap());
+    EXPECT_EQ(3, a.get(2_usize).unwrap());
   }
 }
 
@@ -481,18 +481,18 @@ TEST(ArrayDeathTest, Index) {
 #endif
 }
 
-TEST(Array, AsRef) {
+TEST(Array, AsSlice) {
   auto x = [](sus::Slice<const i32>) {};
   const auto ac = Array<i32, 3>::with_value(2);
   auto am = Array<i32, 3>::with_value(2);
-  x(ac.as_ref());
-  x(am.as_ref());
+  x(ac.as_slice());
+  x(am.as_slice());
 }
 
-TEST(Array, AsMut) {
+TEST(Array, AsMutSlice) {
   auto x = [](sus::Slice<i32>) {};
   auto am = Array<i32, 3>::with_value(2);
-  x(am.as_mut());
+  x(am.as_mut_slice());
 }
 
 TEST(Array, Clone) {

subspace/containers/slice_unittest.cc

@@ -427,7 +427,7 @@ TEST(Slice, Sort) {
   );
   // clang-format on
 
-  Slice<Sortable> s = unsorted.as_mut();
+  Slice<Sortable> s = unsorted.as_mut_slice();
   s.sort();
   for (usize i = 0u; i < s.len(); i += 1u) {
     EXPECT_EQ(sorted[i], s[i]);
@@ -460,7 +460,7 @@ TEST(Slice, SortBy) {
   );
   // clang-format on
 
-  Slice<Sortable> s = unsorted.as_mut();
+  Slice<Sortable> s = unsorted.as_mut_slice();
   // Sorts backward.
   s.sort_by([](const auto& a, const auto& b) { return b <=> a; });
   for (usize i = 0u; i < s.len(); i += 1u) {
@@ -472,7 +472,7 @@ TEST(Slice, SortUnstable) {
   sus::Array<i32, 6> unsorted = sus::array(3, 4, 2, 1, 6, 5);
   sus::Array<i32, 6> sorted = sus::array(1, 2, 3, 4, 5, 6);
 
-  Slice<i32> s = unsorted.as_mut();
+  Slice<i32> s = unsorted.as_mut_slice();
   s.sort_unstable();
   for (usize i = 0u; i < s.len(); i += 1u) {
     EXPECT_EQ(sorted[i], s[i]);
@@ -483,7 +483,7 @@ TEST(Slice, SortUnstableBy) {
   sus::Array<i32, 6> unsorted = sus::array(3, 4, 2, 1, 6, 5);
   sus::Array<i32, 6> sorted = sus::array(6, 5, 4, 3, 2, 1);
 
-  Slice<i32> s = unsorted.as_mut();
+  Slice<i32> s = unsorted.as_mut_slice();
   // Sorts backward.
   s.sort_unstable_by([](const auto& a, const auto& b) { return b <=> a; });
   for (usize i = 0u; i < s.len(); i += 1u) {

subspace/containers/vec.h

@@ -27,7 +27,6 @@
 #include "subspace/fn/run_fn.h"
 #include "subspace/iter/from_iterator.h"
 #include "subspace/iter/into_iterator.h"
-#include "subspace/macros/compiler.h"
 #include "subspace/macros/lifetimebound.h"
 #include "subspace/mem/move.h"
 #include "subspace/mem/relocate.h"
@@ -446,8 +445,8 @@ class Vec {
   void sort() { as_mut_slice().sort(); }
 
   /// #[doc.inherit=[n]sus::[n]containers::[r]Slice::[f]sort_by]
-  template <::sus::fn::FnMut<::sus::fn::NonVoid(const T&, const T&)> F,
-            int&..., class R = std::invoke_result_t<F, const T&, const T&>>
+  template <::sus::fn::FnMut<::sus::fn::NonVoid(const T&, const T&)> F, int&...,
+            class R = std::invoke_result_t<F, const T&, const T&>>
     requires(::sus::ops::Ordering<R>)
   void sort_by(F compare) {
     as_mut_slice().sort_by(sus::move(compare));
@@ -457,8 +456,8 @@ class Vec {
   void sort_unstable() { as_mut_slice().sort(); }
 
   /// #[doc.inherit=[n]sus::[n]containers::[r]Slice::[f]sort_unstable_by]
-  template <::sus::fn::FnMut<::sus::fn::NonVoid(const T&, const T&)> F,
-            int&..., class R = std::invoke_result_t<F, const T&, const T&>>
+  template <::sus::fn::FnMut<::sus::fn::NonVoid(const T&, const T&)> F, int&...,
+            class R = std::invoke_result_t<F, const T&, const T&>>
     requires(::sus::ops::Ordering<R>)
   void sort_unstable_by(F compare) {
     as_mut_slice().sort_by(sus::move(compare));
@@ -597,8 +596,7 @@ using sus::iter::__private::end;
 // the result of `sus::vec()` as a function argument or return value.
 template <class... Ts>
   requires(sizeof...(Ts) > 0)
-[[nodiscard]] inline constexpr auto vec(
-    Ts&&... vs sus_if_clang([[clang::lifetimebound]])) noexcept {
+[[nodiscard]] inline constexpr auto vec(Ts&&... vs sus_lifetimebound) noexcept {
   return __private::VecMarker<Ts...>(
       ::sus::tuple_type::Tuple<Ts&&...>::with(::sus::forward<Ts>(vs)...));
 }

subspace/result/result.h

@@ -706,8 +706,7 @@ using sus::iter::__private::end;
 /// construct Result<T, E>. This is to deduce the actual types `T` and `E` when
 /// it is constructed, avoid specifying them both here, and support conversions.
 template <class T>
-[[nodiscard]] inline constexpr auto ok(
-    T&& t sus_if_clang([[clang::lifetimebound]])) noexcept {
+[[nodiscard]] inline constexpr auto ok(T&& t sus_lifetimebound) noexcept {
   return __private::OkMarker<T&&>(::sus::forward<T>(t));
 }
 
@@ -717,8 +716,7 @@ template <class T>
 /// construct Result<T, E>. This is to deduce the actual types `T` and `E` when
 /// it is constructed, avoid specifying them both here, and support conversions.
 template <class E>
-[[nodiscard]] inline constexpr auto err(
-    E&& e sus_if_clang([[clang::lifetimebound]])) noexcept {
+[[nodiscard]] inline constexpr auto err(E&& e sus_lifetimebound) noexcept {
   return __private::ErrMarker<E&&>(::sus::forward<E>(e));
 }
 

subspace/tuple/tuple.h

@@ -20,6 +20,7 @@
 #include "subspace/assertions/check.h"
 #include "subspace/construct/default.h"
 #include "subspace/macros/__private/compiler_bugs.h"
+#include "subspace/macros/lifetimebound.h"
 #include "subspace/macros/no_unique_address.h"
 #include "subspace/mem/clone.h"
 #include "subspace/mem/copy.h"
@@ -74,15 +75,16 @@ class Tuple final {
   ///
   /// The Tuple's contained types must all be #Default, and will be
   /// constructed through that trait.
+  // clang-format off
   inline constexpr Tuple() noexcept
-  //clang-format off
     requires(!((std::is_trivially_default_constructible_v<T> && ... &&
                 std::is_trivially_default_constructible_v<Ts>) &&
-               !(std::is_reference_v<T> || ... || std::is_reference_v<Ts>)) &&
+              !(std::is_reference_v<T> || ... || std::is_reference_v<Ts>)
+             ) &&
              (::sus::construct::Default<T> && ... &&
               ::sus::construct::Default<Ts>))
-  //clang-format on
       : Tuple(T(), Ts()...) {}
+  // clang-format on
 
   Tuple()
     requires((std::is_trivially_default_constructible_v<T> && ... &&
@@ -263,7 +265,7 @@ struct TupleMarker {
 template <class... Ts>
   requires(sizeof...(Ts) > 0)
 [[nodiscard]] inline constexpr auto tuple(
-    Ts&&... vs sus_if_clang([[clang::lifetimebound]])) noexcept {
+    Ts&&... vs sus_lifetimebound) noexcept {
   return __private::TupleMarker<Ts...>(
       ::sus::tuple_type::Tuple<Ts&&...>::with(::sus::forward<Ts>(vs)...));
 }