diff --git a/docs/headers.png b/docs/headers.png
index 926b71d..12dad1d 100644
Binary files a/docs/headers.png and b/docs/headers.png differ
diff --git a/docs/index.html b/docs/index.html
index 077ec49..166f616 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -3,7 +3,7 @@
 <!-- Created by GNU Texinfo 6.8, https://www.gnu.org/software/texinfo/ -->
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<!-- ra:: (version 26, updated 2023 November 27)
+<!-- ra:: (version 27, updated 2023 November 28)
 
 (c) Daniel Llorens 2005-2023
 
@@ -116,7 +116,7 @@ <h1 class="settitle" align="center">ra:: — An array library for C++20</h1>
 </div>
 <span id="ra_003a_003a"></span><h1 class="top"><code>ra::</code></h1>
 
-<p><code>ra::</code> (version 26, updated 2023 November 27)
+<p><code>ra::</code> (version 27, updated 2023 November 28)
 </p>
 <p>(c) Daniel Llorens 2005&ndash;2023
 </p>
@@ -1749,13 +1749,13 @@ <h3 class="section">4.7 Unregistered scalar types</h3>
 </div>
 <span id="Headers-1"></span><h3 class="section">5.1 Headers</h3>
 
-<p>The header structure of <code>ra::</code> is as follows.<a id="DOCF11" href="#FOOT11"><sup>11</sup></a>
-</p>
+<p>The header structure of <code>ra::</code> is as follows.</p>
+
 <ul>
 <li> <code>tuples.hh</code> -
 Generic macros and tuple library.
 </li><li> <code>bootstrap.hh</code> -
-Basic types, concepts, type predicates, introspection.
+Basic types and concepts, introspection.
 </li><li> <code>expr.hh</code> -
 Expression template nodes, prefix matching.
 </li><li> <code>ply.hh</code> -
@@ -1764,10 +1764,8 @@ <h3 class="section">4.7 Unregistered scalar types</h3>
 Array type with compile time dimensions.
 </li><li> <code>big.hh</code> -
 Array type with run time dimensions.
-</li><li> <code>optimize.hh</code> -
-Optimization templates.
 </li><li> <code>ra.hh</code> -
-Functions and operators. Main header.
+Functions and operators, main header.
 </li><li> <code>test.hh</code> -
 (accessory) Testing library.
 </li><li> <code>bench.hh</code> -
@@ -1776,7 +1774,6 @@ <h3 class="section">4.7 Unregistered scalar types</h3>
 (accessory) Dual number type and operations.
 </li></ul>
 
-<img src="headers.png" alt="headers">
 
 <hr>
 </div>
@@ -1820,7 +1817,7 @@ <h3 class="section">4.7 Unregistered scalar types</h3>
 
 <p>The execution of an expression template begins with the determination of its shape — the length of each of its dimensions. This is done recursively by traversing the terms of the expression. For a given dimension <code>k</code>≥0, terms that have rank less or equal than <code>k</code> are ignored, following the prefix matching principle. Likewise terms where dimension <code>k</code> has undefined length (such as <code>iota()</code> or dimensions created with <code>insert</code>) are ignored. All the other terms must match.
 </p>
-<p>Then we select a order of traversal. <code>ra::</code> supports ‘array’ orders, meaning that the dimensions are sorted in a certain way from outermost to innermost and a full dimension is traversed before one advances on the dimension outside. However, currently (v26) there is no heuristic to choose a dimension order, so traversal always happens in row-major order (which shouldn&rsquo;t be relied upon). <code>ply_ravel</code> will unroll as many innermost dimensions as it can, and in some cases traversal will be executed as a flat loop.
+<p>Then we select a order of traversal. <code>ra::</code> supports ‘array’ orders, meaning that the dimensions are sorted in a certain way from outermost to innermost and a full dimension is traversed before one advances on the dimension outside. However, currently (v27) there is no heuristic to choose a dimension order, so traversal always happens in row-major order (which shouldn&rsquo;t be relied upon). <code>ply_ravel</code> will unroll as many innermost dimensions as it can, and in some cases traversal will be executed as a flat loop.
 </p>
 <p>Finally we select a traversal method. <code>ra::</code> has two traversal methods: <code>ply_fixed</code> can be used when the rank and the traversal order are known at compile time, and <code>ply_ravel</code> can be used in the general case.
 </p>
@@ -2945,12 +2942,6 @@ <h5><a id="FOOT9" href="#DOCF9">(9)</a></h5>
 Note that if both operands are of rank 0 and at least one of them is an <code>ra::</code> object, they is no way to preserve the behavior of <code>&amp;&amp;</code> and <code>||</code> with built in types and avoid evaluating both, since the overloaded operators <a href="http://en.cppreference.com/w/cpp/language/operators">are normal functions</a>.</p>
 <h5><a id="FOOT10" href="#DOCF10">(10)</a></h5>
 <p>Simplified; see the references in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1170r0.html">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1170r0.html</a>.</p>
-<h5><a id="FOOT11" href="#DOCF11">(11)</a></h5>
-<p>Diagram generated using Graphviz and <a href="https://www.flourish.org/cinclude2dot">https://www.flourish.org/cinclude2dot</a>.
-</p>
-<pre class="verbatim">cd ra &amp;&amp; cinclude2dot.pl --include . &gt; headers.dot
-dot -Tpng headers.dot -Gdpi=100 &gt; headers.png
-</pre>
 </div>
 
 
diff --git a/docs/ra-ra.texi b/docs/ra-ra.texi
index c81c108..7bc6325 100644
--- a/docs/ra-ra.texi
+++ b/docs/ra-ra.texi
@@ -11,8 +11,8 @@
 @c http://open-std.org/JTC1/SC22/WG21/docs/papers/2017/p0356r2.html
 @c References to source [ma··] or [ma···] current last is 117.
 
-@set VERSION 26
-@set UPDATED 2023 November 27
+@set VERSION 27
+@set UPDATED 2023 November 28
 
 @copying
 @code{ra::} (version @value{VERSION}, updated @value{UPDATED})
@@ -1683,19 +1683,19 @@ Item 2
 @section Headers
 @c ------------------------------------------------
 
-The header structure of @code{ra::} is as follows.@footnote{Diagram generated using Graphviz and @url{https://www.flourish.org/cinclude2dot}.
+The header structure of @code{ra::} is as follows.@c @footnote{Diagram generated using Graphviz and @url{https://www.flourish.org/cinclude2dot}.
 
-@verbatim
-cd ra && cinclude2dot.pl --include . > headers.dot
-dot -Tpng headers.dot -Gdpi=100 > headers.png
-@end verbatim
-}
+@c @verbatim
+@c cd ra && cinclude2dot.pl --include . > headers.dot
+@c dot -Tpng headers.dot -Gdpi=100 > headers.png
+@c @end verbatim
+@c }
 
 @itemize
 @item @code{tuples.hh} -
 Generic macros and tuple library.
 @item @code{bootstrap.hh} -
-Basic types, concepts, type predicates, introspection.
+Basic types and concepts, introspection.
 @item @code{expr.hh} -
 Expression template nodes, prefix matching.
 @item @code{ply.hh} -
@@ -1704,10 +1704,8 @@ Traversal, including I/O.
 Array type with compile time dimensions.
 @item @code{big.hh} -
 Array type with run time dimensions.
-@item @code{optimize.hh} -
-Optimization templates.
 @item @code{ra.hh} -
-Functions and operators. Main header.
+Functions and operators, main header.
 @item @code{test.hh} -
 (accessory) Testing library.
 @item @code{bench.hh} -
@@ -1716,7 +1714,7 @@ Functions and operators. Main header.
 (accessory) Dual number type and operations.
 @end itemize
 
-@image{headers,4cm}
+@c @image{headers,4cm}
 
 @c ------------------------------------------------
 @node Type hierarchy
diff --git a/ra/big.hh b/ra/big.hh
index 648d6cf..213c28f 100644
--- a/ra/big.hh
+++ b/ra/big.hh
@@ -231,11 +231,8 @@ struct View
         return select_loop(dim, k, RA_FWD(i) ...);
     }
     constexpr static dim_t
-    select_loop(Dim * dim, int k)
-    {
-        return 0;
-    }
-// Specialize for rank() integer-args -> scalar, same in ra::SmallBase in small.hh.
+    select_loop(Dim * dim, int k) { return 0; }
+
     template <class ... I>
     constexpr decltype(auto)
     operator()(I && ... i) const
@@ -555,7 +552,7 @@ template <class T, rank_t RANK=ANY> using Unique = Container<std::unique_ptr<T [
 template <class T, rank_t RANK=ANY> using Shared = Container<std::shared_ptr<T>, RANK>;
 
 // -------------
-// Used in Guile wrappers to let array parameter either borrow from Guile storage or convert into new array (eg 'f32 into 'f64).
+// Used in Guile wrappers to let parameter either borrow from Guile storage or convert into new array (eg 'f32 into 'f64).
 // TODO Can use unique_ptr's deleter for this?
 // TODO Shared/Unique should maybe have constructors with unique_ptr/shared_ptr args
 // -------------
@@ -573,7 +570,7 @@ shared_borrowing(View<T, RANK> & raw)
 
 
 // --------------------
-// Concrete (container) type from array expression.
+// concrete (container) type from array expression.
 // --------------------
 
 template <class E>
@@ -660,7 +657,7 @@ with_shape(std::initializer_list<S> && s, X && x)
 
 
 // --------------------
-// Operations specific to View.
+// View ops
 // --------------------
 
 template <class T, rank_t RANK>
diff --git a/ra/bootstrap.hh b/ra/bootstrap.hh
index c3c6a4f..25f65ec 100644
--- a/ra/bootstrap.hh
+++ b/ra/bootstrap.hh
@@ -30,7 +30,7 @@
 
 namespace ra {
 
-constexpr int VERSION = 26;
+constexpr int VERSION = 27;
 // negative rank is used as 'frame rank' in contrast to 'cell rank'. These values limit what can be handled.
 constexpr int ANY = -1944444444; // only at ct, meaning tbd at rt
 constexpr int BAD = -1988888888; // undefined, eg dead axes
diff --git a/ra/expr.hh b/ra/expr.hh
index e2759bd..0d10477 100644
--- a/ra/expr.hh
+++ b/ra/expr.hh
@@ -357,7 +357,7 @@ struct Match<checkp, std::tuple<P ...>, mp::int_list<I ...>>
     }
 
     constexpr
-    Match(P ... p_): t(p_ ...) // [ra1]
+    Match(P ... p_): t(RA_FWD(p_) ...) // [ra1]
     {
 // TODO Maybe on ply, would make checkp unnecessary, make agree_xxx() unnecessary.
         if constexpr (checkp && !(has_len<P> || ...)) {
diff --git a/ra/optimize.hh b/ra/optimize.hh
deleted file mode 100644
index 4b0a12d..0000000
--- a/ra/optimize.hh
+++ /dev/null
@@ -1,126 +0,0 @@
-// -*- mode: c++; coding: utf-8 -*-
-// ra-ra - Naive optimization pass over expression templates.
-
-// (c) Daniel Llorens - 2015-2023
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License as published by the Free
-// Software Foundation; either version 3 of the License, or (at your option) any
-// later version.
-
-#pragma once
-#include "small.hh"
-
-namespace ra {
-
-template <class E> constexpr decltype(auto) optimize(E && e) { return RA_FWD(e); }
-
-// FIXME only reduces iota exprs as operated on in ra.hh (operators), not a tree like WithLen does.
-#if RA_DO_OPT_IOTA==1
-// TODO maybe don't opt iota(int)*real -> iota(real) since a+a+... != n*a
-template <class X> concept iota_op = ra::is_zero_or_scalar<X> && std::is_arithmetic_v<value_t<X>>;
-
-// TODO something to handle the & variants...
-#define ITEM(i) std::get<(i)>(e.t)
-
-// FIXME gets() vs p2781r2
-// qualified ra::iota is necessary not to pick std::iota through ADL (test/headers.cc).
-
-template <is_iota I, iota_op J>
-constexpr auto
-optimize(Expr<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)
-{
-    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)
-{
-    return ra::iota(maybe_len(e), ITEM(0).i+ITEM(1).i, ITEM(0).gets()+ITEM(1).gets());
-}
-
-template <is_iota I, iota_op J>
-constexpr auto
-optimize(Expr<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)
-{
-    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)
-{
-    return ra::iota(maybe_len(e), ITEM(0).i-ITEM(1).i, ITEM(0).gets()-ITEM(1).gets());
-}
-
-template <is_iota I, iota_op J>
-constexpr auto
-optimize(Expr<std::multiplies<>, std::tuple<I, J>> && e)
-{
-    return ra::iota(ITEM(0).n, ITEM(0).i*ITEM(1), ITEM(0).gets()*ITEM(1));
-}
-template <iota_op I, is_iota J>
-constexpr auto
-optimize(Expr<std::multiplies<>, std::tuple<I, J>> && e)
-{
-    return ra::iota(ITEM(1).n, ITEM(0)*ITEM(1).i, ITEM(0)*ITEM(1).gets());
-}
-
-template <is_iota I>
-constexpr auto
-optimize(Expr<std::negate<>, std::tuple<I>> && e)
-{
-    return ra::iota(ITEM(0).n, -ITEM(0).i, -ITEM(0).gets());
-}
-
-#endif // RA_DO_OPT_IOTA
-
-#if RA_DO_OPT_SMALLVECTOR==1
-
-// FIXME can't match CellSmall directly, maybe bc N is in std::array { Dim { N, 1 } }.
-template <class T, dim_t N, class A> constexpr bool match_small =
-    std::is_same_v<std::decay_t<A>, typename ra::Small<T, N>::View::iterator<0>>
-    || std::is_same_v<std::decay_t<A>, typename ra::Small<T, N>::ViewConst::iterator<0>>;
-
-static_assert(match_small<double, 4, ra::CellSmall<double, ic_t<std::array { Dim { 4, 1 } }>, 0>>);
-
-#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)                     \
-    {                                                                   \
-        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)); \
-        return val;                                                     \
-    }
-#define RA_OPT_SMALLVECTOR_OP_FUNS(T, N)      \
-    static_assert(0==alignof(ra::Small<T, N>) % alignof(extvector<T, N>)); \
-    RA_OPT_SMALLVECTOR_OP(+, std::plus<>, T, N)  \
-    RA_OPT_SMALLVECTOR_OP(-, std::minus<>, T, N) \
-    RA_OPT_SMALLVECTOR_OP(/, std::divides<>, T, N) \
-    RA_OPT_SMALLVECTOR_OP(*, std::multiplies<>, T, N)
-#define RA_OPT_SMALLVECTOR_OP_SIZES(T)        \
-    RA_OPT_SMALLVECTOR_OP_FUNS(T, 2)          \
-    RA_OPT_SMALLVECTOR_OP_FUNS(T, 4)          \
-    RA_OPT_SMALLVECTOR_OP_FUNS(T, 8)
-FOR_EACH(RA_OPT_SMALLVECTOR_OP_SIZES, float, double)
-
-#undef RA_OPT_SMALLVECTOR_OP_SIZES
-#undef RA_OPT_SMALLVECTOR_OP_FUNS
-#undef RA_OPT_SMALLVECTOR_OP_OP
-
-#endif // RA_DO_OPT_SMALLVECTOR
-
-#undef ITEM
-
-} // namespace ra
diff --git a/ra/ra.hh b/ra/ra.hh
index 9dbd817..f10fe36 100644
--- a/ra/ra.hh
+++ b/ra/ra.hh
@@ -9,7 +9,6 @@
 
 #pragma once
 #include "big.hh"
-#include "optimize.hh"
 #include <cmath>
 #include <complex>
 
@@ -127,7 +126,123 @@ constexpr bool odd(unsigned int N) { return N & 1; }
 
 
 // --------------------------------
-// Array versions of operators and functions
+// optimization pass over expression templates.
+// --------------------------------
+
+template <class E> constexpr decltype(auto) optimize(E && e) { return RA_FWD(e); }
+
+// FIXME only reduces iota exprs as operated on in ra.hh (operators), not a tree like WithLen does.
+#if RA_DO_OPT_IOTA==1
+// TODO maybe don't opt iota(int)*real -> iota(real) since a+a+... != n*a
+template <class X> concept iota_op = ra::is_zero_or_scalar<X> && std::is_arithmetic_v<value_t<X>>;
+
+// TODO something to handle the & variants...
+#define ITEM(i) std::get<(i)>(e.t)
+
+// FIXME gets() vs p2781r2
+// qualified ra::iota is necessary not to pick std::iota through ADL (test/headers.cc).
+
+template <is_iota I, iota_op J>
+constexpr auto
+optimize(Expr<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)
+{
+    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)
+{
+    return ra::iota(maybe_len(e), ITEM(0).i+ITEM(1).i, ITEM(0).gets()+ITEM(1).gets());
+}
+
+template <is_iota I, iota_op J>
+constexpr auto
+optimize(Expr<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)
+{
+    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)
+{
+    return ra::iota(maybe_len(e), ITEM(0).i-ITEM(1).i, ITEM(0).gets()-ITEM(1).gets());
+}
+
+template <is_iota I, iota_op J>
+constexpr auto
+optimize(Expr<std::multiplies<>, std::tuple<I, J>> && e)
+{
+    return ra::iota(ITEM(0).n, ITEM(0).i*ITEM(1), ITEM(0).gets()*ITEM(1));
+}
+template <iota_op I, is_iota J>
+constexpr auto
+optimize(Expr<std::multiplies<>, std::tuple<I, J>> && e)
+{
+    return ra::iota(ITEM(1).n, ITEM(0)*ITEM(1).i, ITEM(0)*ITEM(1).gets());
+}
+
+template <is_iota I>
+constexpr auto
+optimize(Expr<std::negate<>, std::tuple<I>> && e)
+{
+    return ra::iota(ITEM(0).n, -ITEM(0).i, -ITEM(0).gets());
+}
+
+#endif // RA_DO_OPT_IOTA
+
+#if RA_DO_OPT_SMALLVECTOR==1
+
+// FIXME can't match CellSmall directly, maybe bc N is in std::array { Dim { N, 1 } }.
+template <class T, dim_t N, class A> constexpr bool match_small =
+    std::is_same_v<std::decay_t<A>, typename ra::Small<T, N>::View::iterator<0>>
+    || std::is_same_v<std::decay_t<A>, typename ra::Small<T, N>::ViewConst::iterator<0>>;
+
+static_assert(match_small<double, 4, ra::CellSmall<double, ic_t<std::array { Dim { 4, 1 } }>, 0>>);
+
+#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)                     \
+    {                                                                   \
+        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)); \
+        return val;                                                     \
+    }
+#define RA_OPT_SMALLVECTOR_OP_FUNS(T, N)      \
+    static_assert(0==alignof(ra::Small<T, N>) % alignof(extvector<T, N>)); \
+    RA_OPT_SMALLVECTOR_OP(+, std::plus<>, T, N)  \
+    RA_OPT_SMALLVECTOR_OP(-, std::minus<>, T, N) \
+    RA_OPT_SMALLVECTOR_OP(/, std::divides<>, T, N) \
+    RA_OPT_SMALLVECTOR_OP(*, std::multiplies<>, T, N)
+#define RA_OPT_SMALLVECTOR_OP_SIZES(T)        \
+    RA_OPT_SMALLVECTOR_OP_FUNS(T, 2)          \
+    RA_OPT_SMALLVECTOR_OP_FUNS(T, 4)          \
+    RA_OPT_SMALLVECTOR_OP_FUNS(T, 8)
+FOR_EACH(RA_OPT_SMALLVECTOR_OP_SIZES, float, double)
+
+#undef RA_OPT_SMALLVECTOR_OP_SIZES
+#undef RA_OPT_SMALLVECTOR_OP_FUNS
+#undef RA_OPT_SMALLVECTOR_OP_OP
+
+#endif // RA_DO_OPT_SMALLVECTOR
+
+#undef ITEM
+
+
+// --------------------------------
+// array versions of operators and functions
 // --------------------------------
 
 // We need zero/scalar specializations because the scalar/scalar operators maybe be templated (e.g. complex<>), so they won't be found when an implicit conversion to scalar is also needed, and e.g. ra::View<complex, 0> * complex would fail.
@@ -277,7 +392,7 @@ FOR_EACH(DEF_SHORTCIRCUIT_BINARY_OP, &&, ||);
 
 
 // --------------------------------
-// Some whole-array reductions. TODO First rank reductions? Variable rank reductions?
+// whole-array reductions. TODO First rank reductions? Variable rank reductions?
 // FIXME C++23 and_then/or_else/etc
 // --------------------------------
 
@@ -410,7 +525,7 @@ cdot(auto && a, auto && b)
 
 
 // --------------------
-// Other whole-array ops.
+// other whole-array ops.
 // --------------------
 
 constexpr auto
@@ -489,7 +604,7 @@ gemv(auto const & a, auto const & b)
 
 
 // --------------------
-// Wedge product and cross product
+// wedge product and cross product
 // --------------------
 
 namespace mp {
diff --git a/ra/small.hh b/ra/small.hh
index cd0fac2..7ac84dd 100644
--- a/ra/small.hh
+++ b/ra/small.hh
@@ -95,7 +95,7 @@ resize(A & a, dim_t s)
 
 
 // --------------------
-// Slicing helpers
+// slicing helpers
 // --------------------
 
 template <int n=BAD> struct dots_t { static_assert(n>=0 || BAD==n); };
@@ -177,9 +177,8 @@ template <int N, class KK=mp::iota<N>> struct unbeat;
 template <int N, int ... k>
 struct unbeat<N, mp::int_list<k ...>>
 {
-    template <class V, class ... I>
     constexpr static decltype(auto)
-    op(V && v, I && ... i)
+    op(auto && v, auto && ... i)
     {
         return from(RA_FWD(v), with_len(maybe_len<k>(v), RA_FWD(i)) ...);
     }
@@ -187,7 +186,7 @@ struct unbeat<N, mp::int_list<k ...>>
 
 
 // --------------------
-// Develop indices
+// develop indices
 // --------------------
 
 template <rank_t k, rank_t end>
@@ -463,10 +462,8 @@ struct SmallView: public SmallBase<T, lens, steps>
     }
     template <int k>
     consteval static dim_t
-    select_loop()
-    {
-        return 0;
-    }
+    select_loop() { return 0; }
+
     template <class ... I>
     constexpr decltype(auto)
     operator()(I && ... i) const
@@ -610,7 +607,7 @@ ravel_from_iterators(auto && begin, auto && end)
 
 
 // ---------------------
-// Builtin arrays.
+// builtin arrays.
 // ---------------------
 
 template <class T>
@@ -701,7 +698,7 @@ cat(A1 && a1_, A2 && a2_)
     if constexpr (cv_smallview<A1> && cv_smallview<A2>) {
         decltype(auto) a1 = a1_.view();
         decltype(auto) a2 = a2_.view();
-        static_assert(1==a1.rank() && 1==a2.rank(), "Bad ranks for cat."); // gcc accepts a1.rank(), etc.
+        static_assert(1==a1.rank() && 1==a2.rank(), "Bad ranks for cat.");
         using T = std::common_type_t<std::decay_t<decltype(a1[0])>, std::decay_t<decltype(a2[0])>>;
         Small<T, a1.size()+a2.size()> val;
         std::copy(a1.begin(), a1.end(), val.begin());
@@ -709,7 +706,7 @@ cat(A1 && a1_, A2 && a2_)
         return val;
     } else if constexpr (cv_smallview<A1> && is_scalar<A2>) {
         decltype(auto) a1 = a1_.view();
-        static_assert(1==a1.rank(), "bad ranks for cat");
+        static_assert(1==a1.rank(), "Bad ranks for cat.");
         using T = std::common_type_t<std::decay_t<decltype(a1[0])>, A2>;
         Small<T, a1.size()+1> val;
         std::copy(a1.begin(), a1.end(), val.begin());
@@ -717,7 +714,7 @@ cat(A1 && a1_, A2 && a2_)
         return val;
     } else if constexpr (is_scalar<A1> && cv_smallview<A2>) {
         decltype(auto) a2 = a2_.view();
-        static_assert(1==a2.rank(), "bad ranks for cat");
+        static_assert(1==a2.rank(), "Bad ranks for cat.");
         using T = std::common_type_t<A1, std::decay_t<decltype(a2[0])>>;
         Small<T, 1+a2.size()> val;
         val[0] = a1_;
diff --git a/test/ra-9.cc b/test/ra-9.cc
index 12c5701..7e4bdfc 100644
--- a/test/ra-9.cc
+++ b/test/ra-9.cc
@@ -83,10 +83,10 @@ int main()
     {
         auto ref = std::array<int, 4> {12, 77, 44, 1};
         tr.test_eq(2, expr([](int i) { return i; }, ra::start(std::vector {1, 2, 3})).at(ra::Small<int, 1>{1}));
-        tr.test_eq(ra::start(ref), expr([](int i) { return i; }, ra::start(std::array {12, 77, 44, 1})));
-// [ra1] no need to forward in Expr()/Match()/Pick(), that is done in expr()/pick(). Used to need it bc CTE in older gcc.
-        tr.test_eq(ra::start(ref), expr([](int i) { return i; }, ra::start(ra::Big<int, 1> {12, 77, 44, 1})));
-        tr.test_eq(ra::start(ref), expr([](int i) { return i; }, ra::start(std::vector {12, 77, 44, 1})));
+        tr.test_eq(ref, expr([](int i) { return i; }, ra::start(std::array {12, 77, 44, 1})));
+// [ra1] used to need forward in Match/Expr/Pick bc CTE in older gcc. But see bug83.cc.
+        tr.test_eq(ref, expr([](int i) { return i; }, ra::start(ra::Big<int, 1> {12, 77, 44, 1})));
+        tr.test_eq(ref, expr([](int i) { return i; }, ra::start(std::vector {12, 77, 44, 1})));
         {
             int c = 0;
             ply_ravel(expr([&c](int i) { c += i; }, ra::start(ra::Unique<int, 1> {12, 77, 44, 1})));
