Rename Expr to Map

This way Map/map follows the pattern of Pick/pick, and we save names. This is
all internal.

* ra/expr.hh (Map): As stated.
  (pick_at, pick_star): Golfing in return types.

Elsewhere reuse users in tests and such.

Author: lloda

TODO

@@ -77,10 +77,10 @@ checkbox [C-ct] flip TODO
       - This has become more feasible after changing the iterator interface from flat to saveload,
         main obstacle atm seems to be the need to support copy. <2023-11-20 Mon 12:45>
       - One can now create a ravel iterator from an IteratorConcept <2023-11-28 Tue 16:37>
-    - [ ] gemv(conj(a), b) should work. Beat View-like selectors down an Expr??
+    - [ ] gemv(conj(a), b) should work. Beat View-like selectors down a Map??
     - [ ] port some of the View ops to generic Iterator. reverse, transpose, etc. seem easy
-      enough. Only it kind of bothers me that they need their own Expr-like types while on Views
-      it's just a one time op. Propagating ops down Expr into leaf Views (a kind of beating) would
+      enough. Only it kind of bothers me that they need their own Map-like types while on Views
+      it's just a one time op. Propagating ops down Map into leaf Views (a kind of beating) would
       be better.
     - [X] Support operator <=> <2020-09-15 Tue 13:50>
       - https://gcc.gnu.org/bugzilla/show_bug.cgi?id=96278 is annoying

docs/index.html

@@ -1996,7 +1996,7 @@ These are array types that own their data in one way or another.
 
 These are array views into data in memory, which may be writable. Any of the @b{Container} types can be treated as a @b{View}, but one may also create @b{View}s into memory that has been allocated independently.
 
-@item @b{Iterator} --- @code{CellBig}, @code{CellSmall}, @code{Iota}, @code{Ptr}, @code{Scalar}, @code{Expr}, @code{Pick}
+@item @b{Iterator} --- @code{CellBig}, @code{CellSmall}, @code{Iota}, @code{Ptr}, @code{Scalar}, @code{Map}, @code{Pick}
 
 This is a traversable object. @b{Iterator}s are accepted by all the array functions such as @code{map}, @code{for_each}, etc. @code{map} produces an @b{Iterator} itself, so most array expressions are @b{Iterator}s. @b{Iterator}s are created from @b{View}s and from certain foreign array-like types primarily through the function @code{start}. This is done automatically when those types are used in array expressions.
 

docs/ra-ra.texi

@@ -157,7 +157,7 @@ rank(auto const & v)
 RA_IS_DEF(is_pos, 0!=rank_s<A>())
 template <class A> concept is_ra_pos = is_ra<A> && is_pos<A>;
 template <class A> concept is_zero_or_scalar = (is_ra<A> && !is_pos<A>) || is_scalar<A>;
-// all args rank 0 (immediate application), but at least one ra:: (don't collide with the scalar version).
+// all args rank 0 (apply immediately), but at least one ra:: (disambiguate scalar version).
 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_zero_or_scalar<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_array<A>) && ...);

ra/base.hh

@@ -389,7 +389,7 @@ struct Match<checkp, std::tuple<P ...>, mp::int_list<I ...>>
 #pragma GCC diagnostic warning "-Warray-bounds"
                 dim_t ls = len(k);
 #pragma GCC diagnostic pop
-                if (((k<ra::rank(std::get<I>(t)) && ls!=choose_len(std::get<I>(t).len(k), ls)) || ...)) {
+                if (((k<ra::rank(get<I>(t)) && ls!=choose_len(get<I>(t).len(k), ls)) || ...)) {
                     return false;
                 }
             }
@@ -419,7 +419,7 @@ struct Match<checkp, std::tuple<P ...>, mp::int_list<I ...>>
     rank() const requires (ANY==rs)
     {
         rank_t r = BAD;
-        ((r = choose_rank(r, ra::rank(std::get<I>(t)))), ...);
+        ((r = choose_rank(r, ra::rank(get<I>(t)))), ...);
         assert(ANY!=r); // not at runtime
         return r;
     }
@@ -445,34 +445,34 @@ struct Match<checkp, std::tuple<P ...>, mp::int_list<I ...>>
         auto f = [&k](dim_t s, auto const & a) {
             return k<ra::rank(a) ? choose_len(s, a.len(k)) : s;
         };
-        dim_t s = BAD; ((s>=0 ? s : s = f(s, std::get<I>(t))), ...);
+        dim_t s = BAD; ((s>=0 ? s : s = f(s, get<I>(t))), ...);
         assert(ANY!=s); // not at runtime
         return s;
     }
 // could preserve static, but ply doesn't use it atm.
     constexpr auto
     step(int i) const
     {
-        return std::make_tuple(std::get<I>(t).step(i) ...);
+        return std::make_tuple(get<I>(t).step(i) ...);
     }
     constexpr void
     adv(rank_t k, dim_t d)
     {
-        (std::get<I>(t).adv(k, d), ...);
+        (get<I>(t).adv(k, d), ...);
     }
     constexpr bool
     keep(dim_t st, int z, int j) const requires (!(requires { P::keep(st, z, j); }  && ...))
     {
-        return (std::get<I>(t).keep(st, z, j) && ...);
+        return (get<I>(t).keep(st, z, j) && ...);
     }
     constexpr static bool
     keep(dim_t st, int z, int j) requires (requires { P::keep(st, z, j); } && ...)
     {
         return (std::decay_t<P>::keep(st, z, j) && ...);
     }
-    constexpr auto save() const { return std::make_tuple(std::get<I>(t).save() ...); }
-    constexpr void load(auto const & pp) { ((std::get<I>(t).load(std::get<I>(pp))), ...); }
-    constexpr void mov(auto const & s) { ((std::get<I>(t).mov(std::get<I>(s))), ...); }
+    constexpr auto save() const { return std::make_tuple(get<I>(t).save() ...); }
+    constexpr void load(auto const & pp) { ((get<I>(t).load(get<I>(pp))), ...); }
+    constexpr void mov(auto const & s) { ((get<I>(t).mov(get<I>(s))), ...); }
 };
 
 
@@ -633,12 +633,17 @@ struct Framematch_def<V, std::tuple<Ti ...>, std::tuple<Ri ...>, skip>
 // explicit agreement checks
 // ---------------
 
+template <bool checkp, class ... P>
+constexpr auto
+match(P && ... p) { return Match<checkp, std::tuple<P ...>> { RA_FWD(p) ... }; }
+
+template <class ... P>
 constexpr bool
-agree(auto && ... p) { return agree_(ra::start(RA_FWD(p)) ...); }
+agree(P && ... p) { return match<false>(ra::start(RA_FWD(p)) ...).check(); }
 
-// 0: fail, 1: rt, 2: pass
+template <class ... P>
 constexpr int
-agree_s(auto && ... p) { return agree_s_(ra::start(RA_FWD(p)) ...); }
+agree_s(P && ... p) { return decltype(match<false>(ra::start(RA_FWD(p)) ...))::check_s(); }
 
 template <class Op, class ... P> requires (is_verb<Op>)
 constexpr bool
@@ -648,14 +653,6 @@ template <class Op, class ... P> requires (!is_verb<Op>)
 constexpr bool
 agree_op(Op && op, P && ... p) { return agree(RA_FWD(p) ...); }
 
-template <class ... P>
-constexpr bool
-agree_(P && ... p) { return (Match<false, std::tuple<P ...>> { RA_FWD(p) ... }).check(); }
-
-template <class ... P>
-constexpr int
-agree_s_(P && ... p) { return Match<false, std::tuple<P ...>>::check_s(); }
-
 template <class V, class ... T, int ... i>
 constexpr bool
 agree_verb(mp::int_list<i ...>, V && v, T && ... t)
@@ -672,89 +669,82 @@ agree_verb(mp::int_list<i ...>, V && v, T && ... t)
 template <class E>
 decltype(auto) to_scalar(E && e)
 {
-    if constexpr (1!=size_s(e)) {
+    if constexpr (constexpr dim_t s=size_s(e); 1!=s) {
+        static_assert(ANY==s, "Bad scalar conversion from shape.");
         RA_CHECK(1==size(e), "Bad scalar conversion from shape [", fmt(nstyle, ra::shape(e)), "].");
     }
     return *e;
 }
 
-template <class Op, class T, class K=mp::iota<mp::len<T>>> struct Expr;
+template <class Op, class T, class K=mp::iota<mp::len<T>>> struct Map;
 template <class Op, IteratorConcept ... P, int ... I>
-struct Expr<Op, std::tuple<P ...>, mp::int_list<I ...>>: public Match<true, std::tuple<P ...>>
+struct Map<Op, std::tuple<P ...>, mp::int_list<I ...>>: public Match<true, std::tuple<P ...>>
 {
     using Match_ = Match<true, std::tuple<P ...>>;
     using Match_::t;
     Op op;
 
-    constexpr Expr(Op op_, P ... p_): Match_(p_ ...), op(op_) {} // [ra1]
-    RA_ASSIGNOPS_SELF(Expr)
+    constexpr Map(Op op_, P ... p_): Match_(p_ ...), op(op_) {} // [ra1]
+    RA_ASSIGNOPS_SELF(Map)
     RA_ASSIGNOPS_DEFAULT_SET
-    constexpr decltype(auto) at(auto const & j) const { return std::invoke(op, std::get<I>(t).at(j) ...); }
-    constexpr decltype(auto) operator*() const { return std::invoke(op, *std::get<I>(t) ...); }
-    constexpr operator decltype(std::invoke(op, *std::get<I>(t) ...)) () const { return to_scalar(*this); }
+    constexpr decltype(auto) at(auto const & j) const { return std::invoke(op, get<I>(t).at(j) ...); }
+    constexpr decltype(auto) operator*() const { return std::invoke(op, *get<I>(t) ...); }
+    constexpr operator decltype(std::invoke(op, *get<I>(t) ...)) () const { return to_scalar(*this); }
 };
 
 template <class Op, IteratorConcept ... P>
-constexpr bool is_special_def<Expr<Op, std::tuple<P ...>>> = (is_special<P> || ...);
+constexpr bool is_special_def<Map<Op, std::tuple<P ...>>> = (is_special<P> || ...);
 
-template <class V, class ... T, int ... i>
+template <class Op, class ... P, int ... i>
 constexpr auto
-expr_verb(mp::int_list<i ...>, V && v, T && ... t)
+map_verb(mp::int_list<i ...>, Op && op, P && ... p)
 {
-    using FM = Framematch<V, std::tuple<T ...>>;
-    return expr(FM::op(RA_FWD(v)), reframe<mp::ref<typename FM::R, i>>(RA_FWD(t)) ...);
+    using FM = Framematch<Op, std::tuple<P ...>>;
+    return map_(FM::op(RA_FWD(op)), reframe<mp::ref<typename FM::R, i>>(RA_FWD(p)) ...);
 }
 
 template <class Op, class ... P>
 constexpr auto
-expr(Op && op, P && ... p)
+map_(Op && op, P && ... p)
 {
     if constexpr (is_verb<Op>) {
-        return expr_verb(mp::iota<sizeof...(P)> {}, RA_FWD(op), RA_FWD(p) ...);
+        return map_verb(mp::iota<sizeof...(P)> {}, RA_FWD(op), RA_FWD(p) ...);
     } else {
-        return Expr<Op, std::tuple<P ...>> { RA_FWD(op), RA_FWD(p) ... };
+        return Map<Op, std::tuple<P ...>> { RA_FWD(op), RA_FWD(p) ... };
     }
 }
 
 constexpr auto
-map(auto && op, auto && ... a) { return expr(RA_FWD(op), start(RA_FWD(a)) ...); }
+map(auto && op, auto && ... a) { return map_(RA_FWD(op), start(RA_FWD(a)) ...); }
 
 
 // ---------------------------
 // pick expression
 // ---------------------------
 
-template <class T, class J> struct pick_at_type;
-template <class ... P, class J> struct pick_at_type<std::tuple<P ...>, J>
-{
-    using type = std::common_reference_t<decltype(std::declval<P>().at(std::declval<J>())) ...>;
-};
+template <class J> struct type_at { template <class P> using type = decltype(std::declval<P>().at(std::declval<J>())); };
 
 template <std::size_t I, class T, class J>
-constexpr pick_at_type<mp::drop1<std::decay_t<T>>, J>::type
+constexpr mp::apply<std::common_reference_t, mp::map<type_at<J>::template type, mp::drop1<std::decay_t<T>>>>
 pick_at(std::size_t p0, T && t, J const & j)
 {
     constexpr std::size_t N = mp::len<std::decay_t<T>> - 1;
     if constexpr (I < N) {
-        return (p0==I) ? std::get<I+1>(t).at(j) : pick_at<I+1>(p0, t, j);
+        return (p0==I) ? get<I+1>(t).at(j) : pick_at<I+1>(p0, t, j);
     } else {
         RA_CHECK(p0 < N, "Bad pick ", p0, " with ", N, " arguments."); std::abort();
     }
 }
 
-template <class T> struct pick_star_type;
-template <class ... P> struct pick_star_type<std::tuple<P ...>>
-{
-    using type = std::common_reference_t<decltype(*std::declval<P>()) ...>;
-};
+template <class P> using type_star = decltype(*std::declval<P>());
 
 template <std::size_t I, class T>
-constexpr pick_star_type<mp::drop1<std::decay_t<T>>>::type
+constexpr mp::apply<std::common_reference_t, mp::map<type_star, mp::drop1<std::decay_t<T>>>>
 pick_star(std::size_t p0, T && t)
 {
     constexpr std::size_t N = mp::len<std::decay_t<T>> - 1;
     if constexpr (I < N) {
-        return (p0==I) ? *(std::get<I+1>(t)) : pick_star<I+1>(p0, t);
+        return (p0==I) ? *(get<I+1>(t)) : pick_star<I+1>(p0, t);
     } else {
         RA_CHECK(p0 < N, "Bad pick ", p0, " with ", N, " arguments."); std::abort();
     }
@@ -771,9 +761,9 @@ struct Pick<std::tuple<P ...>, mp::int_list<I ...>>: public Match<true, std::tup
     constexpr Pick(P ... p_): Match_(p_ ...) {} // [ra1]
     RA_ASSIGNOPS_SELF(Pick)
     RA_ASSIGNOPS_DEFAULT_SET
-    constexpr decltype(auto) at(auto const & j) const { return pick_at<0>(std::get<0>(t).at(j), t, j); }
-    constexpr decltype(auto) operator*() const { return pick_star<0>(*std::get<0>(t), t); }
-    constexpr operator decltype(pick_star<0>(*std::get<0>(t), t)) () const { return to_scalar(*this); }
+    constexpr decltype(auto) at(auto const & j) const { return pick_at<0>(get<0>(t).at(j), t, j); }
+    constexpr decltype(auto) operator*() const { return pick_star<0>(*get<0>(t), t); }
+    constexpr operator decltype(pick_star<0>(*get<0>(t), t)) () const { return to_scalar(*this); }
 };
 
 template <IteratorConcept ... P>

ra/expr.hh

@@ -45,12 +45,12 @@ struct WLen<Len>
 };
 
 template <class Op, IteratorConcept ... P, int ... I> requires (has_len<P> || ...)
-struct WLen<Expr<Op, std::tuple<P ...>, mp::int_list<I ...>>>
+struct WLen<Map<Op, std::tuple<P ...>, mp::int_list<I ...>>>
 {
     constexpr static decltype(auto)
     f(auto ln, auto && e)
     {
-        return expr(RA_FWD(e).op, wlen(ln, std::get<I>(RA_FWD(e).t)) ...);
+        return map_(RA_FWD(e).op, wlen(ln, std::get<I>(RA_FWD(e).t)) ...);
     }
 };
 

ra/ply.hh

@@ -38,9 +38,9 @@ template <class T> constexpr void cast(ra::noarg);
 using std::max, std::min, std::abs, std::fma, std::sqrt, std::pow, std::exp, std::swap,
       std::isfinite, std::isinf, std::isnan, std::clamp, std::lerp, std::conj, std::expm1;
 
-#define FOR_FLOAT(T)                                      \
-    constexpr T conj(T x) { return x; }                   \
-FOR_EACH(FOR_FLOAT, float, double)
+#define FOR_FLOAT(T)                            \
+    constexpr T conj(T x) { return x; }         \
+    FOR_EACH(FOR_FLOAT, float, double)
 #undef FOR_FLOAT
 
 #define FOR_FLOAT(R)                                                    \
@@ -148,47 +148,47 @@ template <class X> concept iota_op = ra::is_zero_or_scalar<X> && std::is_arithme
 
 template <is_iota I, iota_op J>
 constexpr auto
-optimize(Expr<std::plus<>, std::tuple<I, J>> && e)
+optimize(Map<std::plus<>, std::tuple<I, J>> && e)
 { return ra::iota(ITEM(0).n, ITEM(0).i+ITEM(1), ITEM(0).s); }
 
 template <iota_op I, is_iota J>
 constexpr auto
-optimize(Expr<std::plus<>, std::tuple<I, J>> && e)
+optimize(Map<std::plus<>, std::tuple<I, J>> && e)
 { return ra::iota(ITEM(1).n, ITEM(0)+ITEM(1).i, ITEM(1).s); }
 
 template <is_iota I, is_iota J>
 constexpr auto
-optimize(Expr<std::plus<>, std::tuple<I, J>> && e)
+optimize(Map<std::plus<>, std::tuple<I, J>> && e)
 { return ra::iota(maybe_len(e), ITEM(0).i+ITEM(1).i, ITEM(0).s+ITEM(1).s); }
 
 template <is_iota I, iota_op J>
 constexpr auto
-optimize(Expr<std::minus<>, std::tuple<I, J>> && e)
+optimize(Map<std::minus<>, std::tuple<I, J>> && e)
 { return ra::iota(ITEM(0).n, ITEM(0).i-ITEM(1), ITEM(0).s); }
 
 template <iota_op I, is_iota J>
 constexpr auto
-optimize(Expr<std::minus<>, std::tuple<I, J>> && e)
+optimize(Map<std::minus<>, std::tuple<I, J>> && e)
 { return ra::iota(ITEM(1).n, ITEM(0)-ITEM(1).i, -ITEM(1).s); }
 
 template <is_iota I, is_iota J>
 constexpr auto
-optimize(Expr<std::minus<>, std::tuple<I, J>> && e)
+optimize(Map<std::minus<>, std::tuple<I, J>> && e)
 { return ra::iota(maybe_len(e), ITEM(0).i-ITEM(1).i, ITEM(0).s-ITEM(1).s); }
 
 template <is_iota I, iota_op J>
 constexpr auto
-optimize(Expr<std::multiplies<>, std::tuple<I, J>> && e)
+optimize(Map<std::multiplies<>, std::tuple<I, J>> && e)
 { return ra::iota(ITEM(0).n, ITEM(0).i*ITEM(1), ITEM(0).s*ITEM(1)); }
 
 template <iota_op I, is_iota J>
 constexpr auto
-optimize(Expr<std::multiplies<>, std::tuple<I, J>> && e)
+optimize(Map<std::multiplies<>, std::tuple<I, J>> && e)
 { return ra::iota(ITEM(1).n, ITEM(0)*ITEM(1).i, ITEM(0)*ITEM(1).s); }
 
 template <is_iota I>
 constexpr auto
-optimize(Expr<std::negate<>, std::tuple<I>> && e)
+optimize(Map<std::negate<>, std::tuple<I>> && e)
 { return ra::iota(ITEM(0).n, -ITEM(0).i, -ITEM(0).s); }
 
 #if RA_DO_OPT_SMALLVECTOR==1
@@ -202,7 +202,7 @@ static_assert(match_small<double, 4, ra::Cell<double, ic_t<std::array { Dim { 4,
 #define RA_OPT_SMALLVECTOR_OP(OP, NAME, T, N)                           \
     template <class A, class B> requires (match_small<T, N, A> && match_small<T, N, B>) \
     constexpr auto                                                      \
-    optimize(ra::Expr<NAME, std::tuple<A, B>> && e)                     \
+    optimize(Map<NAME, std::tuple<A, B>> && e)                          \
     {                                                                   \
         alignas (alignof(extvector<T, N>)) ra::Small<T, N> val;         \
         *(extvector<T, N> *)(&val) = *(extvector<T, N> *)((ITEM(0).c.cp)) OP *(extvector<T, N> *)((ITEM(1).c.cp)); \
@@ -274,7 +274,7 @@ DEF_NAMED_UNARY_OP(!, std::logical_not<>)
     template <class ... A> requires (toreduce<A ...>) constexpr decltype(auto) \
         OP(A && ... a) { return OP(VALUE(RA_FWD(a)) ...); }
 #define DEF_FWD(QUALIFIED_OP, OP)                                       \
-    template <class ... A> requires (!tomap<A ...> && !toreduce<A ...>) constexpr decltype(auto) \
+    template <class ... A> /* requires neither */ constexpr decltype(auto) \
         OP(A && ... a) { return QUALIFIED_OP(RA_FWD(a) ...); }          \
     DEF_NAME(OP)
 #define DEF_USING(QUALIFIED_OP, OP)             \
@@ -311,16 +311,15 @@ template <class T, class ... A>
 constexpr auto
 pack(A && ... a)
 {
-    return map([](auto && ... a) { return T { a ... }; }, RA_FWD(a) ...);
+    return map([](auto && ... a) { return T { RA_FWD(a) ... }; }, RA_FWD(a) ...);
 }
 
 // FIXME needs nested array for I, but iter<-1> should work
 template <class A, class I>
 constexpr auto
 at(A && a, I && i)
 {
-    return map([a = std::tuple<A>(RA_FWD(a))] (auto && i) -> decltype(auto) { return std::get<0>(a).at(i); },
-               RA_FWD(i));
+    return map([a = std::tuple<A>{RA_FWD(a)}] (auto && i) -> decltype(auto) { return get<0>(a).at(i); }, RA_FWD(i));
 }
 
 
@@ -425,7 +424,7 @@ amax(auto && a)
 }
 
 // FIXME encapsulate this kind of reference-reduction.
-// FIXME expr/ply mechanism doesn't allow partial iteration (adv then continue).
+// FIXME ply mechanism doesn't allow partial iteration (adv then continue).
 template <class A, class Less = std::less<ncvalue_t<A>>>
 constexpr decltype(auto)
 refmin(A && a, Less && less = {})