[misc] better handling of infinite ranges

Author: h-2

include/radr/concepts.hpp

@@ -80,6 +80,13 @@ concept weak_indirect_unary_invocable =
                              std::invoke_result_t<F &, std::iter_reference_t<I>>>;
 //TODO implement P2609
 
+template <typename Rng>
+concept infinite_mp_range = mp_range<Rng> && std::same_as<std::ranges::sentinel_t<Rng>, std::unreachable_sentinel_t>;
+
+template <typename Rng>
+concept safely_indexable_range =
+  std::ranges::random_access_range<Rng> && (std::ranges::sized_range<Rng> || infinite_mp_range<Rng>);
+
 } // namespace radr
 
 namespace radr::detail

include/radr/custom/subborrow.hpp

@@ -17,6 +17,7 @@
 #include "../detail/detail.hpp"
 #include "../rad_util/borrowing_rad.hpp"
 #include "../range_access.hpp"
+#include "radr/concepts.hpp"
 #include "tags.hpp"
 
 namespace radr::custom
@@ -218,10 +219,13 @@ struct subborrow_impl_t
 
     //!\brief Call tag_invoke if possible; call default otherwise. [i, j]
     template <borrowed_mp_range URange>
-        requires(std::ranges::random_access_range<URange> && std::ranges::sized_range<URange>)
+        requires(safely_indexable_range<URange>)
     constexpr auto operator()(URange && urange, size_t const start, size_t const end) const
     {
-        size_t const e = std::min<size_t>(end, std::ranges::size(urange));
+        size_t e = end;
+        if constexpr (std::ranges::sized_range<URange>)
+            e = std::min<size_t>(e, std::ranges::size(urange));
+
         size_t const b = std::min<size_t>(start, e);
 
         return operator()(std::forward<URange>(urange), radr::begin(urange) + b, radr::begin(urange) + e);
@@ -243,17 +247,10 @@ using subborrow_t = decltype(subborrow(std::declval<Args>()...));
 inline constexpr auto borrow =
   detail::overloaded{[]<borrowed_mp_range URange>(URange && urange)
 {
-    if constexpr (std::ranges::sized_range<URange>)
-    {
-        return subborrow(std::forward<URange>(urange),
-                         radr::begin(urange),
-                         radr::end(urange),
-                         std::ranges::size(urange));
-    }
-    else
-    {
-        return subborrow(std::forward<URange>(urange), radr::begin(urange), radr::end(urange));
-    }
+    return subborrow(std::forward<URange>(urange),
+                     radr::begin(urange),
+                     radr::end(urange),
+                     detail::size_or_not(urange));
 },
     // if a range is already borrowed and copyable, just copy it (we assume O(1) copy)
     // BUT do not do this if a copy would result in a constant_range becoming a mutable range

include/radr/factory/iota.hpp

@@ -260,17 +260,26 @@ struct iota_fn
         static_assert(std::incrementable<Value>, "The Value type to radr::iota needs to satisfy std::incrementable.");
         static_assert(weakly_equality_comparable_with<Value, Bound>,
                       "The Value type to radr::iota needs to be comparable with the Bound type.");
-        static_assert(std::semiregular<Bound>, "The Bound type to radr::iota needs to satisfy std::regular.");
+        static_assert(std::semiregular<Bound>, "The Bound type to radr::iota needs to satisfy std::semiregular.");
 
-        using It  = detail::iota_iterator<Value>;
-        using Sen = std::conditional_t<std::same_as<Value, Bound>, It, detail::iota_sentinel<Value, Bound>>;
+        using It = detail::iota_iterator<Value>;
+        if constexpr (std::same_as<Bound, std::unreachable_sentinel_t>)
+        {
+            return borrowing_rad<It, std::unreachable_sentinel_t, It, std::unreachable_sentinel_t>{
+              It{val},
+              std::unreachable_sentinel};
+        }
+        else
+        {
+            using Sen = std::conditional_t<std::same_as<Value, Bound>, It, detail::iota_sentinel<Value, Bound>>;
 
-        constexpr borrowing_rad_kind kind =
-          ((std::random_access_iterator<It> && std::same_as<It, Sen>) || std::sized_sentinel_for<Bound, Value>)
-            ? borrowing_rad_kind::sized
-            : borrowing_rad_kind::unsized;
+            constexpr borrowing_rad_kind kind =
+              ((std::random_access_iterator<It> && std::same_as<It, Sen>) || std::sized_sentinel_for<Bound, Value>)
+                ? borrowing_rad_kind::sized
+                : borrowing_rad_kind::unsized;
 
-        return borrowing_rad<It, Sen, It, Sen, kind>{It{val}, Sen{bound}};
+            return borrowing_rad<It, Sen, It, Sen, kind>{It{val}, Sen{bound}};
+        }
     }
 };
 

include/radr/factory/repeat.hpp

@@ -226,7 +226,7 @@ using constant_t = std::integral_constant<decltype(v), v>;
  * dimensions: \p Bound and \p storage.
  *
  * All instantiations of `repeat_rng` model at least std::semiregular, std::ranges::random_access_range and
- * radr::const_iterable.
+ * radr::mp_range.
  *
  * ## Bound
  *

include/radr/rad/as_const.hpp

@@ -17,20 +17,14 @@
 #include "../custom/subborrow.hpp"
 #include "../detail/detail.hpp"
 #include "../detail/pipe.hpp"
+#include "radr/range_access.hpp"
 
 namespace radr::detail
 {
 
 inline constexpr auto as_const_borrow = []<borrowed_mp_range URange>(URange && urange)
 {
-    if constexpr (std::ranges::sized_range<URange>)
-    {
-        return radr::subborrow(urange, radr::cbegin(urange), radr::cend(urange), std::ranges::size(urange));
-    }
-    else
-    {
-        return radr::subborrow(urange, radr::cbegin(urange), radr::cend(urange));
-    }
+    return radr::subborrow(urange, radr::cbegin(urange), radr::cend(urange), detail::size_or_not(urange));
 };
 
 } // namespace radr::detail

include/radr/rad/slice.hpp

@@ -24,7 +24,7 @@ namespace radr::detail
 inline constexpr auto slice_borrow =
   []<std::ranges::borrowed_range URange>(URange && urange, size_t const start, size_t const end)
 {
-    if constexpr (std::ranges::random_access_range<URange> && std::ranges::sized_range<URange>)
+    if constexpr (safely_indexable_range<URange>)
     {
         return subborrow(std::forward<URange>(urange), start, end);
     }

include/radr/rad/take.hpp

@@ -16,6 +16,7 @@
 #include "../detail/pipe.hpp"
 #include "../generator.hpp"
 #include "../rad_util/borrowing_rad.hpp"
+#include "radr/concepts.hpp"
 
 namespace radr::detail
 {
@@ -99,7 +100,7 @@ inline constexpr auto take_borrow =
     }
 },
              []<borrowed_mp_range URange>(URange && urange, range_size_t_or_size_t<URange> n)
-                 requires(std::ranges::random_access_range<URange> && std::ranges::sized_range<URange>)
+                 requires(safely_indexable_range<URange>)
 {
     return subborrow(std::forward<URange>(urange), 0ull, n);
 }};

tests/unit/factory/iota.cpp

@@ -8,6 +8,7 @@
 #include <radr/test/gtest_helpers.hpp>
 
 #include <radr/factory/iota.hpp>
+#include <radr/rad/take.hpp>
 #include <radr/rad/take_while.hpp>
 #include <radr/rad/transform.hpp>
 
@@ -74,6 +75,20 @@ TEST(iota, InfiniteRange)
     EXPECT_TRUE(std::ranges::borrowed_range<decltype(v)>);
 }
 
+TEST(iota, InfiniteRangeTake)
+{
+    auto v  = radr::iota(0) | radr::take(5);
+    auto it = v.begin();
+    EXPECT_EQ(*it, 0);
+    EXPECT_EQ(*(++it), 1);
+    EXPECT_EQ(*(++it), 2);
+
+    EXPECT_TRUE(std::ranges::sized_range<decltype(v)>);
+    EXPECT_TRUE(std::ranges::random_access_range<decltype(v)>);
+    EXPECT_TRUE(std::ranges::common_range<decltype(v)>);
+    EXPECT_TRUE(std::ranges::borrowed_range<decltype(v)>);
+}
+
 TEST(iota, IotaWithCharType)
 {
     auto        v = radr::iota('a', 'f');

tests/unit/factory/repeat.cpp

@@ -395,3 +395,16 @@ TYPED_TEST(repeat_rng, subborrow_infinite_size)
         }
     }
 }
+
+TYPED_TEST(repeat_rng, take)
+{
+    int i = 3;
+
+    TypeParam r{i, TestFixture::get_bound()};
+
+    auto rad = std::move(r) | radr::take(2);
+
+    EXPECT_TRUE(std::ranges::sized_range<decltype(rad)>);
+    EXPECT_TRUE(radr::common_range<decltype(rad)>);
+    EXPECT_EQ(std::ranges::size(rad), 2);
+}