From 5055e6382ccd5df5bef8c8ecc6a2de3efa458633 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Fahller?= <rollbear@users.noreply.github.com>
Date: Mon, 28 May 2018 13:09:43 +0200
Subject: [PATCH 1/2] or_else calls func with error state (#22)

* or_else calls func with error state

* Hopefully worked around C++11 issues with or_else

* or_else with g++-4.8 not supporting const&& overloads
---
 tests/extensions.cpp | 189 +++++++++++++++++++++++++++++++++++++++++++
 tl/expected.hpp      |  59 +++++++++-----
 2 files changed, 229 insertions(+), 19 deletions(-)

diff --git a/tests/extensions.cpp b/tests/extensions.cpp
index 12b21b5..8e1c77f 100644
--- a/tests/extensions.cpp
+++ b/tests/extensions.cpp
@@ -368,6 +368,195 @@ TEST_CASE("And then extensions", "[extensions.and_then]") {
   }
 }
 
+TEST_CASE("or_else", "[extensions.or_else]") {
+  using eptr = std::unique_ptr<int>;
+  auto succeed = [](int a) { return tl::expected<int, int>(21 * 2); };
+  auto succeedptr = [](eptr e) { return tl::expected<int,eptr>(21*2);};
+  auto fail =    [](int a) { return tl::expected<int,int>(tl::unexpect, 17);};
+  auto efail =   [](eptr e) { *e = 17;return tl::expected<int,eptr>(tl::unexpect, std::move(e));};
+  auto failptr = [](eptr e) { return tl::expected<int,eptr>(tl::unexpect, std::move(e));};
+  auto failvoid = [](int) {};
+  auto failvoidptr = [](const eptr&) { /* don't consume */};
+  auto consumeptr = [](eptr) {};
+  auto make_u_int = [](int n) { return std::unique_ptr<int>(new int(n));};
+
+  {
+    tl::expected<int, int> e = 21;
+    auto ret = e.or_else(succeed);
+    REQUIRE(ret);
+    REQUIRE(*ret == 21);
+  }
+
+  {
+    const tl::expected<int, int> e = 21;
+    auto ret = e.or_else(succeed);
+    REQUIRE(ret);
+    REQUIRE(*ret == 21);
+  }
+
+  {
+    tl::expected<int, int> e = 21;
+    auto ret = std::move(e).or_else(succeed);
+    REQUIRE(ret);
+    REQUIRE(*ret == 21);
+  }
+
+  {
+    tl::expected<int, eptr> e = 21;
+    auto ret = std::move(e).or_else(succeedptr);
+    REQUIRE(ret);
+    REQUIRE(*ret == 21);
+  }
+
+  {
+    const tl::expected<int, int> e = 21;
+    auto ret = std::move(e).or_else(succeed);
+    REQUIRE(ret);
+    REQUIRE(*ret == 21);
+  }
+
+  {
+    tl::expected<int, int> e = 21;
+    auto ret = e.or_else(fail);
+    REQUIRE(ret);
+    REQUIRE(*ret == 21);
+  }
+
+  {
+    const tl::expected<int, int> e = 21;
+    auto ret = e.or_else(fail);
+    REQUIRE(ret);
+    REQUIRE(*ret == 21);
+  }
+
+  {
+    tl::expected<int, int> e = 21;
+    auto ret = std::move(e).or_else(fail);
+    REQUIRE(ret);
+    REQUIRE(ret == 21);
+  }
+
+
+  {
+    tl::expected<int, eptr> e = 21;
+    auto ret = std::move(e).or_else(efail);
+    REQUIRE(ret);
+    REQUIRE(ret == 21);
+  }
+
+  {
+    const tl::expected<int, int> e = 21;
+    auto ret = std::move(e).or_else(fail);
+    REQUIRE(ret);
+    REQUIRE(*ret == 21);
+  }
+
+  {
+    tl::expected<int, int> e(tl::unexpect, 21);
+    auto ret = e.or_else(succeed);
+    REQUIRE(ret);
+    REQUIRE(*ret == 42);
+  }
+
+  {
+    const tl::expected<int, int> e(tl::unexpect, 21);
+    auto ret = e.or_else(succeed);
+    REQUIRE(ret);
+    REQUIRE(*ret == 42);
+  }
+
+  {
+    tl::expected<int, int> e(tl::unexpect, 21);
+    auto ret = std::move(e).or_else(succeed);
+    REQUIRE(ret);
+    REQUIRE(*ret == 42);
+  }
+
+  {
+    tl::expected<int, eptr> e(tl::unexpect, make_u_int(21));
+    auto ret = std::move(e).or_else(succeedptr);
+    REQUIRE(ret);
+    REQUIRE(*ret == 42);
+  }
+
+  {
+    const tl::expected<int, int> e(tl::unexpect, 21);
+    auto ret = std::move(e).or_else(succeed);
+    REQUIRE(ret);
+    REQUIRE(*ret == 42);
+  }
+
+  {
+    tl::expected<int, int> e(tl::unexpect, 21);
+    auto ret = e.or_else(fail);
+    REQUIRE(!ret);
+    REQUIRE(ret.error() == 17);
+  }
+
+  {
+    tl::expected<int, int> e(tl::unexpect, 21);
+    auto ret = e.or_else(failvoid);
+    REQUIRE(!ret);
+    REQUIRE(ret.error() == 21);
+  }
+
+  {
+    const tl::expected<int, int> e(tl::unexpect, 21);
+    auto ret = e.or_else(fail);
+    REQUIRE(!ret);
+    REQUIRE(ret.error() == 17);
+  }
+
+  {
+    const tl::expected<int, int> e(tl::unexpect, 21);
+    auto ret = e.or_else(failvoid);
+    REQUIRE(!ret);
+    REQUIRE(ret.error() == 21);
+  }
+
+  {
+    tl::expected<int, int> e(tl::unexpect, 21);
+    auto ret = std::move(e).or_else(fail);
+    REQUIRE(!ret);
+    REQUIRE(ret.error() == 17);
+  }
+
+  {
+    tl::expected<int, int> e(tl::unexpect, 21);
+    auto ret = std::move(e).or_else(failvoid);
+    REQUIRE(!ret);
+    REQUIRE(ret.error() == 21);
+  }
+
+  {
+    tl::expected<int, eptr> e(tl::unexpect, make_u_int(21));
+    auto ret = std::move(e).or_else(failvoidptr);
+    REQUIRE(!ret);
+    REQUIRE(*ret.error() == 21);
+  }
+
+  {
+    tl::expected<int, eptr> e(tl::unexpect, make_u_int(21));
+    auto ret = std::move(e).or_else(consumeptr);
+    REQUIRE(!ret);
+    REQUIRE(ret.error() == nullptr);
+  }
+
+  {
+    const tl::expected<int, int> e(tl::unexpect, 21);
+    auto ret = std::move(e).or_else(fail);
+    REQUIRE(!ret);
+    REQUIRE(ret.error() == 17);
+  }
+
+  {
+    const tl::expected<int, int> e(tl::unexpect, 21);
+    auto ret = std::move(e).or_else(failvoid);
+    REQUIRE(!ret);
+    REQUIRE(ret.error() == 21);
+  }
+
+}
 struct S {
     int x;
 };
diff --git a/tl/expected.hpp b/tl/expected.hpp
index f8d2ec2..5052c81 100644
--- a/tl/expected.hpp
+++ b/tl/expected.hpp
@@ -1369,11 +1369,11 @@ public:
 #endif
 
   /// \brief Calls `f` if the expectd is in the unexpected state
-  /// \requires `std::invoke_result_t<F>` must be void or convertible to
-  /// `expcted<T,E>`.
+  /// \requires `F` is invokable with `E`, and `std::invoke_result_t<F>`
+  /// must be void or convertible to `expcted<T,E>`.
   /// \effects If `*this` has a value, returns `*this`.
-  /// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns
-  /// `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
+  /// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)(E)` and returns
+  /// `std::nullopt`. Otherwise, returns `std::forward<F>(f)(E)`.
   ///
   /// \group or_else
   template <class F> expected TL_EXPECTED_11_CONSTEXPR or_else(F &&f) & {
@@ -1388,10 +1388,11 @@ public:
     return or_else_impl(*this, std::forward<F>(f));
   }
 
+#ifndef TL_EXPECTED_NO_CONSTRR
   template <class F> expected constexpr or_else(F &&f) const && {
     return or_else_impl(std::move(*this), std::forward<F>(f));
   }
-
+#endif
   constexpr expected() = default;
   constexpr expected(const expected &rhs) = default;
   constexpr expected(expected &&rhs) = default;
@@ -2009,31 +2010,51 @@ auto map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, monostate> {
 }
 #endif
 
+#ifdef TL_EXPECTED_CXX14
 template <class Exp, class F,
           class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Exp>())),
+                                              std::declval<Exp>().error())),
           detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr detail::decay_t<Exp> or_else_impl(Exp &&exp, F &&f) {
-  if (exp.has_value()) {
-    return std::forward<Exp>(exp);
-  }
-
-  return detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp));
+constexpr auto or_else_impl(Exp &&exp, F &&f) {
+  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
+  return exp.has_value()
+  ? std::forward<Exp>(exp)
+  : detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
 }
 
 template <class Exp, class F,
           class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Exp>())),
+                                              std::declval<Exp>().error())),
           detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
 detail::decay_t<Exp> or_else_impl(Exp &&exp, F &&f) {
-  if (exp.has_value()) {
-    return std::forward<Exp>(exp);
-  }
-
-  detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp));
-  return std::forward<Exp>(exp);
+  return exp.has_value()
+  ? std::forward<Exp>(exp)
+  : (detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error()),
+    std::forward<Exp>(exp));
+}
+#else
+template <class Exp, class F,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              std::declval<Exp>().error())),
+  detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+auto or_else_impl(Exp &&exp, F &&f) -> Ret {
+  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
+  return exp.has_value()
+         ? std::forward<Exp>(exp)
+         : detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
 }
 
+template <class Exp, class F,
+          class Ret = decltype(detail::invoke(std::declval<F>(),
+                                              std::declval<Exp>().error())),
+  detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+detail::decay_t<Exp> or_else_impl(Exp &&exp, F &&f) {
+  return exp.has_value()
+         ? std::forward<Exp>(exp)
+         : (detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error()),
+            std::forward<Exp>(exp));
+}
+#endif
 } // namespace detail
 
 template <class T, class E, class U, class F>

From 12334cb13bbb1de89770bfc5819d438bc4fb1802 Mon Sep 17 00:00:00 2001
From: Simon Brand <simon@codeplay.com>
Date: Mon, 28 May 2018 12:06:10 +0100
Subject: [PATCH 2/2] =?UTF-8?q?Thank=20Bj=C3=B6rn?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7a5dfbe..c15e6c1 100644
--- a/README.md
+++ b/README.md
@@ -88,7 +88,7 @@ Requires [Catch](https://github.com/philsquared/Catch) for testing. This is bund
 
 ### Acknowledgements
 
-Thanks to [Kévin Alexandre Boissonneault](https://github.com/KABoissonneault) for various bug fixes.
+Thanks to [Kévin Alexandre Boissonneault](https://github.com/KABoissonneault) and [Björn Fahller](https://github.com/rollbear) for various bug fixes.
 
 ----------