Use num::cast where appropriate...

...rather than checked_cast.

Author: tcbrindle

include/flux/core/default_impls.hpp

@@ -222,7 +222,7 @@ struct sequence_traits<R> : default_sequence_traits {
 
     static constexpr auto size(auto& self) -> distance_t
     {
-        return num::checked_cast<distance_t>(std::ranges::ssize(self));
+        return num::cast<distance_t>(std::ranges::ssize(self));
     }
 
     static constexpr auto data(auto& self) -> auto*
@@ -242,7 +242,7 @@ struct sequence_traits<R> : default_sequence_traits {
             ++iter;
         }
 
-        return num::checked_cast<index_t>(iter - std::ranges::begin(self));
+        return num::cast<index_t>(iter - std::ranges::begin(self));
     }
 };
 

include/flux/core/sequence_access.hpp

@@ -127,7 +127,7 @@ struct usize_fn {
     [[nodiscard]]
     constexpr auto operator()(Seq&& seq) const -> std::size_t
     {
-        return num::checked_cast<std::size_t>(size_fn{}(seq));
+        return num::unchecked_cast<std::size_t>(size_fn{}(seq));
     }
 };
 

include/flux/op/cycle.hpp

@@ -186,7 +186,7 @@ struct cycle_adaptor : inline_sequence_base<cycle_adaptor<Base, IsInfinite>> {
             requires random_access_sequence<decltype(self.base_)> &&
                      sized_sequence<decltype(self.base_)>
         {
-            auto dist = num::checked_cast<distance_t>(to.n) - num::checked_cast<distance_t>(from.n);
+            auto dist = num::cast<distance_t>(to.n) - num::cast<distance_t>(from.n);
             dist = num::mul(dist, flux::size(self.base_));
             return num::add(dist,
                     flux::distance(self.base_, from.base_cur, to.base_cur));
@@ -204,7 +204,7 @@ struct cycle_adaptor : inline_sequence_base<cycle_adaptor<Base, IsInfinite>> {
             requires (!IsInfinite && sized_sequence<Base>)
         {
             return num::mul(flux::size(self.base_),
-                            num::checked_cast<flux::distance_t>(self.data_.count));
+                            num::cast<flux::distance_t>(self.data_.count));
         }
     };
 };

include/flux/op/slide.hpp

@@ -115,7 +115,7 @@ struct slide_fn {
     template <adaptable_sequence Seq>
         requires multipass_sequence<Seq>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, std::integral auto win_sz) const
+    constexpr auto operator()(Seq&& seq, num::integral auto win_sz) const
         -> sequence auto
     {
         return slide_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq),
@@ -132,7 +132,7 @@ constexpr auto inline_sequence_base<D>::slide(std::integral auto win_sz) &&
         requires multipass_sequence<D>
 {
     FLUX_ASSERT(win_sz > 0);
-    return flux::slide(std::move(derived()), num::checked_cast<distance_t>(win_sz));
+    return flux::slide(std::move(derived()), win_sz);
 }
 
 } // namespace slide

include/flux/source/iota.hpp

@@ -98,19 +98,19 @@ struct iota_sequence_traits : default_sequence_traits {
         -> cursor_type&
         requires advancable<T>
     {
-        return cur += num::checked_cast<std::iter_difference_t<T>>(offset);
+        return cur += num::cast<std::iter_difference_t<T>>(offset);
     }
 
     static constexpr auto distance(auto&, cursor_type const& from, cursor_type const& to)
         requires advancable<T>
     {
-        return from <= to ? num::checked_cast<distance_t>(to - from) : -num::checked_cast<distance_t>(from - to);
+        return from <= to ? num::cast<distance_t>(to - from) : -num::cast<distance_t>(from - to);
     }
 
     static constexpr auto size(auto& self) -> distance_t
         requires advancable<T> && (Traits.has_start && Traits.has_end)
     {
-        return num::checked_cast<distance_t>(self.end_ - self.start_);
+        return num::cast<distance_t>(self.end_ - self.start_);
     }
 };
 

include/flux/source/range.hpp

@@ -122,7 +122,7 @@ struct range_sequence : inline_sequence_base<range_sequence<R, IsConst>> {
                 bounds_check(offset < distance(self, cur, last(self)));
             }
 
-            cur.iter += num::checked_cast<std::ranges::range_difference_t<V>>(offset);
+            cur.iter += num::cast<std::ranges::range_difference_t<V>>(offset);
         }
 
         template <typename Self>
@@ -131,7 +131,7 @@ struct range_sequence : inline_sequence_base<range_sequence<R, IsConst>> {
             -> distance_t
             requires std::ranges::random_access_range<R>
         {
-            return num::checked_cast<distance_t>(std::ranges::distance(from.iter, to.iter));
+            return num::cast<distance_t>(std::ranges::distance(from.iter, to.iter));
         }
 
         template <typename Self>
@@ -159,7 +159,7 @@ struct range_sequence : inline_sequence_base<range_sequence<R, IsConst>> {
         static constexpr auto size(Self& self) -> distance_t
             requires std::ranges::sized_range<R>
         {
-            return num::checked_cast<distance_t>(std::ranges::ssize(self.rng_));
+            return num::cast<distance_t>(std::ranges::ssize(self.rng_));
         }
 
         template <typename Self>

include/flux/source/repeat.hpp

@@ -77,7 +77,7 @@ struct repeat_sequence : inline_sequence_base<repeat_sequence<T, IsInfinite>>
 
         static constexpr auto distance(self_t const&, std::size_t from, std::size_t to) -> distance_t
         {
-            return num::checked_cast<distance_t>(to) - num::checked_cast<distance_t>(from);
+            return num::cast<distance_t>(to) - num::cast<distance_t>(from);
         }
 
         static constexpr auto for_each_while(self_t const& self, auto&& pred) -> std::size_t
@@ -110,7 +110,7 @@ struct repeat_sequence : inline_sequence_base<repeat_sequence<T, IsInfinite>>
         static constexpr auto size(self_t const& self) -> distance_t
             requires (!IsInfinite)
         {
-            return num::checked_cast<distance_t>(self.data_.count);
+            return num::cast<distance_t>(self.data_.count);
         }
     };
 };