Make RangeBounds which is implemented by Range, RangeTo, RangeFrom, RangeFull

danakj · danakj · commit d13fe6569015 · 2023-02-23T23:59:19.000-05:00
Introduce _r literals for writing range literals.
"1..4"_r produces a Range.
"1..=4"_r also does.
"..4"_r produces a RangeTo.
"4.."_r produces a RangeFrom.
".."_r produces a RangeFull.

Slice range methods now take a RangeBounds instead of a Range, allowing
them to operator on ranges with unbounded ends.

Range and RangeFrom are Iterators over the values in their range.

TODO: Need some helper functions to make ranges from dynamic values as
the literals only work with constants (unlike in Rust).
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -14,7 +14,7 @@
         "-compile-commands-dir=out"
     ],
     "cmake.configureSettings": {
-        "CMAKE_MAKE_PROGRAM": "ninja"
+        "CMAKE_MAKE_PROGRAM": "ninja",
     },
     "cmake.generator": "Ninja",
     "files.eol": "\n",
diff --git a/subdoc/lib/gen/files.h b/subdoc/lib/gen/files.h
@@ -72,7 +72,7 @@ inline std::filesystem::path construct_html_file_path_for_namespace(
   // The namespace path includes the namespace element itself, so drop
   // that one.
   sus::Slice<const Namespace> short_namespace_path =
-      element.namespace_path.as_ref()[{1u, element.namespace_path.len()}];
+      element.namespace_path.as_ref()["1.."_r];
 
   std::string file_name = [&]() {
     if (element.namespace_name.which() == Namespace::Tag::Global) {
diff --git a/subdoc/lib/gen/generate_namespace.cc b/subdoc/lib/gen/generate_namespace.cc
@@ -35,7 +35,7 @@ std::string namespace_display_name(const NamespaceElement& element) noexcept {
   // The namespace path includes the namespace we're generating for, so drop
   // that one.
   sus::Slice<const Namespace> short_namespace_path =
-      element.namespace_path.as_ref()[{1u, element.namespace_path.len()}];
+      element.namespace_path.as_ref()["1.."_r];
 
   // For display in the html, we use the full path name of the namespace.
   return namespace_with_path_to_string(short_namespace_path,
diff --git a/subspace/CMakeLists.txt b/subspace/CMakeLists.txt
@@ -114,6 +114,7 @@ target_sources(subspace PUBLIC
     "ops/eq.h"
     "ops/ord.h"
     "ops/range.h"
+    "ops/range_literals.h"
     "result/__private/is_result_type.h"
     "result/__private/marker.h"
     "result/__private/storage.h"
@@ -176,6 +177,7 @@ add_executable(subspace_unittests
     "option/option_types_unittest.cc"
     "ops/eq_unittest.cc"
     "ops/ord_unittest.cc"
+    "ops/range_unittest.cc"
     "result/result_unittest.cc"
     "result/result_types_unittest.cc"
     "tuple/tuple_types_unittest.cc"
diff --git a/subspace/containers/slice.h b/subspace/containers/slice.h
@@ -142,12 +142,14 @@ class Slice {
   /// function will panic.
   /// #[doc.overloads=slice.index.range]
   constexpr inline Slice<T> operator[](
-      const ::sus::ops::Range<usize> range) const noexcept {
-    const usize len = range.end >= range.start ? range.end - range.start : 0u;
+      const ::sus::ops::RangeBounds<usize> auto range) const noexcept {
+    const usize start = range.start_bound().unwrap_or(0u);
+    const usize end = range.end_bound().unwrap_or(len_);
+    const usize len = end >= start ? end - start : 0u;
     ::sus::check(len <= len_);  // Avoid underflow below.
     // We allow start == len_ && end == len_, which returns an empty slice.
-    ::sus::check(range.start <= len_ && range.start <= len_ - len);
-    return Slice(data_ + size_t{range.start}, len);
+    ::sus::check(start <= len_ && start <= len_ - len);
+    return Slice(data_ + size_t{start}, len);
   }
 
   /// Returns a subslice which contains elements in `range`, which specifies a
@@ -161,12 +163,14 @@ class Slice {
   /// Returns None if the Range would otherwise contain an element that is out
   /// of bounds.
   constexpr Option<Slice<T>> get_range(
-      const ::sus::ops::Range<usize> range) const noexcept {
-    const usize len = range.end >= range.start ? range.end - range.start : 0u;
+      const ::sus::ops::RangeBounds<usize> auto range) const noexcept {
+    const usize start = range.start_bound().unwrap_or(0u);
+    const usize end = range.end_bound().unwrap_or(len_);
+    const usize len = end >= start ? end - start : 0u;
     if (len > len_) return sus::none();  // Avoid underflow below.
     // We allow start == len_ && end == len_, which returns an empty slice.
-    if (range.start > len_ || range.start > len_ - len) return sus::none();
-    return sus::some(Slice(data_ + size_t{range.start}, len));
+    if (start > len_ || start > len_ - len) return sus::none();
+    return Option<Slice<T>>::some(Slice(data_ + size_t{start}, len));
   }
 
   /// Returns a subslice which contains elements in `range`, which specifies a
@@ -182,9 +186,11 @@ class Slice {
   /// of bounds of the Slice, which can result in Undefined Behaviour.
   constexpr Slice<T> get_range_unchecked(
       ::sus::marker::UnsafeFnMarker,
-      const ::sus::ops::Range<usize> range) const noexcept {
-    const usize len = range.end >= range.start ? range.end - range.start : 0u;
-    return Slice(data_ + size_t{range.start}, len);
+      const ::sus::ops::RangeBounds<usize> auto range) const noexcept {
+    const usize start = range.start_bound().unwrap_or(0u);
+    const usize end = range.end_bound().unwrap_or(len_);
+    const usize len = end >= start ? end - start : 0u;
+    return Slice(data_ + size_t{start}, len);
   }
 
   /// Sorts the slice.
diff --git a/subspace/containers/slice_unittest.cc b/subspace/containers/slice_unittest.cc
@@ -127,27 +127,27 @@ TEST(Slice, IndexRange) {
   auto sc = Slice<const i32>::from_raw_parts(unsafe_fn, a, 3_usize);
   auto sm = Slice<i32>::from_raw_parts(unsafe_fn, a, 3_usize);
 
-  EXPECT_EQ((sc[{0u, 1u}][0u]), 1_i32);
-  EXPECT_EQ((sc[{0u, 1u}].len()), 1_usize);
-  EXPECT_EQ((sc[{1u, 3u}][1u]), 3_i32);
-  EXPECT_EQ((sc[{1u, 3u}].len()), 2_usize);
+  EXPECT_EQ((sc["0..1"_r][0u]), 1_i32);
+  EXPECT_EQ((sc["0..1"_r].len()), 1_usize);
+  EXPECT_EQ((sc["1..3"_r][1u]), 3_i32);
+  EXPECT_EQ((sc["1..3"_r].len()), 2_usize);
 
-  EXPECT_EQ((sc[{1u, 1u}].len()), 0_usize);
+  EXPECT_EQ((sc["1..1"_r].len()), 0_usize);
   // Start == End == the original End is an empty Slice.
-  EXPECT_EQ((sc[{3u, 3u}].len()), 0_usize);
+  EXPECT_EQ((sc["3..3"_r].len()), 0_usize);
 
-  EXPECT_EQ((sm[{0u, 3u}][0u]), 1_i32);
-  EXPECT_EQ((sm[{0u, 3u}].len()), 3_usize);
-  EXPECT_EQ((sm[{2u, 3u}][0u]), 3_i32);
-  EXPECT_EQ((sm[{2u, 3u}].len()), 1_usize);
+  EXPECT_EQ((sm["0..3"_r][0u]), 1_i32);
+  EXPECT_EQ((sm["0..3"_r].len()), 3_usize);
+  EXPECT_EQ((sm["2..3"_r][0u]), 3_i32);
+  EXPECT_EQ((sm["2..3"_r].len()), 1_usize);
 
-  EXPECT_EQ((sm[{1u, 1u}].len()), 0_usize);
+  EXPECT_EQ((sm["1..1"_r].len()), 0_usize);
   // Start == End == the original End is an empty Slice.
-  EXPECT_EQ((sm[{3u, 3u}].len()), 0_usize);
+  EXPECT_EQ((sm["3..3"_r].len()), 0_usize);
 
   // Rvalue Slices are usable as they are reference types.
-  EXPECT_EQ((sc[{1u, 3u}][{1u, 2u}][0u]), 3_i32);
-  EXPECT_EQ((sm[{1u, 3u}][{1u, 2u}][0u]), 3_i32);
+  EXPECT_EQ((sc["1..3"_r]["1..2"_r][0u]), 3_i32);
+  EXPECT_EQ((sm["1..3"_r]["1..2"_r][0u]), 3_i32);
 }
 
 TEST(SliceDeathTest, IndexRange) {
@@ -156,48 +156,48 @@ TEST(SliceDeathTest, IndexRange) {
   auto sm = Slice<i32>::from_raw_parts(unsafe_fn, a, 3_usize);
 
 #if GTEST_HAS_DEATH_TEST
-  EXPECT_DEATH((sc[{0u, 4u}]), "");
-  EXPECT_DEATH((sc[{3u, 4u}]), "");
-  EXPECT_DEATH((sm[{1u, 4u}]), "");
-  EXPECT_DEATH((sm[{2u, 4u}]), "");
-  EXPECT_DEATH((sm[{4u, 4u}]), "");
+  EXPECT_DEATH((sc["0..4"_r]), "");
+  EXPECT_DEATH((sc["3..4"_r]), "");
+  EXPECT_DEATH((sm["1..4"_r]), "");
+  EXPECT_DEATH((sm["2..4"_r]), "");
+  EXPECT_DEATH((sm["4..4"_r]), "");
 #endif
 }
 
 TEST(Slice, GetRange) {
   i32 a[] = {1, 2, 3};
   auto s = Slice<const i32>::from_raw_parts(unsafe_fn, a, 3_usize);
-  EXPECT_EQ(s.get_range({0u, 3u}).unwrap()[1u], 2_i32);
-  EXPECT_EQ(s.get_range({1u, 3u}).unwrap()[1u], 3_i32);
-  EXPECT_EQ(s.get_range({1u, 4u}), sus::None);
-  EXPECT_EQ(s.get_range({3u, 3u}).unwrap().len(), 0_usize);
-  EXPECT_EQ(s.get_range({4u, 4u}), sus::None);
+  EXPECT_EQ(s.get_range("0..3"_r).unwrap()[1u], 2_i32);
+  EXPECT_EQ(s.get_range("1..3"_r).unwrap()[1u], 3_i32);
+  EXPECT_EQ(s.get_range("1..4"_r), sus::None);
+  EXPECT_EQ(s.get_range("3..3"_r).unwrap().len(), 0_usize);
+  EXPECT_EQ(s.get_range("4..4"_r), sus::None);
 
   auto sm = Slice<i32>::from_raw_parts(unsafe_fn, a, 3_usize);
-  EXPECT_EQ(sm.get_range({0u, 3u}).unwrap()[1u], 2_i32);
-  EXPECT_EQ(sm.get_range({1u, 3u}).unwrap()[1u], 3_i32);
-  EXPECT_EQ(sm.get_range({1u, 4u}), sus::None);
-  EXPECT_EQ(sm.get_range({3u, 3u}).unwrap().len(), 0_usize);
-  EXPECT_EQ(sm.get_range({4u, 4u}), sus::None);
+  EXPECT_EQ(sm.get_range("0..3"_r).unwrap()[1u], 2_i32);
+  EXPECT_EQ(sm.get_range("1..3"_r).unwrap()[1u], 3_i32);
+  EXPECT_EQ(sm.get_range("1..4"_r), sus::None);
+  EXPECT_EQ(sm.get_range("3..3"_r).unwrap().len(), 0_usize);
+  EXPECT_EQ(sm.get_range("4..4"_r), sus::None);
 
   // Rvalue Slices are usable as they are reference types.
-  EXPECT_EQ(s.get_range({3u, 3u}).unwrap().get_range({0u, 0u}).unwrap().len(),
+  EXPECT_EQ(s.get_range("3..3"_r).unwrap().get_range("0..0"_r).unwrap().len(),
             0u);
-  EXPECT_EQ(s.get_range({1u, 3u}).unwrap().get_range({1u, 2u}).unwrap().len(),
+  EXPECT_EQ(s.get_range("1..3"_r).unwrap().get_range("1..2"_r).unwrap().len(),
             1u);
-  EXPECT_EQ(s.get_range({1u, 3u}).unwrap().get_range({1u, 2u}).unwrap()[0u],
+  EXPECT_EQ(s.get_range("1..3"_r).unwrap().get_range("1..2"_r).unwrap()[0u],
             3_i32);
 }
 
 TEST(Slice, GetUncheckedRange) {
   i32 a[] = {1, 2, 3};
   auto s = Slice<const i32>::from_raw_parts(unsafe_fn, a, 3_usize);
-  EXPECT_EQ(s.get_range_unchecked(unsafe_fn, {0u, 2u})[1u], 2_i32);
-  EXPECT_EQ(s.get_range_unchecked(unsafe_fn, {2u, 3u})[0u], 3_i32);
+  EXPECT_EQ(s.get_range_unchecked(unsafe_fn, "0..2"_r)[1u], 2_i32);
+  EXPECT_EQ(s.get_range_unchecked(unsafe_fn, "2..3"_r)[0u], 3_i32);
 
   auto sm = Slice<i32>::from_raw_parts(unsafe_fn, a, 3_usize);
-  EXPECT_EQ(sm.get_range_unchecked(unsafe_fn, {0u, 2u})[1u], 2_i32);
-  EXPECT_EQ(sm.get_range_unchecked(unsafe_fn, {2u, 3u})[0u], 3_i32);
+  EXPECT_EQ(sm.get_range_unchecked(unsafe_fn, "0..2"_r)[1u], 2_i32);
+  EXPECT_EQ(sm.get_range_unchecked(unsafe_fn, "2..3"_r)[0u], 3_i32);
 }
 
 TEST(Slice, Into) {
diff --git a/subspace/containers/vec.h b/subspace/containers/vec.h
@@ -568,6 +568,10 @@ class Vec {
                                            decltype(capacity_));
 };
 
+// Implicit for-ranged loop iteration via `Vec::iter()`.
+using sus::iter::__private::begin;
+using sus::iter::__private::end;
+
 /// Used to construct a Vec<T> with the parameters as its values.
 ///
 /// Calling vec() produces a hint to make a Vec<T> but does not actually
diff --git a/subspace/iter/__private/iterator_loop.h b/subspace/iter/__private/iterator_loop.h
@@ -21,7 +21,7 @@ namespace sus::iter::__private {
 
 /// An adaptor for range-based for loops.
 template <class Iter>
-class IteratorLoop final {
+class [[nodiscard]] IteratorLoop final {
   using Item = typename std::remove_reference_t<Iter>::Item;
 
  public:
diff --git a/subspace/iter/boxed_iterator.h b/subspace/iter/boxed_iterator.h
@@ -36,7 +36,7 @@ class IteratorImpl;
 /// relocatable.
 template <class ItemT, size_t SubclassSize, size_t SubclassAlign,
           bool DoubleEnded>
-class [[sus_trivial_abi]] BoxedIterator final
+class [[nodiscard]] [[sus_trivial_abi]] BoxedIterator final
     : public IteratorImpl<
           BoxedIterator<ItemT, SubclassSize, SubclassAlign, DoubleEnded>,
           ItemT> {
diff --git a/subspace/iter/empty.h b/subspace/iter/empty.h
@@ -21,7 +21,7 @@ namespace sus::iter {
 
 /// An Iterator that never returns an `Item`.
 template <class ItemT>
-class [[sus_trivial_abi]] Empty final
+class [[nodiscard]] [[sus_trivial_abi]] Empty final
     : public IteratorImpl<Empty<ItemT>, ItemT> {
  public:
   using Item = ItemT;
diff --git a/subspace/iter/filter.h b/subspace/iter/filter.h
@@ -25,7 +25,7 @@ namespace sus::iter {
 using ::sus::mem::relocate_by_memcpy;
 
 template <class InnerSizedIter>
-class [[sus_trivial_abi]] Filter final
+class [[nodiscard]] [[sus_trivial_abi]] Filter final
     : public IteratorImpl<Filter<InnerSizedIter>,
                           typename InnerSizedIter::Item> {
   using Pred = ::sus::fn::FnMut<bool(
diff --git a/subspace/iter/iterator_defn.h b/subspace/iter/iterator_defn.h
@@ -119,9 +119,9 @@ class IteratorBase {
 };
 
 template <class Iter, class Item>
-class [[nodiscard]] IteratorImpl : public IteratorBase<Item> {
+class IteratorImpl : public IteratorBase<Item> {
  protected:
-  IteratorImpl() noexcept : IteratorBase<Item>() {
+  constexpr IteratorImpl() noexcept {
     static_assert(std::is_final_v<Iter>,
                   "Iterator implementations must be `final`, as the provided "
                   "methods must know the complete type.");
diff --git a/subspace/iter/map.h b/subspace/iter/map.h
@@ -23,7 +23,7 @@
 namespace sus::iter {
 
 template <class ToItem, class InnerSizedIter>
-class [[sus_trivial_abi]] Map final : public IteratorImpl<Map<ToItem, InnerSizedIter>, ToItem> {
+class [[nodiscard]] [[sus_trivial_abi]] Map final : public IteratorImpl<Map<ToItem, InnerSizedIter>, ToItem> {
   using FromItem = InnerSizedIter::Item;
   using MapFn = ::sus::fn::FnMut<ToItem(FromItem&&)>;
 
diff --git a/subspace/iter/once.h b/subspace/iter/once.h
@@ -24,7 +24,7 @@ using ::sus::option::Option;
 
 /// An Iterator that walks over at most a single Item.
 template <class ItemT>
-class Once final : public IteratorImpl<Once<ItemT>, ItemT> {
+class [[nodiscard]] Once final : public IteratorImpl<Once<ItemT>, ItemT> {
  public:
   using Item = ItemT;
 
diff --git a/subspace/iter/reverse.h b/subspace/iter/reverse.h
@@ -30,7 +30,7 @@ using ::sus::mem::relocate_by_memcpy;
 ///
 /// The iterator wrapped by Reverse must be a DoubleEndedIterator.
 template <class InnerSizedIter>
-class [[sus_trivial_abi]] Reverse final
+class [[nodiscard]] [[sus_trivial_abi]] Reverse final
     : public IteratorImpl<Reverse<InnerSizedIter>,
                           typename InnerSizedIter::Item> {
   static_assert(InnerSizedIter::DoubleEnded);
diff --git a/subspace/mem/never_value.h b/subspace/mem/never_value.h
@@ -139,7 +139,7 @@ concept NeverValueField = __private::NeverValueAccess<T>::has_field;
     static_assert(                                                             \
         std::is_assignable_v<decltype(field_name)&, decltype(never_value)>,    \
         "The `never_value` must be able to be assigned to the named field.");  \
-    return field_name != never_value;                                          \
+    return !(field_name == never_value);                                       \
   }                                                                            \
   constexpr void _sus_Unsafe_NeverValueSetNeverValue(                          \
       ::sus::marker::UnsafeFnMarker) noexcept {                                \
diff --git a/subspace/ops/range.h b/subspace/ops/range.h
diff --git a/subspace/ops/range_literals.h b/subspace/ops/range_literals.h
diff --git a/subspace/ops/range_unittest.cc b/subspace/ops/range_unittest.cc
diff --git a/subspace/prelude.h b/subspace/prelude.h
