result_to_try & try_to_result

Summary: `result_to_try` & `try_to_result` to make it easier to `result`-ify existing codebases.

Reviewed By: ispeters

Differential Revision: D71589246

fbshipit-source-id: f03b9c4922fd62df0c08ea457af79f7dc8b3e235

Author: snarkmaster

folly/result/test/try_test.cpp

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <folly/result/try.h>
+
+#if FOLLY_HAS_RESULT
+
+namespace folly {
+
+struct ThrowingMove {
+  ThrowingMove(const ThrowingMove&) = default;
+  ThrowingMove& operator=(const ThrowingMove&) = default;
+  ThrowingMove(ThrowingMove&&) {}
+  ThrowingMove& operator=(ThrowingMove&&) { return *this; }
+};
+struct NothrowMove {};
+
+static_assert(noexcept(result_to_try(FOLLY_DECLVAL(result<int>))));
+static_assert(noexcept(result_to_try(FOLLY_DECLVAL(result<NothrowMove>))));
+static_assert(!noexcept(result_to_try(FOLLY_DECLVAL(result<ThrowingMove>))));
+
+static_assert(noexcept(try_to_result(FOLLY_DECLVAL(Try<int>))));
+static_assert(noexcept(try_to_result(FOLLY_DECLVAL(Try<NothrowMove>))));
+static_assert(!noexcept(try_to_result(FOLLY_DECLVAL(Try<ThrowingMove>))));
+
+TEST(ResultTry, result_to_try) {
+  auto tInt = result_to_try(result<int>{5});
+  static_assert(std::is_same_v<Try<int>, decltype(tInt)>);
+  EXPECT_EQ(5, *tInt);
+
+  auto tErr = result_to_try(
+      result<int>{make_exception_wrapper<std::runtime_error>("foo")});
+  static_assert(std::is_same_v<Try<int>, decltype(tErr)>);
+  EXPECT_STREQ("foo", tErr.tryGetExceptionObject<std::runtime_error>()->what());
+
+  // `void` -> `void` is a special case
+  auto tVoid = result_to_try(result<void>{});
+  static_assert(std::is_same_v<Try<void>, decltype(tVoid)>);
+  EXPECT_TRUE(tVoid.hasValue());
+}
+
+TEST(ResultTry, nonempty_try_to_result) {
+  auto rInt = try_to_result(Try<int>{5});
+  static_assert(std::is_same_v<result<int>, decltype(rInt)>);
+  EXPECT_EQ(5, rInt.value_or_throw());
+
+  auto rErr = try_to_result(
+      Try<int>{make_exception_wrapper<std::runtime_error>("foo")});
+  static_assert(std::is_same_v<result<int>, decltype(rErr)>);
+  EXPECT_STREQ("foo", get_exception<std::runtime_error>(rErr)->what());
+
+  // `void` -> `void` is a special case
+  auto rVoid = try_to_result(Try<void>{});
+  static_assert(std::is_same_v<result<void>, decltype(rVoid)>);
+  EXPECT_TRUE(rVoid.has_value());
+}
+
+TEST(ResultTry, empty_try_to_result_error) {
+  auto rErr = try_to_result(Try<int>{});
+  static_assert(std::is_same_v<result<int>, decltype(rErr)>);
+  EXPECT_NE(nullptr, get_exception<UsingUninitializedTry>(rErr));
+}
+
+TEST(ResultTry, empty_try_to_result_default) {
+  auto rInt = try_to_result(Try<int>{}, empty_try_with{[]() { return 1337; }});
+  static_assert(std::is_same_v<result<int>, decltype(rInt)>);
+  EXPECT_EQ(1337, rInt.value_or_throw());
+
+  auto rErr = try_to_result(
+      Try<int>{}, empty_try_with{[]() {
+        return make_exception_wrapper<std::runtime_error>("baz");
+      }});
+  static_assert(std::is_same_v<result<int>, decltype(rErr)>);
+  EXPECT_STREQ("baz", get_exception<std::runtime_error>(rErr)->what());
+}
+
+} // namespace folly
+
+#endif // FOLLY_HAS_RESULT

folly/result/try.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/Try.h>
+#include <folly/result/result.h>
+
+/// `result<T>` <-> `Try<T>` conversions to aid in migrating legacy `Try` code.
+///
+/// Perfect interconversion is not always possible:
+///   - `Try` does not support reference types, but `result` does.
+///   - `Try` has 3 states.  Value & error interconvert transparently.  For the
+///     empty state, `try_to_result` has a 2nd arg to set the policy.
+
+#if FOLLY_HAS_RESULT
+
+namespace folly {
+
+// NB: If `T` is a reference type, this will fail with a `Try` static assert.
+template <typename T>
+Try<T> result_to_try(result<T> r) noexcept(
+    std::is_nothrow_move_constructible_v<T>) {
+  if (r.has_value()) {
+    if constexpr (std::is_void_v<T>) {
+      return Try<void>{};
+    } else {
+      return Try<T>{std::move(r).value_or_throw()};
+    }
+  } else {
+    return Try<T>{std::move(r).non_value().get_legacy_error_or_cancellation()};
+  }
+}
+
+inline constexpr struct empty_try_as_error_t {
+  template <typename T>
+  result<T> on_empty_try() const {
+    return {make_exception_wrapper<UsingUninitializedTry>()};
+  }
+} empty_try_as_error;
+
+template <typename Fn>
+class empty_try_with {
+ private:
+  Fn fn_;
+
+ public:
+  explicit empty_try_with(Fn fn) : fn_(std::move(fn)) {}
+  template <typename T>
+  result<T> on_empty_try() && {
+    return {std::move(fn_)()};
+  }
+};
+
+/// If `t` is empty, defaults to returning a `UsingUninitializedTry` result.
+/// Pick your own default via `empty_try_with{[]() { return result<T>{...}; }`.
+template <typename T, typename IfEmpty>
+result<T> try_to_result(Try<T> t, IfEmpty if_empty) noexcept(
+    std::is_nothrow_move_constructible_v<T>) {
+  if (t.hasValue()) {
+    if constexpr (std::is_void_v<T>) {
+      return result<void>{};
+    } else {
+      return {std::move(t).value()};
+    }
+  } else if (t.hasException()) {
+    return {non_value_result::make_legacy_error_or_cancellation(
+        std::move(t).exception())};
+  } else {
+    return std::move(if_empty).template on_empty_try<T>();
+  }
+}
+template <typename T>
+result<T> try_to_result(Try<T> t) noexcept(
+    std::is_nothrow_move_constructible_v<T>) {
+  return try_to_result(std::move(t), empty_try_as_error);
+}
+
+} // namespace folly
+
+#endif // FOLLY_HAS_RESULT