Add u32::from(i32) and i32::from(u32)

Going from one type to the other will panic if out of bounds

Author: danakj

CMakeLists.txt

@@ -65,6 +65,7 @@ add_library(subspace STATIC
     "num/__private/signed_integer_macros.h"
     "num/__private/unsigned_integer_macros.h"
     "num/i32.h"
+    "num/integer_concepts.h"
     "num/num_concepts.h"
     "num/u32.h"
     "option/__private/is_option_type.h"

concepts/from.h

@@ -18,8 +18,11 @@
 
 namespace sus::concepts::from {
 
-// clang-format off
+/// A concept that indicates ToType can be constructed from a FromType, via
+/// `ToType::from(FromType)`.
+///
 template <class ToType, class FromType>
+// clang-format off
 concept From = requires (FromType&& from) {
     { ToType::from(static_cast<FromType&&>(from)) } -> std::same_as<ToType>;
 };

concepts/into.h

@@ -18,7 +18,6 @@
 #include <type_traits>
 
 #include "concepts/from.h"
-#include "mem/forward.h"
 
 namespace sus::concepts::into {
 
@@ -43,7 +42,7 @@ struct IntoRef {
 
 }  // namespace __private
 
-template<class FromType, class ToType>
+template <class FromType, class ToType>
 concept Into = ::sus::concepts::from::From<ToType, FromType>;
 
 template <class FromType>

concepts/into_unittest.cc

@@ -14,6 +14,7 @@
 
 #include "concepts/into.h"
 
+#include "mem/forward.h"
 #include "third_party/googletest/googletest/include/gtest/gtest.h"
 
 using sus::concepts::from::From;

num/__private/signed_integer_macros.h

@@ -41,6 +41,7 @@
   static_assert(true)
 
 #define _sus__signed_impl(T, Bytes, LargerT, UnsignedT, UnsignedSusT) \
+  _sus__signed_from(T);                                               \
   _sus__signed_integer_comparison(T);                                 \
   _sus__signed_unary_ops(T, UnsignedT);                               \
   _sus__signed_binary_logic_ops(T);                                   \
@@ -60,6 +61,37 @@
   _sus__signed_log(T, UnsignedT);                                     \
   _sus__signed_endian(T, UnsignedT, Bytes)
 
+#define _sus__signed_from(T)                                                \
+  /** Constructs a ##T## from a signed integer type (i8, i16, i32, etc).    \
+   *                                                                        \
+   * # Panics                                                               \
+   * The function will panic if the input value is out of range for ##T##.  \
+   */                                                                       \
+  template <Signed S>                                                       \
+  static constexpr i32 from(S s) noexcept {                                 \
+    if constexpr (MIN_PRIMITIVE > S::MIN_PRIMITIVE)                         \
+      ::sus::check(s.primitive_value >= MIN_PRIMITIVE);                     \
+    if constexpr (MAX_PRIMITIVE < S::MAX_PRIMITIVE)                         \
+      ::sus::check(s.primitive_value <= MAX_PRIMITIVE);                     \
+    return i32(static_cast<primitive_type>(s.primitive_value));             \
+  }                                                                         \
+                                                                            \
+  /** Constructs a ##T## from an unsigned integer type (u8, u16, u32, etc). \
+   *                                                                        \
+   * # Panics                                                               \
+   * The function will panic if the input value is out of range for ##T##.  \
+   */                                                                       \
+  template <Unsigned U>                                                     \
+  static constexpr i32 from(U u) noexcept {                                 \
+    constexpr auto umax =                                                   \
+        static_cast<decltype(U::primitive_value)>(MAX_PRIMITIVE);           \
+    if constexpr (umax < U::MAX_PRIMITIVE) {                                \
+      ::sus::check(u.primitive_value <= umax);                              \
+    }                                                                       \
+    return i32(static_cast<primitive_type>(u.primitive_value));             \
+  }                                                                         \
+  static_assert(true)
+
 #define _sus__signed_integer_comparison(T)                                     \
   /** Returns true if the current value is positive and false if the number is \
    * zero or negative.                                                         \

num/__private/unsigned_integer_macros.h

@@ -37,6 +37,7 @@
   static_assert(true)
 
 #define _sus__unsigned_impl(T, Bytes, LargerT) \
+  _sus__unsigned_from(T);                      \
   _sus__unsigned_integer_comparison(T);        \
   _sus__unsigned_unary_ops(T);                 \
   _sus__unsigned_binary_logic_ops(T);          \
@@ -56,6 +57,37 @@
   _sus__unsigned_log(T);                       \
   _sus__unsigned_endian(T, Bytes)
 
+#define _sus__unsigned_from(T)                                              \
+  /** Constructs a ##T## from a signed integer type (i8, i16, i32, etc).    \
+   *                                                                        \
+   * # Panics                                                               \
+   * The function will panic if the input value is out of range for ##T##.  \
+   */                                                                       \
+  template <Signed S>                                                       \
+  static constexpr u32 from(S s) noexcept {                                 \
+    ::sus::check(s.primitive_value >= 0);                                   \
+    constexpr auto umax = static_cast<primitive_type>(S::MAX_PRIMITIVE);    \
+    if constexpr (MAX_PRIMITIVE < umax)                                     \
+      ::sus::check(static_cast<primitive_type>(s.primitive_value) <=        \
+                   MAX_PRIMITIVE);                                          \
+    return u32(static_cast<primitive_type>(s.primitive_value));             \
+  }                                                                         \
+                                                                            \
+  /** Constructs a ##T## from an unsigned integer type (u8, u16, u32, etc). \
+   *                                                                        \
+   * # Panics                                                               \
+   * The function will panic if the input value is out of range for ##T##.  \
+   */                                                                       \
+  template <Unsigned U>                                                     \
+  static constexpr u32 from(U u) noexcept {                                 \
+    if constexpr (MIN_PRIMITIVE > U::MIN_PRIMITIVE)                         \
+      ::sus::check(u.primitive_value >= MIN_PRIMITIVE);                     \
+    if constexpr (MAX_PRIMITIVE < U::MAX_PRIMITIVE)                         \
+      ::sus::check(u.primitive_value <= MAX_PRIMITIVE);                     \
+    return u32(static_cast<primitive_type>(u.primitive_value));             \
+  }                                                                         \
+  static_assert(true)
+
 #define _sus__unsigned_integer_comparison(T)                                  \
   /** sus::concepts::Eq<##T##> trait. */                                      \
   friend constexpr inline bool operator==(const T& l, const T& r) noexcept {  \

num/i32.h

@@ -20,6 +20,7 @@
 
 #include "num/__private/literals.h"
 #include "num/__private/signed_integer_macros.h"
+#include "num/integer_concepts.h"
 
 namespace sus::num {
 

num/i32_unittest.cc

@@ -1507,7 +1507,8 @@ TEST(i32, OverflowingPow) {
 
   EXPECT_EQ((2_i32).overflowing_pow(5_u32),
             (Tuple<i32, bool>::with(32_i32, false)));
-  EXPECT_EQ((2_i32).overflowing_pow(0_u32), (Tuple<i32, bool>::with(1_i32, false)));
+  EXPECT_EQ((2_i32).overflowing_pow(0_u32),
+            (Tuple<i32, bool>::with(1_i32, false)));
   EXPECT_EQ((i32::MAX()).overflowing_pow(1_u32),
             (Tuple<i32, bool>::with(i32::MAX(), false)));
   EXPECT_EQ((i32::MAX()).overflowing_pow(2_u32),
@@ -1522,8 +1523,7 @@ TEST(i32, CheckedPow) {
   EXPECT_EQ((2_i32).checked_pow(0_u32), Option<i32>::some(1_i32));
   EXPECT_EQ((2_i32).checked_pow(1_u32), Option<i32>::some(2_i32));
   EXPECT_EQ((2_i32).checked_pow(30_u32), Option<i32>::some(1_i32 << 30_u32));
-  EXPECT_EQ((1_i32).checked_pow(u32::MAX()),
-            Option<i32>::some(1_i32));
+  EXPECT_EQ((1_i32).checked_pow(u32::MAX()), Option<i32>::some(1_i32));
   EXPECT_EQ((i32::MAX()).checked_pow(1_u32), Option<i32>::some(i32::MAX()));
   EXPECT_EQ((i32::MAX()).checked_pow(0_u32), Option<i32>::some(1_i32));
 
@@ -1899,4 +1899,17 @@ TEST(i32, ToNeBytes) {
   }
 }
 
+TEST(i32, From) {
+  static_assert(sus::concepts::from::From<i32, u32>);
+
+  // TODO: Add all the integer types as they exist.
+  EXPECT_EQ(i32::from(2_i32), 2_i32);
+  EXPECT_EQ(i32::from(2_u32), 2_i32);
+}
+
+TEST(i32DeathTest, FromOutOfRange) {
+  // TODO: Add all the integer types as they exist.
+  EXPECT_DEATH(i32::from(u32::MAX()), "");
+}
+
 }  // namespace

num/integer_concepts.h

@@ -0,0 +1,35 @@
+// Copyright 2022 Google LLC
+//
+// 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
+//
+//     https://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 <concepts>
+
+namespace sus::num {
+
+struct i32;
+struct u32;
+
+// TODO: Add all the unsigned types as they exist.
+template <class T>
+concept Unsigned = std::same_as<u32, std::decay_t<T>>;
+
+// TODO: Add all the signed types as they exist.
+template <class T>
+concept Signed = std::same_as<i32, std::decay_t<T>>;
+
+template <class T>
+concept Integer = Unsigned<T> || Signed<T>;
+
+}  // namespace sus::num

num/u32.h

@@ -18,8 +18,11 @@
 
 #include <concepts>
 
+#include "concepts/from.h"
+#include "concepts/into.h"
 #include "num/__private/literals.h"
 #include "num/__private/unsigned_integer_macros.h"
+#include "num/integer_concepts.h"
 
 namespace sus::num {
 
@@ -74,7 +77,6 @@ struct u32 {
   // TODO: from_str_radix(). Need Result type and Errors.
   // TODO: next_power_of_two().
   // TODO: checked_add_signed() and friends?
-  // TODO: casting to i32, and u{8-64}. Maybe i{8-64}?
 
   /// The inner primitive value, in case it needs to be unwrapped from the
   /// type. Avoid using this member except to convert when a consumer