Add iterator methods to Result

This involved fixing the defn of iter::Once as well.

Author: danakj

iter/once.h

@@ -34,16 +34,24 @@ class [[sus_trivial_abi]] Once : public IteratorBase<Item> {
   Once(Option<Item>&& single) : single_(::sus::move(single)) {}
 
  private:
+  template <class U>
+  friend inline Iterator<Once<U>> once(Option<U>&& single) noexcept
+    requires(std::is_move_constructible_v<U>);
+
+  static Iterator<Once> with_option(Option<Item>&& single) {
+    return Iterator<Once>(static_cast<Option<Item>&&>(single));
+  }
+
   RelocatableStorage<Item> single_;
 
-  sus_class_maybe_trivial_relocatable_types(unsafe_fn, decltype(single_));
+  sus_class_assert_trivial_relocatable_types(unsafe_fn, decltype(single_));
 };
 
 template <class Item>
-inline Once<Item> once(Option<Item>&& single)
+inline Iterator<Once<Item>> once(Option<Item>&& single) noexcept
   requires(std::is_move_constructible_v<Item>)
 {
-  return Once(::sus::move(single));
+  return Once<Item>::with_option(::sus::move(single));
 }
 
 }  // namespace sus::iter

result/result.h

@@ -29,6 +29,7 @@
 
 #include "assertions/check.h"
 #include "assertions/unreachable.h"
+#include "iter/once.h"
 #include "marker/unsafe.h"
 #include "mem/mref.h"
 #include "mem/relocate.h"
@@ -38,6 +39,9 @@
 
 namespace sus::result {
 
+using sus::iter::Iterator;
+using sus::iter::Once;
+
 /// The representation of an Result's state, which can either be #Ok to
 /// represent it has a success value, or #Err for when it is holding an error
 /// value.
@@ -227,7 +231,9 @@ class Result {
     switch (state_) {
       case IsOk:
         switch (state_ = replace(mref(o.state_), IsMoved)) {
-          case IsOk: mem::replace_and_discard(mref(ok_), static_cast<T&&>(o.ok_)); break;
+          case IsOk:
+            mem::replace_and_discard(mref(ok_), static_cast<T&&>(o.ok_));
+            break;
           case IsErr:
             ok_.~T();
             new (&err_) E(static_cast<E&&>(o.err_));
@@ -237,7 +243,9 @@ class Result {
         break;
       case IsErr:
         switch (state_ = replace(mref(o.state_), IsMoved)) {
-          case IsErr: mem::replace_and_discard(mref(err_), static_cast<E&&>(o.err_)); break;
+          case IsErr:
+            mem::replace_and_discard(mref(err_), static_cast<E&&>(o.err_));
+            break;
           case IsOk:
             err_.~T();
             new (&ok_) T(static_cast<T&&>(o.ok_));
@@ -366,6 +374,34 @@ class Result {
     return take_and_destruct(unsafe_fn, mref(err_));
   }
 
+  constexpr Iterator<Once<const T&>> iter() const& noexcept {
+    check(state_ != IsMoved);
+    if (state_ == IsOk)
+      return sus::iter::once(Option<const T&>::some(ok_));
+    else
+      return sus::iter::once(Option<const T&>::none());
+  }
+  Iterator<Once<const T&>> iter() const&& = delete;
+
+  constexpr Iterator<Once<T&>> iter_mut() & noexcept {
+    check(state_ != IsMoved);
+    if (state_ == IsOk)
+      return sus::iter::once(Option<T&>::some(mref(ok_)));
+    else
+      return sus::iter::once(Option<T&>::none());
+  }
+
+  constexpr Iterator<Once<T>> into_iter() && noexcept {
+    check(state_ != IsMoved);
+    if (replace(mref(state_), IsMoved) == IsOk) {
+      return sus::iter::once(
+          Option<T>::some(take_and_destruct(unsafe_fn, mref(ok_))));
+    } else {
+      err_.~E();
+      return sus::iter::once(Option<T>::none());
+    }
+  }
+
  private:
   enum WithOkType { WithOk };
   constexpr inline Result(WithOkType, const T& t) noexcept

result/result_unittest.cc

@@ -22,6 +22,8 @@
 #include "result/result.h"
 
 #include "mem/move.h"
+#include "iter/once.h"
+#include "iter/iterator.h"
 #include "num/types.h"
 #include "third_party/googletest/googletest/include/gtest/gtest.h"
 
@@ -230,4 +232,61 @@ TEST(Result, MoveAfterNonTrivialMove) {
   EXPECT_DEATH([[maybe_unused]] auto r2 = sus::move(r), "");
 }
 
+TEST(Result, Iter) {
+  auto x = Result<i32, u8>::with_err(2_u8);
+  for ([[maybe_unused]] auto i : x.iter()) {
+    ADD_FAILURE();
+  }
+
+  int count = 0;
+  auto y = Result<i32, u8>::with(-4_i32);
+  for (auto& i : y.iter()) {
+    static_assert(std::is_same_v<decltype(i), const i32&>, "");
+    EXPECT_EQ(i, -4_i32);
+    ++count;
+  }
+  EXPECT_EQ(count, 1);
+}
+
+TEST(Result, IterMut) {
+  auto x = Result<i32, u8>::with_err(2_u8);
+  for ([[maybe_unused]] auto i : x.iter_mut()) {
+    ADD_FAILURE();
+  }
+
+  int count = 0;
+  auto y = Result<i32, u8>::with(-3_i32);
+  for (auto& i : y.iter_mut()) {
+    static_assert(std::is_same_v<decltype(i), i32&>, "");
+    EXPECT_EQ(i, -3_i32);
+    i += 1;
+    ++count;
+  }
+  EXPECT_EQ(sus::move(y).unwrap(), -2_i32);
+}
+
+struct MoveOnly {
+  explicit MoveOnly(int i) : i(i) {}
+  MoveOnly(MoveOnly&& o) : i(o.i) {}
+  void operator=(MoveOnly&& o) { i = o.i; }
+
+  int i;
+};
+
+TEST(Result, IntoIter) {
+  auto x = Result<i32, u8>::with_err(2_u8);
+  for ([[maybe_unused]] auto i : x.iter_mut()) {
+    ADD_FAILURE();
+  }
+
+  int count = 0;
+  auto y =  Result<MoveOnly, u8>::with(MoveOnly(-3));
+  for (auto m : sus::move(y).into_iter()) {
+    static_assert(std::is_same_v<decltype(m), MoveOnly>, "");
+    EXPECT_EQ(m.i, -3);
+    ++count;
+  }
+  EXPECT_EQ(count, 1);
+}
+
 }  // namespace