Use num::integral rather than std::integral...

tcbrindle · tcbrindle · commit 2d330a69c879 · 2024-08-23T12:29:40.000+01:00
...in function arguments, because I don't think flux::chunk(seq, 'a') is something we should allow.
diff --git a/include/flux/core/inline_sequence_base.hpp b/include/flux/core/inline_sequence_base.hpp
@@ -235,7 +235,7 @@ struct inline_sequence_base {
                      (multipass_sequence<Derived> && not infinite_sequence<Derived>);
 
     [[nodiscard]]
-    constexpr auto chunk(std::integral auto chunk_sz) &&;
+    constexpr auto chunk(num::integral auto chunk_sz) &&;
 
     template <typename Pred>
         requires multipass_sequence<Derived> &&
@@ -251,15 +251,15 @@ struct inline_sequence_base {
             requires infinite_sequence<Derived> || multipass_sequence<Derived>;
 
     [[nodiscard]]
-    constexpr auto cycle(std::integral auto count) && requires multipass_sequence<Derived>;
+    constexpr auto cycle(num::integral auto count) && requires multipass_sequence<Derived>;
 
     [[nodiscard]]
     constexpr auto dedup() &&
         requires multipass_sequence<Derived> &&
                  std::equality_comparable<element_t<Derived>>;
 
     [[nodiscard]]
-    constexpr auto drop(std::integral auto count) &&;
+    constexpr auto drop(num::integral auto count) &&;
 
     template <typename Pred>
         requires std::predicate<Pred&, element_t<Derived>>
@@ -338,7 +338,7 @@ struct inline_sequence_base {
     constexpr auto scan_first(Func func) &&;
 
     [[nodiscard]]
-    constexpr auto slide(std::integral auto win_sz) && requires multipass_sequence<Derived>;
+    constexpr auto slide(num::integral auto win_sz) && requires multipass_sequence<Derived>;
 
     template <typename Pattern>
         requires multipass_sequence<Derived> &&
@@ -364,10 +364,10 @@ struct inline_sequence_base {
     constexpr auto split_string(Pattern&& pattern) &&;
 
     [[nodiscard]]
-    constexpr auto stride(std::integral auto by) &&;
+    constexpr auto stride(num::integral auto by) &&;
 
     [[nodiscard]]
-    constexpr auto take(std::integral auto count) &&;
+    constexpr auto take(num::integral auto count) &&;
 
     template <typename Pred>
         requires std::predicate<Pred&, element_t<Derived>>
diff --git a/include/flux/op/chunk.hpp b/include/flux/op/chunk.hpp
@@ -298,7 +298,7 @@ struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {
 struct chunk_fn {
     template <adaptable_sequence Seq>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, std::integral auto chunk_sz) const
+    constexpr auto operator()(Seq&& seq, num::integral auto chunk_sz) const
         -> sequence auto
     {
         FLUX_ASSERT(chunk_sz > 0);
@@ -312,7 +312,7 @@ struct chunk_fn {
 FLUX_EXPORT inline constexpr auto chunk = detail::chunk_fn{};
 
 template <typename D>
-constexpr auto inline_sequence_base<D>::chunk(std::integral auto chunk_sz) &&
+constexpr auto inline_sequence_base<D>::chunk(num::integral auto chunk_sz) &&
 {
     return flux::chunk(std::move(derived()), chunk_sz);
 }
diff --git a/include/flux/op/cycle.hpp b/include/flux/op/cycle.hpp
@@ -225,7 +225,7 @@ struct cycle_fn {
     template <adaptable_sequence Seq>
         requires multipass_sequence<Seq>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, std::integral auto count) const
+    constexpr auto operator()(Seq&& seq, num::integral auto count) const
         -> multipass_sequence auto
     {
         auto c = num::checked_cast<distance_t>(count);
@@ -249,7 +249,7 @@ constexpr auto inline_sequence_base<D>::cycle() &&
 }
 
 template <typename D>
-constexpr auto inline_sequence_base<D>::cycle(std::integral auto count) &&
+constexpr auto inline_sequence_base<D>::cycle(num::integral auto count) &&
     requires multipass_sequence<D>
 {
     return flux::cycle(std::move(derived()), count);
diff --git a/include/flux/op/drop.hpp b/include/flux/op/drop.hpp
@@ -64,7 +64,7 @@ struct drop_adaptor : inline_sequence_base<drop_adaptor<Base>> {
 struct drop_fn {
     template <adaptable_sequence Seq>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, std::integral auto count) const
+    constexpr auto operator()(Seq&& seq, num::integral auto count) const
     {
         auto count_ = num::checked_cast<distance_t>(count);
         if (count_ < 0) {
@@ -81,7 +81,7 @@ struct drop_fn {
 FLUX_EXPORT inline constexpr auto drop = detail::drop_fn{};
 
 template <typename Derived>
-constexpr auto inline_sequence_base<Derived>::drop(std::integral auto count) &&
+constexpr auto inline_sequence_base<Derived>::drop(num::integral auto count) &&
 {
     return flux::drop(std::move(derived()), count);
 }
diff --git a/include/flux/op/slide.hpp b/include/flux/op/slide.hpp
@@ -128,7 +128,7 @@ struct slide_fn {
 FLUX_EXPORT inline constexpr auto slide = detail::slide_fn{};
 
 template <typename D>
-constexpr auto inline_sequence_base<D>::slide(std::integral auto win_sz) &&
+constexpr auto inline_sequence_base<D>::slide(num::integral auto win_sz) &&
         requires multipass_sequence<D>
 {
     FLUX_ASSERT(win_sz > 0);
diff --git a/include/flux/op/stride.hpp b/include/flux/op/stride.hpp
@@ -254,7 +254,7 @@ struct stride_adaptor<Base> : inline_sequence_base<stride_adaptor<Base>> {
 struct stride_fn {
     template <adaptable_sequence Seq>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, std::integral auto by) const
+    constexpr auto operator()(Seq&& seq, num::integral auto by) const
     {
         FLUX_ASSERT(by > 0);
         return stride_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq),
@@ -267,7 +267,7 @@ struct stride_fn {
 FLUX_EXPORT inline constexpr auto stride = detail::stride_fn{};
 
 template <typename D>
-constexpr auto inline_sequence_base<D>::stride(std::integral auto by) &&
+constexpr auto inline_sequence_base<D>::stride(num::integral auto by) &&
 {
     return flux::stride(std::move(derived()), by);
 }
diff --git a/include/flux/op/take.hpp b/include/flux/op/take.hpp
@@ -148,7 +148,7 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>>
 struct take_fn {
     template <adaptable_sequence Seq>
     [[nodiscard]]
-    constexpr auto operator()(Seq&& seq, std::integral auto count) const
+    constexpr auto operator()(Seq&& seq, num::integral auto count) const
     {
         auto count_ = num::checked_cast<distance_t>(count);
         if (count_ < 0) {
@@ -164,7 +164,7 @@ struct take_fn {
 FLUX_EXPORT inline constexpr auto take = detail::take_fn{};
 
 template <typename Derived>
-constexpr auto inline_sequence_base<Derived>::take(std::integral auto count) &&
+constexpr auto inline_sequence_base<Derived>::take(num::integral auto count) &&
 {
     return flux::take(std::move(derived()), count);
 }
diff --git a/include/flux/source/array_ptr.hpp b/include/flux/source/array_ptr.hpp
@@ -158,7 +158,7 @@ namespace detail {
 struct make_array_ptr_unchecked_fn {
     template <typename T>
         requires (std::is_object_v<T> && !std::is_abstract_v<T>)
-    constexpr auto operator()(T* ptr, std::integral auto size) const -> array_ptr<T>
+    constexpr auto operator()(T* ptr, num::integral auto size) const -> array_ptr<T>
     {
         return array_ptr<T>(ptr, num::checked_cast<distance_t>(size));
     }
diff --git a/include/flux/source/repeat.hpp b/include/flux/source/repeat.hpp
@@ -125,7 +125,7 @@ struct repeat_fn {
 
     template <typename T>
         requires std::movable<std::decay_t<T>>
-    constexpr auto operator()(T&& obj, std::integral auto count) const
+    constexpr auto operator()(T&& obj, num::integral auto count) const
     {
         auto c = num::checked_cast<distance_t>(count);
         if (c < 0) {

Original file line number	Diff line number	Diff line change
`@@ -298,7 +298,7 @@ struct chunk_adaptor<Base> : inline_sequence_base<chunk_adaptor<Base>> {`
`298`	`298`	`struct chunk_fn {`
`299`	`299`	`template <adaptable_sequence Seq>`
`300`	`300`	`[[nodiscard]]`
`301`		`- constexpr auto operator()(Seq&& seq, std::integral auto chunk_sz) const`
	`301`	`+ constexpr auto operator()(Seq&& seq, num::integral auto chunk_sz) const`
`302`	`302`	`-> sequence auto`
`303`	`303`	`{`
`304`	`304`	`FLUX_ASSERT(chunk_sz > 0);`
`@@ -312,7 +312,7 @@ struct chunk_fn {`
`312`	`312`	`FLUX_EXPORT inline constexpr auto chunk = detail::chunk_fn{};`
`313`	`313`
`314`	`314`	`template <typename D>`
`315`		`-constexpr auto inline_sequence_base<D>::chunk(std::integral auto chunk_sz) &&`
	`315`	`+constexpr auto inline_sequence_base<D>::chunk(num::integral auto chunk_sz) &&`
`316`	`316`	`{`
`317`	`317`	`return flux::chunk(std::move(derived()), chunk_sz);`
`318`	`318`	`}`
Original file line number	Diff line number	Diff line change
`@@ -225,7 +225,7 @@ struct cycle_fn {`
`225`	`225`	`template <adaptable_sequence Seq>`
`226`	`226`	`requires multipass_sequence<Seq>`
`227`	`227`	`[[nodiscard]]`
`228`		`- constexpr auto operator()(Seq&& seq, std::integral auto count) const`
	`228`	`+ constexpr auto operator()(Seq&& seq, num::integral auto count) const`
`229`	`229`	`-> multipass_sequence auto`
`230`	`230`	`{`
`231`	`231`	`auto c = num::checked_cast<distance_t>(count);`
`@@ -249,7 +249,7 @@ constexpr auto inline_sequence_base<D>::cycle() &&`
`249`	`249`	`}`
`250`	`250`
`251`	`251`	`template <typename D>`
`252`		`-constexpr auto inline_sequence_base<D>::cycle(std::integral auto count) &&`
	`252`	`+constexpr auto inline_sequence_base<D>::cycle(num::integral auto count) &&`
`253`	`253`	`requires multipass_sequence<D>`
`254`	`254`	`{`
`255`	`255`	`return flux::cycle(std::move(derived()), count);`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ struct drop_adaptor : inline_sequence_base<drop_adaptor<Base>> {`
`64`	`64`	`struct drop_fn {`
`65`	`65`	`template <adaptable_sequence Seq>`
`66`	`66`	`[[nodiscard]]`
`67`		`- constexpr auto operator()(Seq&& seq, std::integral auto count) const`
	`67`	`+ constexpr auto operator()(Seq&& seq, num::integral auto count) const`
`68`	`68`	`{`
`69`	`69`	`auto count_ = num::checked_cast<distance_t>(count);`
`70`	`70`	`if (count_ < 0) {`
`@@ -81,7 +81,7 @@ struct drop_fn {`
`81`	`81`	`FLUX_EXPORT inline constexpr auto drop = detail::drop_fn{};`
`82`	`82`
`83`	`83`	`template <typename Derived>`
`84`		`-constexpr auto inline_sequence_base<Derived>::drop(std::integral auto count) &&`
	`84`	`+constexpr auto inline_sequence_base<Derived>::drop(num::integral auto count) &&`
`85`	`85`	`{`
`86`	`86`	`return flux::drop(std::move(derived()), count);`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@ struct slide_fn {`
`128`	`128`	`FLUX_EXPORT inline constexpr auto slide = detail::slide_fn{};`
`129`	`129`
`130`	`130`	`template <typename D>`
`131`		`-constexpr auto inline_sequence_base<D>::slide(std::integral auto win_sz) &&`
	`131`	`+constexpr auto inline_sequence_base<D>::slide(num::integral auto win_sz) &&`
`132`	`132`	`requires multipass_sequence<D>`
`133`	`133`	`{`
`134`	`134`	`FLUX_ASSERT(win_sz > 0);`
Original file line number	Diff line number	Diff line change
`@@ -254,7 +254,7 @@ struct stride_adaptor<Base> : inline_sequence_base<stride_adaptor<Base>> {`
`254`	`254`	`struct stride_fn {`
`255`	`255`	`template <adaptable_sequence Seq>`
`256`	`256`	`[[nodiscard]]`
`257`		`- constexpr auto operator()(Seq&& seq, std::integral auto by) const`
	`257`	`+ constexpr auto operator()(Seq&& seq, num::integral auto by) const`
`258`	`258`	`{`
`259`	`259`	`FLUX_ASSERT(by > 0);`
`260`	`260`	`return stride_adaptor<std::decay_t<Seq>>(FLUX_FWD(seq),`
`@@ -267,7 +267,7 @@ struct stride_fn {`
`267`	`267`	`FLUX_EXPORT inline constexpr auto stride = detail::stride_fn{};`
`268`	`268`
`269`	`269`	`template <typename D>`
`270`		`-constexpr auto inline_sequence_base<D>::stride(std::integral auto by) &&`
	`270`	`+constexpr auto inline_sequence_base<D>::stride(num::integral auto by) &&`
`271`	`271`	`{`
`272`	`272`	`return flux::stride(std::move(derived()), by);`
`273`	`273`	`}`
Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,7 @@ struct take_adaptor : inline_sequence_base<take_adaptor<Base>>`
`148`	`148`	`struct take_fn {`
`149`	`149`	`template <adaptable_sequence Seq>`
`150`	`150`	`[[nodiscard]]`
`151`		`- constexpr auto operator()(Seq&& seq, std::integral auto count) const`
	`151`	`+ constexpr auto operator()(Seq&& seq, num::integral auto count) const`
`152`	`152`	`{`
`153`	`153`	`auto count_ = num::checked_cast<distance_t>(count);`
`154`	`154`	`if (count_ < 0) {`
`@@ -164,7 +164,7 @@ struct take_fn {`
`164`	`164`	`FLUX_EXPORT inline constexpr auto take = detail::take_fn{};`
`165`	`165`
`166`	`166`	`template <typename Derived>`
`167`		`-constexpr auto inline_sequence_base<Derived>::take(std::integral auto count) &&`
	`167`	`+constexpr auto inline_sequence_base<Derived>::take(num::integral auto count) &&`
`168`	`168`	`{`
`169`	`169`	`return flux::take(std::move(derived()), count);`
`170`	`170`	`}`
Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,7 @@ namespace detail {`
`158`	`158`	`struct make_array_ptr_unchecked_fn {`
`159`	`159`	`template <typename T>`
`160`	`160`	`requires (std::is_object_v<T> && !std::is_abstract_v<T>)`
`161`		`- constexpr auto operator()(T* ptr, std::integral auto size) const -> array_ptr<T>`
	`161`	`+ constexpr auto operator()(T* ptr, num::integral auto size) const -> array_ptr<T>`
`162`	`162`	`{`
`163`	`163`	`return array_ptr<T>(ptr, num::checked_cast<distance_t>(size));`
`164`	`164`	`}`
Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,7 @@ struct repeat_fn {`
`125`	`125`
`126`	`126`	`template <typename T>`
`127`	`127`	`requires std::movable<std::decay_t<T>>`
`128`		`- constexpr auto operator()(T&& obj, std::integral auto count) const`
	`128`	`+ constexpr auto operator()(T&& obj, num::integral auto count) const`
`129`	`129`	`{`
`130`	`130`	`auto c = num::checked_cast<distance_t>(count);`
`131`	`131`	`if (c < 0) {`