Fix constraint for Slice::data()

* ra/base.hh (Slice): As stated.
  (is_scalar): For std::integral_constant, check the type inside.

Author: lloda

docs/index.html

@@ -9,10 +9,10 @@
 @c http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0834r0.html
 @c http://open-std.org/JTC1/SC22/WG21/docs/papers/2017/p0573r2.html
 @c http://open-std.org/JTC1/SC22/WG21/docs/papers/2017/p0356r2.html
-@c References to source [ma··] or [ma···] current last is 117.
+@c References to source [ma··] or [ma···] current last is 118.
 
 @set VERSION 31
-@set UPDATED 2025 September 09
+@set UPDATED 2026 February 2
 
 @copying
 @code{ra::} (version @value{VERSION}, updated @value{UPDATED})
@@ -1027,7 +1027,7 @@ cout << f(b(0, 0)) << endl; // ok, automatic conversion from ViewBig<T *> to T &
 @end verbatim
 @end example
 
-The result of @code{A(i, ...)} when @code{A} is a view, or equivalently @code{@ref{x-from,@code{from}}(A, i ...)}, is itself be a view when
+The result of @code{A(i, ...)} when @code{A} is a view, or equivalently @code{@ref{x-from,@code{from}}(A, i ...)}, is itself a view when
 @itemize
 @item
 each of the @code{i ...} is @emph{beatable}, that is, either

docs/ra-ra.texi

@@ -100,7 +100,7 @@ struct ViewSmall
     }
 // T not is_scalar [ra44]
     constexpr ViewSmall const & operator=(T const & t) const { ra::iter(*this) = ra::scalar(t); return *this; }
-// cf RA_ASSIGNOPS_ITER [ra38] [ra34]
+// cf RA_ASSIGNOPS_ITER [ra38][ra34]
     ViewSmall const & operator=(ViewSmall const & x) const { ra::iter(*this) = x; return *this; }
 #define RA_ASSIGNOPS(OP)                                                   \
     constexpr ViewSmall const & operator OP(auto const & x) const { ra::iter(*this) OP x; return *this; } \
@@ -309,7 +309,7 @@ struct ViewBig
 #undef RA_BRACES
 // T not is_scalar [ra44]
     constexpr ViewBig const & operator=(T const & t) const { ra::iter(*this) = ra::scalar(t); return *this; }
-// cf RA_ASSIGNOPS_ITER [ra38] [ra34]
+// cf RA_ASSIGNOPS_ITER [ra38][ra34]
     ViewBig const & operator=(ViewBig const & x) const { ra::iter(*this) = x; return *this; }
 #define RA_ASSIGNOPS(OP)                                                \
     constexpr ViewBig const & operator OP (auto const & x) const { ra::iter(*this) OP x; return *this; } \

ra/arrays.hh

@@ -210,7 +210,7 @@ struct complement_sorted_list_<tuple<S0, S ...>, tuple<T0, T ...>>
     using type = cons<T0, complement_sorted_list<tuple<S0, S ...>, tuple<T ...>>>;
 };
 
-// Like complement_list where the second argument is [0 .. end-1].
+// Like complement_list where the second arg is [0 .. end-1].
 template <class S, int end> using complement = complement_sorted_list<S, iota<end>>;
 
 // Prepend element to each of a list of lists.
@@ -277,10 +277,9 @@ struct mapanticomb<std::tuple<C ...>, D>
     using type = std::tuple<typename anticomb<C, D>::type ...>;
 };
 
-template <int D, int O>
-struct choose_
+template <int D, int O> struct choose_
 {
-    static_assert(D>=O, "Bad dimension or form order.");
+    static_assert(D>=O, "Bad args to choose_.");
     using type = combs<iota<D>, O>;
 };
 
@@ -289,7 +288,7 @@ template <int D, int O> using choose = typename choose_<D, O>::type;
 template <int D, int O> requires ((D>1) && (2*O>D))
 struct choose_<D, O>
 {
-    static_assert(D>=O, "Bad dimension or form order.");
+    static_assert(D>=O, "Bad args to choose_.");
     using type = typename mapanticomb<choose<D, D-O>, D>::type;
 };
 
@@ -342,15 +341,41 @@ struct default_init_allocator: public A
 
 template <class T> using vector_default_init = std::vector<T, default_init_allocator<T>>;
 
+// FIXME c++26 p2841 ?
+#define RA_IS_DEF(NAME, PRED)                                           \
+    template <class A> constexpr bool RA_JOIN(NAME, _def) = requires { requires PRED; }; \
+    template <class A> concept NAME = RA_JOIN(NAME, _def)<std::decay_t< A >>;
+
+// Contextual len, a unique object.
+constexpr struct Len
+{
+    consteval static rank_t rank() { return 0; }
+    [[noreturn]] consteval static void len_out_of_context() { std::abort(); }
+    consteval static dim_t len_s(int k) { len_out_of_context(); }
+    consteval static dim_t len(int k) { len_out_of_context(); }
+    consteval static dim_t step(int k) { len_out_of_context(); }
+    consteval static void adv(rank_t k, dim_t d) { len_out_of_context(); }
+    consteval static bool keep(dim_t st, int z, int j) { len_out_of_context(); }
+    consteval dim_t operator*() const { len_out_of_context(); }
+    consteval static int save() { len_out_of_context(); }
+    consteval static void load(int) { len_out_of_context(); }
+    consteval static void mov(dim_t d) { len_out_of_context(); }
+} len;
+
+template <class E> struct WLen; // defined in ply.hh. FIXME C++ p2481
+template <class E> concept has_len = requires(int ln, E && e) { WLen<std::decay_t<E>>::f(ln, RA_FW(e)); };
+RA_IS_DEF(is_special, false) // rank-0 types that we don't want reduced.
+template <has_len E> constexpr bool is_special_def<E> = true;
+
 template <class A>
-concept Iterator = requires (A a, rank_t k, dim_t d, rank_t i, rank_t j)
+concept Iterator = requires (A a, rank_t k, dim_t d, rank_t i)
 {
     { a.rank() } -> std::same_as<rank_t>;
     { std::decay_t<A>::len_s(k) } -> std::same_as<dim_t>;
     { a.len(k) } -> std::same_as<dim_t>;
     { a.adv(k, d) } -> std::same_as<void>;
     { a.step(k) };
-    { a.keep(d, i, j) } -> std::same_as<bool>;
+    { a.keep(d, k, i) } -> std::same_as<bool>;
     { a.save() };
     { a.load(std::declval<decltype(a.save())>()) } -> std::same_as<void>;
     { a.mov(d) } -> std::same_as<void>;
@@ -362,16 +387,12 @@ concept Slice = requires (A a)
 {
     { a.rank() } -> std::same_as<rank_t>;
     { a.iter() } -> Iterator;
-    { a.data() }; // -> has_len || std::bidirectional_iterator;
+    requires has_len<decltype(a.data())> || std::bidirectional_iterator<decltype(a.data())>;
     { a.dimv };
 };
 
-// FIXME c++26 p2841 ?
-#define RA_IS_DEF(NAME, PRED)                                           \
-    template <class A> constexpr bool RA_JOIN(NAME, _def) = requires { requires PRED; }; \
-    template <class A> concept NAME = RA_JOIN(NAME, _def)<std::decay_t< A >>;
-
-RA_IS_DEF(is_scalar, !std::is_pointer_v<A> && std::is_scalar_v<A> || is_ctype<A>)
+RA_IS_DEF(is_scalar, !std::is_pointer_v<A> && std::is_scalar_v<A>);
+template <class T, T v> constexpr bool is_scalar_def<std::integral_constant<T, v>> = is_scalar<T>;
 template <> constexpr bool is_scalar_def<std::strong_ordering> = true;
 template <> constexpr bool is_scalar_def<std::weak_ordering> = true;
 template <> constexpr bool is_scalar_def<std::partial_ordering> = true;
@@ -414,10 +435,9 @@ rank(auto const & v)
     }
 }
 
-// all args rank 0 (apply immediately), but at least one ra:: (disambiguate scalar version).
+// All args rank 0 (apply immediately), but at least one ra:: (disambiguate scalar version).
 template <class A> concept is_ra_pos = is_ra<A> && 0!=rank_s<A>();
 template <class A> concept is_ra_0 = (is_ra<A> && 0==rank_s<A>()) || is_scalar<A>;
-RA_IS_DEF(is_special, false) // rank-0 types that we don't want reduced.
 template <class ... A> constexpr bool toreduce = (!is_scalar<A> || ...) && ((is_ra_0<A> && !is_special<A>) && ...);
 template <class ... A> constexpr bool tomap = ((is_ra_pos<A> || is_special<A>) || ...) && ((is_ra<A> || is_scalar<A> || is_fov<A> || is_builtin<A>) && ...);
 

ra/base.hh

@@ -59,39 +59,6 @@ namespace ra {
     constexpr TYPE(TYPE const & x) = default;                           \
     RA_FE(RA_ASSIGNOPS_DEFAULT, =, *=, +=, -=, /=)
 
-// Contextual len, a unique object. See wlen in arrays.hh
-
-constexpr struct Len
-{
-    consteval static rank_t rank() { return 0; }
-    [[noreturn]] consteval static void len_out_of_context() { std::abort(); }
-    consteval static dim_t len_s(int k) { len_out_of_context(); }
-    consteval static dim_t len(int k) { len_out_of_context(); }
-    consteval static dim_t step(int k) { len_out_of_context(); }
-    consteval static void adv(rank_t k, dim_t d) { len_out_of_context(); }
-    consteval static bool keep(dim_t st, int z, int j) { len_out_of_context(); }
-    consteval dim_t operator*() const { len_out_of_context(); }
-    consteval static int save() { len_out_of_context(); }
-    consteval static void load(int) { len_out_of_context(); }
-    consteval static void mov(dim_t d) { len_out_of_context(); }
-} len;
-
-template <class E> struct WLen; // defined in ply.hh. FIXME C++ p2481
-template <class E> concept has_len = requires(int ln, E && e) { WLen<std::decay_t<E>>::f(ln, RA_FW(e)); };
-template <has_len E> constexpr bool is_special_def<E> = true; // protect exprs with Len from reduction.
-
-template <class Ln, class E>
-constexpr decltype(auto)
-wlen(Ln ln, E && e)
-{
-    static_assert(std::is_integral_v<Ln> || is_ctype<Ln>);
-    if constexpr (has_len<E>) {
-        return WLen<std::decay_t<E>>::f(ln, RA_FW(e));
-    } else {
-        return RA_FW(e);
-    }
-}
-
 template <class N> constexpr auto
 maybe_any = []{ if constexpr (is_ctype<N>) { return N::value; } else { return ANY; } }();
 
@@ -147,7 +114,7 @@ struct Scalar final
     constexpr static void adv(rank_t k, dim_t d) {}
     constexpr static bool keep(dim_t st, int z, int j) { return true; }
     constexpr decltype(auto) at(auto && i) const { return c; }
-    constexpr std::conditional_t<std::is_lvalue_reference_v<C>, C, C const &> operator*() const { return c; } // [ra24] [ra37] [ra39]
+    constexpr std::conditional_t<std::is_lvalue_reference_v<C>, C, C const &> operator*() const { return c; } // [ra24][ra37][ra39]
     consteval static int save() { return 0; }
     constexpr static void load(int) {}
     constexpr static void mov(dim_t d) {}
@@ -165,7 +132,6 @@ constexpr decltype(auto) iter(is_iterator auto && a) { return RA_FW(a); }
 // Cell doesn't retain rvalues [ra4]. If both Slice and Iterator (Ptr), go as Iterator.
 // TODO any exprs? runtime cr? ra::len in cr?
 template <int cr=0> constexpr auto iter(Slice auto && a) requires (!is_iterator<decltype(a)>) { return RA_FW(a).template iter<cr>(); }
-
 // forward decl.
 constexpr auto iter(is_fov auto && a);
 constexpr auto iter(is_builtin auto && a);

ra/expr.hh

@@ -247,6 +247,18 @@ constexpr auto range(is_ra auto && a) requires (requires { a.begin(); }) { stati
 // Replace Len in expr tree. VAL arguments that must be either is_ctype or is_scalar.
 // ---------------------
 
+template <class Ln, class E>
+constexpr decltype(auto)
+wlen(Ln ln, E && e)
+{
+    static_assert(std::is_integral_v<Ln> || is_ctype<Ln>);
+    if constexpr (has_len<E>) {
+        return WLen<std::decay_t<E>>::f(ln, RA_FW(e));
+    } else {
+        return RA_FW(e);
+    }
+}
+
 template <>
 struct WLen<Len>
 {

ra/ply.hh

@@ -9,8 +9,8 @@
 
 #if 0==RA_CHECK
   #undef RA_CHECK
+  #define RA_CHECK 1 // required by 'regression from test/checks' below
 #endif
-#define RA_CHECK 1 // required by 'regression from test/checks' below
 
 #include <iostream>
 #include "ra/base.hh"