Simplify view conversions, view ops

* ra/arrays.hh (ViewBig, ViewSmall): Replace const/unconst conversions with
  conversions from Slice.
  (reconst, unconst): Unused, remove.
  (reshape, colapse, stencil): Take Slice arguments.

Author: lloda

README.md

@@ -7,9 +7,9 @@
 
 **ra-ra** implements [expression templates](https://en.wikipedia.org/wiki/Expression_templates). This is a C++ technique (pioneered by [Blitz++](http://blitz.sourceforge.net)) to delay the execution of expressions involving array operands, and in this way avoid the unnecessary creation of large temporary array objects.
 
-**ra-ra** is compact (≈4k loc), easy to extend, and generic. There are no arbitrary type restrictions or limits on rank or argument count.
+**ra-ra** is compact, generic, and easy to extend.
 
-In this example ([examples/read-me.cc](examples/read-me.cc)), we create some arrays, do operations on them, and print the result.
+In this example ([examples/read-me.cc](examples/read-me.cc)), we create some arrays, operate on them, and print the result.
 
 ```c++
   #include "ra/ra.hh"
@@ -38,7 +38,7 @@ B:
  {215.00, 218.00, -221.00, -224.00}}
 ```
 
-Please check the manual online at [lloda.github.io/ra-ra](https://lloda.github.io/ra-ra), or have a look at the [examples/](examples/) folder.
+Check the manual at [lloda.github.io/ra-ra](https://lloda.github.io/ra-ra), or have a look at the [examples/](examples/).
 
 **ra-ra** offers:
 
@@ -50,48 +50,45 @@ Please check the manual online at [lloda.github.io/ra-ra](https://lloda.github.i
 * iterators over subarrays (cells) of any rank
 * rank conjunction as in J (compile time rank only), outer product operation
 * short-circuiting logical operators
-* operators to select from argument list using either bool or integer (`where`, `pick`)
+* operators to select from argument list (`where`, `pick`)
 * view operations: reshape, transpose, reverse, collapse/explode, stencils
 * arbitrary types as array elements, or as scalar operands
-* many predefined array operations, adding yours is trivial
+* many predefined array operations; adding yours is trivial
 * configurable error handling
 * as much `constexpr` as possible.
 
-Performance is competitive with hand written scalar (element by element) loops, but probably not with cache-tuned code such as your platform BLAS, or with code using SIMD. Please have a look at the benchmarks in [bench/](bench/).
+Performance is competitive with hand written scalar (element by element) loops, but probably not with cache-tuned code such as your platform BLAS, or with code using SIMD. Have a look at the benchmarks in [bench/](bench/).
 
 #### Building the tests and the benchmarks
 
-**ra-ra** is header-only and has no dependencies other than a C++23 compiler and the standard library. At the moment I test with gcc 14.2. If you can test with Clang, please let me know.
+**ra-ra** is header-only and only depends on the standard library. A C++23 compiler is required. At the moment I test with gcc 14. If you can test with Clang, please let me know.
 
-The test suite in [test/](test/) runs under either SCons (`CXXFLAGS=-O3 scons`) or CMake (`CXXFLAGS=-O3 cmake . && make && make test`). Running the test suite will also build and run the [examples](examples/) and the [benchmarks](bench/). Please check the manual for options.
+The test suite in [test/](test/) runs under either SCons (`CXXFLAGS=-O3 scons`) or CMake (`CXXFLAGS=-O3 cmake . && make && make test`). Running the test suite will also build and run the [examples](examples/) and the [benchmarks](bench/). Check the manual for options.
 
 #### Notes
 
 * Both index and size types are signed. Index base is 0.
-* The default array order is C or row-major (last dimension changes fastest). You can make array views with other orders, but newly created arrays use C order.
+* The default array order is C or row-major (last dimension changes fastest). You can make array views with other orders.
 * The subscripting operator is `()` or `[]`, indistinctly.
-* Indices are checked by default. This can be disabled with a compilation flag.
+* Indices are checked by default. Checks can be disabled with a compilation flag.
 
 #### Bugs & defects
 
 * Operations that require allocation, such as concatenation or search, are mostly absent.
 * No good abstraction for reductions. You can write reductions abusing rank extension, but it's awkward.
-* Traversal of arrays is basic, just unrolling of inner dimensions.
+* Basic array traversal, just unrolling of inner dimensions.
 * Handling of nested / ragged arrays is inconsistent.
-* No support for parallel operations or GPU.
-* No SIMD to speak of.
-
-Please see the TODO file for a concrete list of known issues.
+* No parallel operations, GPU, or SIMD (but should be thread safe).
 
 #### Motivation
 
-I do numerical work in C++, and I need support for array operations. The built-in array types that C++ inherits from C are very insufficient, so at the time of C++11 when I started writing **ra-ra**, a number of libraries were already available. However, most of these libraries seemed to support only vectors and matrices, or small objects for vector algebra.
+I do numerical work in C++, and I need support for array operations. The built-in array types that C++ inherits from C are insufficient, so at the time of C++11 when I started writing **ra-ra**, a number of libraries were already available. However, most of these libraries seemed to support only vectors and matrices, or small objects for vector algebra.
 
 Blitz++ was a major inspiration as an early *generic* library. But it was a heroic feat to write such a library in C++ in the late 90s. Variadic templates, lambdas, perfect forwarding, etc. make things much easier, for the library writer as well as for the user.
 
-From APL and J I've taken the rank extension mechanism, and perhaps an inclination for carrying each feature to its logical end.
+From APL and J I've taken the rank extension mechanism, as well as an inclination for carrying each feature to its logical end.
 
-**ra-ra** wants to remain simple. I try not to second-guess the compiler and I don't stress performance as much as Blitz++ did. However, I'm wary of adding features that could become an obstacle if I ever tried to make things fast(er). I believe that implementating new traversal methods, or perhaps optimizing specific expression patterns, should be possible without having to turn the library inside out.
+I want **ra-ra** to remain simple. I try not to second-guess the compiler and I don't fret over performance as much as Blitz++ did. However, I'll avoid features that could become an obstacle if I ever tried to make things fast(er). It should be possible to implement new traversal methods, or perhaps optimize specific expression patterns, without having to turn the library inside out.
 
 #### Other C++ array libraries