Add TryInto and try_into<T>()

This gives a cast-like syntax for fallably converting to a
type in a value-preserving way for #221.

Author: danakj

subspace/construct/from.h

@@ -16,6 +16,7 @@
 
 #include <concepts>
 
+#include "subspace/mem/forward.h"
 #include "subspace/result/__private/is_result_type.h"
 
 namespace sus::construct {
@@ -48,7 +49,7 @@ namespace sus::construct {
 /// ```
 template <class ToType, class FromType>
 concept From = requires(FromType&& from) {
-  { ToType::from(static_cast<FromType&&>(from)) } -> std::same_as<ToType>;
+  { ToType::from(::sus::forward<FromType>(from)) } -> std::same_as<ToType>;
 };
 
 /// A concept that indicates `ToType` can be (sometimes) constructed from a
@@ -59,11 +60,9 @@ concept From = requires(FromType&& from) {
 /// `sus::Result`.
 template <class ToType, class FromType>
 concept TryFrom = requires(FromType&& from) {
-  { ToType::try_from(static_cast<FromType&&>(from)) };
-  requires std::same_as<
-      typename ::sus::result::__private::IsResultType<decltype(ToType::try_from(
-          static_cast<FromType&&>(from)))>::ok_type,
-      ToType>;
+  {
+    ToType::try_from(::sus::forward<FromType>(from))
+  } -> ::sus::result::__private::IsResultWithSuccessType<ToType>;
 };
 
 }  // namespace sus::construct

subspace/construct/from_unittest.cc

@@ -15,8 +15,10 @@
 #include "subspace/construct/from.h"
 
 #include "subspace/construct/into.h"
+#include "subspace/result/result.h"
 
 using sus::construct::From;
+using sus::construct::TryFrom;
 
 namespace {
 
@@ -44,4 +46,24 @@ static_assert(!From<WithFromS, int>);
 static_assert(!From<FromReturnsVoid, int>);
 static_assert(!From<FromReturnsElse, int>);
 
+enum Error {};
+
+struct TryYes {
+  static sus::Result<TryYes, Error> try_from(S) { return sus::ok(TryYes()); }
+};
+struct TryNoResult {
+  static TryYes try_from(S) { return TryYes(); }
+};
+struct TryWrongResult {
+  static sus::Result<S, Error> try_from(S) { return sus::ok(S()); }
+};
+struct TryVoidResult {
+  static sus::Result<void, Error> try_from(S) { return sus::ok(); }
+};
+
+static_assert(TryFrom<TryYes, S>);
+static_assert(!TryFrom<TryNoResult, S>);
+static_assert(!TryFrom<TryWrongResult, S>);
+static_assert(!TryFrom<TryVoidResult, S>);
+
 }  // namespace

subspace/construct/into.h

@@ -22,10 +22,12 @@
 #include "subspace/construct/__private/into_ref.h"
 #include "subspace/construct/from.h"
 #include "subspace/macros/compiler.h"
+#include "subspace/macros/lifetimebound.h"
+#include "subspace/mem/forward.h"
 
 namespace sus::construct {
 
-/// A concept that declares `FromType` can be converted to `ToType`, through the
+/// A concept that declares `FromType` can be converted to `ToType` through the
 /// `From` concept or through an identity transformation.
 ///
 /// When true, `ToType::from(FromType)` can be used to construct `ToType`,
@@ -84,25 +86,22 @@ template <class FromType>
   requires(!std::is_const_v<std::remove_reference_t<FromType>> &&
            std::is_rvalue_reference_v<FromType &&> &&
            !std::is_array_v<FromType>)
-constexpr inline auto into(
-    FromType&& from sus_if_clang([[clang::lifetimebound]])) noexcept {
+constexpr inline auto into(FromType&& from sus_lifetimebound) noexcept {
   return __private::IntoRef(
       static_cast<std::remove_reference_t<FromType>&&>(from));
 }
 
 template <class FromType>
   requires(std::is_trivially_copyable_v<FromType> && !std::is_array_v<FromType>)
-constexpr inline auto into(
-    const FromType& from sus_if_clang([[clang::lifetimebound]])) noexcept {
+constexpr inline auto into(const FromType& from sus_lifetimebound) noexcept {
   return __private::IntoRef<const FromType&>(from);
 }
 
 template <class FromType>
   requires(!std::is_const_v<std::remove_reference_t<FromType>> &&
            std::is_trivially_move_constructible_v<FromType> &&
            !std::is_array_v<FromType>)
-constexpr inline auto into(
-    FromType& from sus_if_clang([[clang::lifetimebound]])) noexcept {
+constexpr inline auto into(FromType& from sus_lifetimebound) noexcept {
   return __private::IntoRef(
       static_cast<std::remove_reference_t<FromType>&&>(from));
 }
@@ -113,7 +112,7 @@ constexpr inline auto into(
 /// satisfied.
 template <class FromType, size_t N>
 constexpr inline auto array_into(
-    FromType (&from)[N] sus_if_clang([[clang::lifetimebound]])) noexcept {
+    FromType (&from)[N] sus_lifetimebound) noexcept {
   return __private::IntoRefArray<FromType, N>(from);
 }
 
@@ -128,8 +127,7 @@ constexpr inline auto array_into(
 template <class FromType>
   requires(!std::is_const_v<std::remove_reference_t<FromType>> &&
            !std::is_array_v<FromType>)
-constexpr inline auto move_into(
-    FromType& from sus_if_clang([[clang::lifetimebound]])) noexcept {
+constexpr inline auto move_into(FromType& from sus_lifetimebound) noexcept {
   return __private::IntoRef(
       static_cast<std::remove_cv_t<std::remove_reference_t<FromType>>&&>(from));
 }
@@ -138,13 +136,37 @@ template <class FromType>
   requires(std::is_rvalue_reference_v<FromType &&> &&
            !std::is_const_v<std::remove_reference_t<FromType>> &&
            !std::is_array_v<FromType>)
-constexpr inline auto move_into(
-    FromType&& from sus_if_clang([[clang::lifetimebound]])) noexcept {
+constexpr inline auto move_into(FromType&& from sus_lifetimebound) noexcept {
   return __private::IntoRef(
       static_cast<std::remove_cv_t<std::remove_reference_t<FromType>>&&>(from));
 }
 
-// TODO: Consider adding sus::try_into() and a TryInto concept?
+/// A concept that declares `FromType` can (sometimes) be converted to `ToType`
+/// through the `TryFrom` concept or through an identity transformation.
+template <class FromType, class ToType>
+concept TryInto = ::sus::construct::TryFrom<ToType, FromType> ||
+                  std::same_as<ToType, FromType>;
+
+/// Attempts to convert from the given value to a `ToType`.
+///
+/// Unlike `into()`, this function can not use type deduction to determine the
+/// receiving type as it needs to determine the Result type and allow the caller
+/// the chance to handle the error condition.
+///
+/// The `TryFrom` concept requires a `try_from()` method that returns a
+/// `Result`. That `Result` will be the return type of this function.
+///
+/// # Example
+/// ```
+/// auto valid = sus::try_into<u8>(123_i32).unwrap_or_default();
+/// sus::check(valid == 123);
+/// auto invalid = sus::try_into<u8>(-1_i32).unwrap_or_default();
+/// sus::check(invalid == 0);
+/// ```
+template <class ToType, TryInto<ToType> FromType>
+constexpr inline auto try_into(FromType&& from) noexcept {
+  return ToType::try_from(::sus::forward<FromType>(from));
+}
 
 }  // namespace sus::construct
 
@@ -153,4 +175,5 @@ namespace sus {
 using ::sus::construct::array_into;
 using ::sus::construct::into;
 using ::sus::construct::move_into;
+using ::sus::construct::try_into;
 }  // namespace sus

subspace/construct/into_unittest.cc

@@ -17,6 +17,7 @@
 #include "googletest/include/gtest/gtest.h"
 #include "subspace/macros/__private/compiler_bugs.h"
 #include "subspace/mem/forward.h"
+#include "subspace/prelude.h"
 #include "subspace/test/behaviour_types.h"
 
 using sus::construct::From;
@@ -156,4 +157,11 @@ TEST(Into, Concept) {
   EXPECT_EQ(f(S(3)).got_value, 3);
 }
 
+TEST(TryInto, Example) {
+  auto valid = sus::try_into<u8>(123_i32).unwrap_or_default();
+  sus::check(valid == 123u);
+  auto invalid = sus::try_into<u8>(-1_i32).unwrap_or_default();
+  sus::check(invalid == 0u);
+}
+
 }  // namespace

subspace/result/__private/is_result_type.h

@@ -30,4 +30,9 @@ struct IsResultType<::sus::result::Result<U, V>> final : std::true_type {
   using err_type = V;
 };
 
+template <class T, class Success>
+concept IsResultWithSuccessType =
+    IsResultType<T>::value &&
+    std::same_as<Success, typename IsResultType<T>::ok_type>;
+
 }  // namespace sus::result::__private