Rename Transmogrify to Cast and mog<T> to cast<T>.

Part of #221.

Author: danakj

subdoc/lib/gen/markdown_to_html.cc

@@ -344,7 +344,7 @@ sus::Result<MarkdownToHtml, MarkdownToHtmlError> markdown_to_html(
       } else {
         // SAFETY: The input is a char, so tolower will give a value in the
         // range of char.
-        c = sus::mog<char>(std::tolower(c));
+        c = sus::cast<char>(std::tolower(c));
       }
     }
 

sus/CMakeLists.txt

@@ -45,7 +45,7 @@ target_sources(subspace PUBLIC
     "construct/into.h"
     "construct/default.h"
     "construct/safe_from_reference.h"
-    "construct/transmogrify.h"
+    "construct/cast.h"
     "collections/__private/slice_methods_impl.inc"
     "collections/__private/slice_methods.inc"
     "collections/__private/slice_mut_methods.inc"
@@ -171,7 +171,7 @@ target_sources(subspace PUBLIC
     "num/__private/unsigned_integer_consts.inc"
     "num/__private/unsigned_integer_methods.inc"
     "num/__private/unsigned_integer_methods_impl.inc"
-    "num/transmogrify.h"
+    "num/cast.h"
     "num/float.h"
     "num/float_concepts.h"
     "num/float_impl.h"
@@ -251,7 +251,7 @@ if(${SUBSPACE_BUILD_TESTS})
         "cmp/eq_unittest.cc"
         "cmp/ord_unittest.cc"
         "cmp/reverse_unittest.cc"
-        "construct/transmogrify_unittest.cc"
+        "construct/cast_unittest.cc"
         "collections/array_unittest.cc"
         "collections/compat_deque_unittest.cc"
         "collections/compat_forward_list_unittest.cc"
@@ -294,7 +294,7 @@ if(${SUBSPACE_BUILD_TESTS})
         "mem/take_unittest.cc"
         "num/__private/literals_unittest.cc"
         "num/cmath_macros_unittest.cc"
-        "num/transmogrify_unittest.cc"
+        "num/cast_unittest.cc"
         "num/f32_unittest.cc"
         "num/f64_unittest.cc"
         "num/i8_unittest.cc"

sus/boxed/dyn.h

@@ -256,7 +256,7 @@ namespace sus::boxed {
 /// In order to ensure the target of the `DynC&` reference outlives the function
 /// it can be constructed as a stack variable before calling the function.
 /// ```
-/// std::srand(sus::mog<unsigned>(std::time(nullptr)));
+/// std::srand(sus::cast<unsigned>(std::time(nullptr)));
 ///
 /// auto x = [](sus::Option<sus::fn::DynFn<std::string()>&> fn) {
 ///   if (fn.is_some())

sus/boxed/dyn_unittest.cc

@@ -339,7 +339,7 @@ TEST(Dyn, Example_Macro) {
 }  // namespace example_macro
 
 TEST(Dyn, Example_Stack) {
-  std::srand(sus::mog<unsigned>(std::time(nullptr)));
+  std::srand(sus::cast<unsigned>(std::time(nullptr)));
 
   auto x = [](sus::Option<sus::fn::DynFn<std::string()>&> fn) {
     if (fn.is_some())

sus/collections/array.h

@@ -69,7 +69,7 @@ struct Storage<T, 0> final {};
 /// subtracting a pointer at a greater distance results in Undefined Behaviour.
 template <class T, size_t N>
 class Array final {
-  static_assert(N <= ::sus::mog<usize>(isize::MAX));
+  static_assert(N <= ::sus::cast<usize>(isize::MAX));
   static_assert(!std::is_reference_v<T>,
                 "Array<T&, N> is invalid as Array must hold value types. Use "
                 "Array<T*, N> instead.");

sus/collections/slice.h

@@ -42,8 +42,8 @@
 #include "sus/mem/clone.h"
 #include "sus/mem/move.h"
 #include "sus/mem/swap.h"
+#include "sus/num/cast.h"
 #include "sus/num/signed_integer.h"
-#include "sus/num/transmogrify.h"
 #include "sus/num/unsigned_integer.h"
 #include "sus/ops/range.h"
 #include "sus/option/option.h"
@@ -115,7 +115,7 @@ class [[sus_trivial_abi]] Slice final {
   sus_pure static constexpr Slice from_raw_parts(
       ::sus::marker::UnsafeFnMarker, const T* data sus_lifetimebound,
       usize len) noexcept {
-    ::sus::check(len <= ::sus::mog<usize>(isize::MAX));
+    ::sus::check(len <= ::sus::cast<usize>(isize::MAX));
     // We strip the `const` off `data`, however only const access is provided
     // through this class. This is done so that mutable types can compose Slice
     // and store a mutable pointer.
@@ -150,7 +150,7 @@ class [[sus_trivial_abi]] Slice final {
   sus_pure static constexpr Slice from_raw_collection(
       ::sus::marker::UnsafeFnMarker, ::sus::iter::IterRefCounter refs,
       const T* data sus_lifetimebound, usize len) noexcept {
-    ::sus::check(len <= ::sus::mog<usize>(isize::MAX));
+    ::sus::check(len <= ::sus::cast<usize>(isize::MAX));
     // We strip the `const` off `data`, however only const access is provided
     // through this class. This is done so that mutable types can compose Slice
     // and store a mutable pointer.
@@ -163,7 +163,7 @@ class [[sus_trivial_abi]] Slice final {
   ///
   /// #[doc.overloads=from.array]
   template <size_t N>
-    requires(N <= ::sus::mog<usize>(isize::MAX))
+    requires(N <= ::sus::cast<usize>(isize::MAX))
   sus_pure static constexpr Slice from(const T (&data)[N] sus_lifetimebound) {
     // We strip the `const` off `data`, however only const access is provided
     // through this class. This is done so that mutable types can compose Slice
@@ -342,7 +342,7 @@ class [[sus_trivial_abi]] SliceMut final {
   sus_pure static constexpr SliceMut from_raw_parts_mut(
       ::sus::marker::UnsafeFnMarker, T* data sus_lifetimebound,
       usize len) noexcept {
-    ::sus::check(len <= ::sus::mog<usize>(isize::MAX));
+    ::sus::check(len <= ::sus::cast<usize>(isize::MAX));
     return SliceMut(::sus::iter::IterRefCounter::empty_for_view(), data, len);
   }
 
@@ -372,7 +372,7 @@ class [[sus_trivial_abi]] SliceMut final {
   sus_pure static constexpr SliceMut from_raw_collection_mut(
       ::sus::marker::UnsafeFnMarker, ::sus::iter::IterRefCounter refs,
       T* data sus_lifetimebound, usize len) noexcept {
-    ::sus::check(len <= ::sus::mog<usize>(isize::MAX));
+    ::sus::check(len <= ::sus::cast<usize>(isize::MAX));
     return SliceMut(::sus::move(refs), data, len);
   }
 
@@ -382,7 +382,7 @@ class [[sus_trivial_abi]] SliceMut final {
   ///
   /// #[doc.overloads=from.array]
   template <size_t N>
-    requires(N <= ::sus::mog<usize>(isize::MAX_PRIMITIVE))
+    requires(N <= ::sus::cast<usize>(isize::MAX_PRIMITIVE))
   sus_pure static constexpr SliceMut from(T (&data)[N] sus_lifetimebound) {
     return SliceMut(::sus::iter::IterRefCounter::empty_for_view(), data, N);
   }

sus/collections/vec.h

@@ -50,9 +50,9 @@
 #include "sus/mem/relocate.h"
 #include "sus/mem/replace.h"
 #include "sus/mem/size_of.h"
+#include "sus/num/cast.h"
 #include "sus/num/integer_concepts.h"
 #include "sus/num/signed_integer.h"
-#include "sus/num/transmogrify.h"
 #include "sus/num/unsigned_integer.h"
 #include "sus/ops/range.h"
 #include "sus/option/option.h"
@@ -147,7 +147,8 @@ class Vec final {
   /// # Panics
   /// Panics if the capacity exceeds `isize::MAX` bytes.
   sus_pure static constexpr Vec with_capacity(usize capacity) noexcept {
-    check(::sus::mem::size_of<T>() * capacity <= ::sus::mog<usize>(isize::MAX));
+    check(::sus::mem::size_of<T>() * capacity <=
+          ::sus::cast<usize>(isize::MAX));
     return Vec(WITH_CAPACITY, std::allocator<T>(), capacity);
   }
 
@@ -210,12 +211,12 @@ class Vec final {
     requires(std::same_as<T, u8> &&  //
              (std::same_as<C, char> || std::same_as<C, signed char> ||
               std::same_as<C, unsigned char>) &&
-             N <= ::sus::mog<usize>(isize::MAX))
+             N <= ::sus::cast<usize>(isize::MAX))
   static constexpr Vec from(const C (&arr)[N]) {
     auto s = sus::Slice<C>::from(arr);
     auto v = Vec::with_capacity(N - 1);
     for (auto c : s[sus::ops::RangeTo<usize>(N - 1)])
-      v.push_with_capacity_internal(sus::mog<uint8_t>(c));
+      v.push_with_capacity_internal(sus::cast<uint8_t>(c));
     ::sus::check(s[N - 1] == 0);  // Null terminated.
     return v;
   }
@@ -1011,7 +1012,7 @@ Vec(T&&, Ts&&...) -> Vec<std::remove_cvref_t<T>>;
 template <class T>
 constexpr T* Vec<T>::alloc_internal_check_cap(usize cap) noexcept {
   sus_debug_check(!is_alloced());
-  ::sus::check(cap <= ::sus::mog<usize>(isize::MAX));
+  ::sus::check(cap <= ::sus::cast<usize>(isize::MAX));
   T* const new_data = std::allocator_traits<A>::allocate(allocator_, cap);
   data_ = new_data;
   capacity_ = cap;
@@ -1022,7 +1023,7 @@ template <class T>
 constexpr T* Vec<T>::grow_to_internal_check_cap(usize cap) noexcept {
   sus_debug_check(is_alloced());
   sus_debug_check(cap > capacity_);
-  ::sus::check(cap <= ::sus::mog<usize>(isize::MAX));
+  ::sus::check(cap <= ::sus::cast<usize>(isize::MAX));
   T* const new_data =
       std::allocator_traits<std::allocator<T>>::allocate(allocator_, cap);
   if constexpr (::sus::mem::relocate_by_memcpy<T>) {

sus/collections/vec_unittest.cc

@@ -1029,22 +1029,22 @@ TEST(Vec, FromCharArray) {
     const signed char SIGNED[] = "abcdefg";
     auto v = Vec<u8>::from(SIGNED);
     EXPECT_EQ(v.len(), 7u);
-    EXPECT_EQ(v[0u], sus::mog<u8>('a'));
-    EXPECT_EQ(v[6u], sus::mog<u8>('g'));
+    EXPECT_EQ(v[0u], sus::cast<u8>('a'));
+    EXPECT_EQ(v[6u], sus::cast<u8>('g'));
   }
   {
     const unsigned char UNSIGNED[] = "abcdefg";
     auto v = Vec<u8>::from(UNSIGNED);
     EXPECT_EQ(v.len(), 7u);
-    EXPECT_EQ(v[0u], sus::mog<u8>('a'));
-    EXPECT_EQ(v[6u], sus::mog<u8>('g'));
+    EXPECT_EQ(v[0u], sus::cast<u8>('a'));
+    EXPECT_EQ(v[6u], sus::cast<u8>('g'));
   }
   {
     const char CHARS[] = "abcdefg";
     auto v = Vec<u8>::from(CHARS);
     EXPECT_EQ(v.len(), 7u);
-    EXPECT_EQ(v[0u], sus::mog<u8>('a'));
-    EXPECT_EQ(v[6u], sus::mog<u8>('g'));
+    EXPECT_EQ(v[0u], sus::cast<u8>('a'));
+    EXPECT_EQ(v[6u], sus::cast<u8>('g'));
   }
 }