Add Option::zip() which returns an Option<Tuple> from 2 Options.

Author: danakj

option/option.h

@@ -21,8 +21,6 @@
 
 // TODO: Clone integration: cloned().
 
-// TODO: Pair/tuple integration: zip().
-
 #pragma once
 
 #include <type_traits>
@@ -51,6 +49,11 @@ template <class T, class E>
 class Result;
 }
 
+namespace sus::tuple {
+template <class T, class... Ts>
+class Tuple;
+}
+
 namespace sus::option {
 
 using sus::iter::Iterator;
@@ -683,6 +686,25 @@ class Option final {
       return Result::with_err(static_cast<ElseFn&&>(f)());
   }
 
+  /// Zips self with another Option.
+  ///
+  /// If self is `Some(s)` and other is `Some(o)`, this method returns `Some((s,
+  /// o))`. Otherwise, `None` is returned.
+  template <class U, int&..., class Tuple = ::sus::tuple::Tuple<T, U>>
+  constexpr inline Option<Tuple> zip(Option<U> o) && noexcept {
+    if (o.is_none()) {
+      if (t_.set_state(None) == Some) t_.val_.~T();
+      return Option<Tuple>::none();
+    } else if (is_none()) {
+      return Option<Tuple>::none();
+    } else {
+      t_.set_state(None);
+      return Option<Tuple>::some(
+          Tuple::with(::sus::mem::take_and_destruct(unsafe_fn, mref(t_.val_)),
+                      static_cast<Option<U>&&>(o).unwrap()));
+    }
+  }
+
   /// Transposes an #Option of a #Result into a #Result of an #Option.
   ///
   /// `None` will be mapped to `Ok(None)`. `Some(Ok(_))` and `Some(Err(_))` will
@@ -1157,6 +1179,24 @@ class Option<T&> final {
       return Result::with_err(static_cast<ElseFn&&>(f)());
   }
 
+  /// Zips self with another Option.
+  ///
+  /// If self is `Some(s)` and other is `Some(o)`, this method returns `Some((s,
+  /// o))`. Otherwise, `None` is returned.
+  template <class U, int&..., class Tuple = ::sus::tuple::Tuple<T&, U>>
+  constexpr inline Option<Tuple> zip(Option<U> o) && noexcept {
+    if (o.is_none()) {
+      t_.ptr_ = nullptr;
+      return Option<Tuple>::none();
+    } else if (is_none()) {
+      return Option<Tuple>::none();
+    } else {
+      return Option<Tuple>::some(
+          Tuple::with(*::sus::mem::replace_ptr(mref(t_.ptr_), nullptr),
+                      static_cast<Option<U>&&>(o).unwrap()));
+    }
+  }
+
   /// Replaces whatever the Option is currently holding with #Some value `t` and
   /// returns an Option holding what was there previously.
   Option replace(T& t) & noexcept {

option/option_unittest.cc

@@ -20,6 +20,7 @@
 #include "iter/iterator.h"
 #include "mem/relocate.h"
 #include "num/types.h"
+#include "tuple/tuple.h"
 #include "result/result.h"
 #include "test/behaviour_types.h"
 #include "third_party/googletest/googletest/include/gtest/gtest.h"
@@ -1603,4 +1604,25 @@ TEST(Option, Transpose) {
   EXPECT_EQ(sus::move(t3).unwrap_err(), -2_i32);
 }
 
+TEST(Option, Zip) {
+  EXPECT_EQ(Option<i32>::none().zip(Option<i32>::none()), None);
+  EXPECT_EQ(Option<i32>::some(1_i32).zip(Option<i32>::none()), None);
+  EXPECT_EQ(Option<i32>::none().zip(Option<i32>::some(1_i32)), None);
+  EXPECT_EQ(Option<i32>::some(2_i32).zip(Option<i32>::some(1_i32)), Some);
+
+  {
+    auto o = Option<i32>::some(-2_i32);
+    EXPECT_EQ(sus::move(o).zip(Option<u8>::some(3_u8)).unwrap(), (sus::Tuple<i32, u8>::with(-2_i32, 3_u8)));
+    EXPECT_EQ(o, None);
+  }
+
+  {
+    auto i = -2_i32;
+    auto u = 3_u8;
+    auto o = Option<const i32&>::some(i);
+    EXPECT_EQ(sus::move(o).zip(Option<const u8&>::some(u)).unwrap(), (sus::Tuple<i32, u8>::with(-2_i32, 3_u8)));
+    EXPECT_EQ(o, None);
+  }
+}
+
 }  // namespace

tuple/tuple.h

@@ -113,6 +113,9 @@ class Tuple final {
   }
 
  private:
+  template <class U, class... Us>
+  friend class Tuple;  // For access to moved_from();
+
   /// Storage for the tuple elements. The first element is the moved-from flag.
   using Storage = __private::TupleStorage<2 + sizeof...(Ts), bool, T, Ts...>;
   /// A helper type used for accessing the `Storage`.