std::ranges::views::concat, std::ranges::concat_view

template< class... Rs >
concept /*concat-indirectly-readable*/ = // exposition only
 std::common_reference_with </*concat-reference-t*/<Rs...>&&,
 /*concat-value-t*/<Rs...>&> &&
 std::common_reference_with </*concat-reference-t*/<Rs...>&&,
 /*concat-rvalue-reference-t*/<Rs...>&&> &&
 std::common_reference_with </*concat-rvalue-reference-t*/<Rs...>&&,
 /*concat-value-t*/<Rs...> const&> &&
 (/*concat-indirectly-readable-impl*/</*concat-reference-t*/<Rs...>,
 /*concat-rvalue-reference-t*/<Rs...>,
 ranges::iterator_t <Rs>> && ...);

template< class Ref, class RRef, class It >
concept /*concat-indirectly-readable-impl*/ = // exposition only
 requires(const It it) {
 { *it } -> std::convertible_to <Ref>;
 { ranges::iter_move (it)} -> std::convertible_to <RRef>;
 };

template< class... Rs >
concept /*concatable*/ = requires { // exposition only
 typename /*concat-reference-t*/<Rs...>;
 typename /*concat-value-t*/<Rs...>;
 typename /*concat-rvalue-reference-t*/<Rs...>;
 } && /*concat-indirectly-readable*/<Rs...>;

#include <cassert>
#include <list>
#include <print>
#include <ranges>
#include <vector>
 
int main()
{
 std::vector <int> v0{1, 2, 3}, v1{4, 5};
 int a[]{6, 7};
 int i{8};
 auto ie{std::views::single (i)};
 
 auto con = std::views::concat(v0, v1, a, ie);
 assert (con.size() == v0.size() + v1.size() + std::size (a) + ie.size());
 std::println ("con.size(): {}", con.size());
 std::println ("con: {}", con);
 con[6] = 42; // con is random_access_range, operator[] returns a reference
 assert (a[1] == 42); // a[1] was modified via con[6]
 std::println ("con: {}", con);
 
 std::list <int> l{7, 8}; // list is bidirectional range
 auto cat = std::views::concat(v0, l);
 std::println ("cat: {}", cat);
 // cat[0] = 13; // compile-time error: cat is bidirectional => no operator[]
}

con.size(): 8
con: [1, 2, 3, 4, 5, 6, 7, 8]
con: [1, 2, 3, 4, 5, 6, 42, 8]
cat: [1, 2, 3, 7, 8]