Compiler Explorer

Source code

#include <algorithm>
#include <compare>
#include <concepts>
#include <functional>
#include <tuple>
#include <ranges>
#include <boost/mp11.hpp>
#include <fmt/format.h>
#include <fmt/ranges.h>

#define FWD(e) static_cast<decltype(e)&&>(e)

#include <https://raw.githubusercontent.com/pdimov/lambda2/develop/include/boost/lambda2/lambda2.hpp>
namespace boost::lambda2 {
 // maybe we should add these as function objects to std?
 // redefining this from Boost.Lambda2 to both declare new function objects and use them
 #define BOOST_LAMBDA2_UNARY_LAMBDA(op, fn) \
 struct fn { constexpr auto operator()(auto&& arg) -> decltype(op FWD(arg)) { return op FWD(arg); } }; \
 template<class A, class = detail::enable_unary_lambda<A>> \
 auto operator op( A&& a ) \
 { \
 return std::bind( fn(), std::forward<A>(a) ); \
 }

#define BOOST_LAMBDA2_BINARY_LAMBDA(op, fn) \
 struct fn { constexpr auto operator()(auto&& x, auto&& y) -> decltype(FWD(x) op FWD(y)) { return FWD(x) op FWD(y); } }; \
 template<class A, class B, class = detail::enable_binary_lambda<A, B>> \
 auto operator op( A&& a, B&& b ) \
 { \
 return std::bind( fn(), std::forward<A>(a), std::forward(b) ); \
 }

BOOST_LAMBDA2_UNARY_LAMBDA(*, deref)
    BOOST_LAMBDA2_UNARY_LAMBDA(++, prefix_inc)
    BOOST_LAMBDA2_UNARY_LAMBDA(--, prefix_dec)
    BOOST_LAMBDA2_BINARY_LAMBDA(+=, plus_eq)
    BOOST_LAMBDA2_BINARY_LAMBDA(-=, minus_eq)

struct index { constexpr auto operator()(auto&& x, auto&& y) -> decltype(FWD(x)[FWD(y)]) { return FWD(x)[FWD(y)]; } };

template <int I> struct placeholder {
 constexpr auto operator[](auto&& arg) const { return std::bind(index(), *this, FWD(arg)); }
 };
 inline constexpr placeholder<1> _{};
}

namespace std {
 template <int I> struct is_placeholder<boost::lambda2::placeholder> : true_type { };
}

namespace std {
 // did I really not think to add this one?
 template <typename... Ts>
 using common_comparison_category_for = common_comparison_category_t<compare_three_way_result_t<Ts>...>;
}

#define FOR_EACH_QUAL(X) X(&) X(const&) X(&&) X(const&&)
using namespace boost::mp11;
using namespace boost::lambda2;

template <size_t N>
inline constexpr auto idx_all_of = [](auto f) -> bool {
 return [=]<size_t... Is>(std::index_sequence<Is...>){
 return (f(mp_size_t<Is>()) and ...);
 }(std::make_index_sequence<N>());
};

template <size_t N>
inline constexpr auto idx_any_of = [](auto f) -> bool {
 return [=]<size_t... Is>(std::index_sequence<Is...>){
 return (f(mp_size_t<Is>()) or ...);
 }(std::make_index_sequence<N>());
};

/////////////////////////////////////////////////////////////////////////////////////////
// Pair
/////////////////////////////////////////////////////////////////////////////////////////
namespace X {
 template <typename T, typename U>
 struct Pair {
 T first;
 U second;

constexpr Pair() = default;

template <typename T1, typename U1>
 requires std::constructible_from<T, T1> and std::constructible_from<U, U1>
 constexpr Pair(T1&& t, U1&& u)
 : first(FWD(t))
 , second(FWD(u))
 { }

#define FROM_PAIR(q) \
 template <typename T1, typename U1> \
 requires std::constructible_from<T, T1 q> and std::constructible_from<U, U1 q> \
 constexpr Pair(Pair<T1, U1> q rhs) \
 : first(FWD(rhs).first) \
 , second(FWD(rhs).second) \
 { } \
 \
 template <typename T1, typename U1> \
 requires std::is_assignable_v<T&, T1 q> and std::is_assignable_v<U&, U1 q> \
 constexpr auto operator=(Pair<T1, U1> q rhs) -> Pair& { \
 first = FWD(rhs).first; \
 second = FWD(rhs).second; \
 return *this; \
 } \
 \
 template <typename T1, typename U1> \
 requires std::is_assignable_v<T const&, T1 q> and std::is_assignable_v \
 constexpr auto operator=(Pair<T1, U1> q rhs) const -> Pair const& { \
 first = FWD(rhs).first; \
 second = FWD(rhs).second; \
 return *this; \
 }
 FOR_EACH_QUAL(FROM_PAIR)
 #undef FROM_PAIR

Pair(Pair const&) = default;
        Pair(Pair&&) = default;

constexpr auto operator=(Pair const& rhs) -> Pair&
 requires std::is_copy_assignable_v<T> && std::is_copy_assignable_v
 {
 first = rhs.first;
 second = rhs.second;
 return *this;
 }

constexpr auto operator=(Pair&& rhs) -> Pair&
 requires std::is_move_assignable_v<T> && std::is_move_assignable_v
 {
 first = std::move(rhs).first;
 second = std::move(rhs).second;
 return *this;
 }

#define GETTER(q) \
 template <size_t I> \
 constexpr decltype(auto) get(mp_size_t = {}) q { \
 if constexpr (I == 0) return static_cast<T q>(first); \
 else return static_cast(second); \
 }
 FOR_EACH_QUAL(GETTER)
 #undef GETTER

#define APPLY(q) \
 template <typename F> \
 constexpr decltype(auto) apply(F&& f) q { \
 return std::invoke(FWD(f), static_cast<T q>(first), static_cast(second)); \
 }
 FOR_EACH_QUAL(APPLY)
 #undef APPLY

friend constexpr void swap(Pair& lhs, Pair& rhs)
 requires std::is_swappable_v<T> and std::is_swappable_v
 {
 std::ranges::swap(lhs.first, rhs.first);
 std::ranges::swap(lhs.second, rhs.second);
 }

friend constexpr void swap(Pair const& lhs, Pair const& rhs)
 requires std::is_swappable_v<T const> and std::is_swappable_v
 {
 std::ranges::swap(lhs.first, rhs.first);
 std::ranges::swap(lhs.second, rhs.second);
 }

constexpr auto operator==(Pair const& rhs) const -> bool 
 requires std::equality_comparable<T> and std::equality_comparable
 {
 return first == rhs.first and second == rhs.second;
 }

constexpr auto operator<=>(Pair const& rhs) const
 requires std::three_way_comparable<T> and std::three_way_comparable
 {
 using R = std::common_comparison_category_for<T, U>;
 if (auto c = first <=> rhs.first; c != 0) return R(c);
 return R(second <=> rhs.second); 
 }
 };

template <typename T, typename U> Pair(T, U) -> Pair<T, U>;
}

namespace std {
 template <typename T1, typename U1, typename T2, typename U2,
 template <typename> class Qual1,
 template <typename> class Qual2>
 requires requires {
 typename X::Pair<common_reference_t<Qual1<T1>, Qual2<T2>>, common_reference_t<Qual1<U1>, Qual2<U2>>>;
 }
 struct basic_common_reference<X::Pair<T1,U1>, X::Pair<T2,U2>, Qual1, Qual2>
 {
 using type = X::Pair<
 common_reference_t<Qual1<T1>, Qual2<T2>>,
 common_reference_t<Qual1<U1>, Qual2<U2>>
 >;
 };

template <typename T1, typename U1, typename T2, typename U2>
 requires requires { typename X::Pair<common_type_t<T1, U1>, common_type_t<T2, U2>>; }
 struct common_type<X::Pair<T1, T2>, X::Pair<U1, U2>> {
 using type = X::Pair<common_type_t<T1, U1>, common_type_t<T2, U2>>;
 };

template <typename T, typename U> struct tuple_size<X::Pair<T, U>> : mp_size_t<2> { };
 template <size_t I, typename T, typename U> struct tuple_element<I, X::Pair<T, U>> { using type = mp_at_c<X::Pair<T, U>, I>; };
}

/////////////////////////////////////////////////////////////////////////////////////////
// Tuple
/////////////////////////////////////////////////////////////////////////////////////////
namespace X {
 template <typename... Ts>
 class Tuple {
 std::tuple<Ts...> impl;

template <size_t... Is, typename Rhs>
 constexpr Tuple(std::index_sequence<Is...>, Rhs&& tuple)
 : impl(std::get<Is>(FWD(tuple))...)
 { }

public:
        constexpr Tuple() = default;

template <typename... Us> requires (std::constructible_from<Ts, Us> and ...)
 constexpr Tuple(Us&&... us) : impl(FWD(us)...) { }

#define FROM_TUPLE(q) \
 template <typename... Us> \
 requires (std::constructible_from<Ts, Us q> and ...) \
 constexpr Tuple(Tuple<Us...> q rhs) \
 : Tuple(std::index_sequence_for<Ts...>(), FWD(rhs).impl) \
 { } \
 \
 template <typename... Us> \
 requires (std::is_assignable_v<Ts&, Us q> and ...) \
 constexpr auto operator=(Tuple<Us...> q rhs) -> Tuple& { \
 mp_for_each<mp_iota_c<sizeof...(Ts)>>([&](auto I){ \
 std::get(*this) = std::get(FWD(rhs)); \
 }); \
 return *this; \
 } \
 \
 template <typename... Us> \
 requires (std::is_assignable_v<Ts const&, Us q> and ...) \
 constexpr auto operator=(Tuple<Us...> q rhs) const -> Tuple const& { \
 mp_for_each<mp_iota_c<sizeof...(Ts)>>([&](auto I){ \
 std::get(*this) = std::get(FWD(rhs)); \
 }); \
 return *this; \
 }
 FOR_EACH_QUAL(FROM_TUPLE)
 #undef FROM_TUPLE

#define FROM_PAIR(q) \
 template <typename T, typename U> \
 requires (sizeof...(Ts) == 2) \
 and std::constructible_from<mp_defer<mp_first, Tuple>, T q> \
 and std::constructible_from<mp_defer<mp_second, Tuple>, U q> \
 constexpr Tuple(Pair<T, U> q rhs) : impl(FWD(rhs).first, FWD(rhs).second) { }
 FOR_EACH_QUAL(FROM_PAIR)
 #undef FROM_PAIR

#define GETTER(q) \
 template <size_t I> \
 constexpr decltype(auto) get(mp_size_t = {}) q { \
 return std::get(static_cast<std::tuple<Ts...> q>(impl)); \
 }
 FOR_EACH_QUAL(GETTER)
 #undef GETTER

#define APPLY(q) template <typename F> constexpr decltype(auto) apply(F&& f) q { return std::apply(FWD(f), static_cast<std::tuple<Ts...> q>(impl)); }
 FOR_EACH_QUAL(APPLY)
 #undef APPLY

friend constexpr void swap(Tuple& lhs, Tuple& rhs)
 requires (std::is_swappable_v<Ts> and ...)
 {
 mp_for_each<mp_iota_c<sizeof...(Ts)>>([&](auto I){
 std::ranges::swap(std::get(lhs.impl), std::get(rhs.impl));
 });
 }

friend constexpr void swap(Tuple const& lhs, Tuple const& rhs)
 requires (std::is_swappable_v<Ts const> and ...)
 {
 mp_for_each<mp_iota_c<sizeof...(Ts)>>([&](auto I){
 std::ranges::swap(std::get(lhs.impl), std::get(rhs.impl));
 });
 }

constexpr auto operator==(Tuple const& rhs) const -> bool 
 requires (std::equality_comparable<Ts> and ...)
 {
 return impl == rhs.impl;
 }

constexpr auto operator<=>(Tuple const& rhs) const
 requires (std::three_way_comparable<Ts> and ...)
 {
 return impl <=> rhs.impl;
 }
 };

template <typename... Ts> Tuple(Ts...) -> Tuple<Ts...>;

template <size_t I, typename Tuple> constexpr auto get(Tuple&& tuple) { return FWD(tuple).get(mp_size_t()); }
}

namespace std {
 template <typename... Ts, typename... Us,
 template <typename> class TQual,
 template <typename> class UQual>
 requires requires { typename X::Tuple<common_reference_t<TQual<Ts>, UQual<Us>>...>; }
 struct basic_common_reference<X::Tuple<Ts...>, X::Tuple<Us...>, TQual, UQual>
 {
 using type = X::Tuple<common_reference_t<TQual<Ts>, UQual<Us>>...>;
 };

template <typename... Ts, typename... Us>
 requires requires { typename X::Tuple<common_type_t<Ts, Us>...>; }
 struct common_type<X::Tuple<Ts...>, X::Tuple<Us...>> {
 using type = X::Tuple<common_type_t<Ts, Us>...>;
 };

template <typename... Ts> struct tuple_size<X::Tuple<Ts...>> : mp_size_t<sizeof...(Ts)> { };
 template <size_t I, typename... Ts> struct tuple_element<I, X::Tuple<Ts...>> { using type = mp_at_c<X::Tuple<Ts...>, I>; };
}

/////////////////////////////////////////////////////////////////////////////////////////
// Zip
/////////////////////////////////////////////////////////////////////////////////////////

namespace std::ranges {
 template <typename... Rs>
 concept zip_is_common =
 (sizeof...(Rs) == 1 and (common_range<Rs> and ...))
 or (not (bidirectional_range<Rs> and ...) and (common_range<Rs> and ...))
 or ((random_access_range<Rs> and ...) and (sized_range<Rs> and ...));

template <typename... Ts>
 using tuple_or_pair = mp_eval_if_c<sizeof...(Ts) != 2, X::Tuple<Ts...>, X::Pair, Ts...>;

static_assert(std::same_as<tuple_or_pair<int>, X::Tuple<int>>);
 static_assert(std::same_as<tuple_or_pair<int, char>, X::Pair<int, char>>);
 static_assert(std::same_as<tuple_or_pair<int, char, float>, X::Tuple<int, char, float>>);

template <typename F, typename Tuple>
 constexpr auto tuple_transform(F&& f, Tuple&& tuple) {
 return FWD(tuple).apply([&]<typename... Ts>(Ts&&... elems){
 return tuple_or_pair<invoke_result_t<F&, Ts>...>(
 std::invoke(f, FWD(elems))...
 );
 });
 }

static_assert(tuple_transform([](auto i){ return i+1; }, X::Tuple(0, 1, 2)) == X::Tuple(1, 2, 3));
    static_assert(tuple_transform([](auto i){ return i+1; }, X::Tuple(0, 1)) == X::Pair(1, 2));
    static_assert(tuple_transform([](auto i){ return i+1; }, X::Pair(0, 1)) == X::Pair(1, 2));

template <typename F, typename Tuple>
 constexpr void tuple_for_each(F&& f, Tuple&& tuple) {
 FWD(tuple).apply([&](auto&&... elems){
 (std::invoke(f, FWD(elems)), ...);
 });
 }

template <typename R> concept simple_view = __detail::__simple_view<R>;

template <typename... Vs> struct maybe_iterator_category { };
 template <forward_range... Vs> struct maybe_iterator_category<Vs...> { using iterator_category = input_iterator_tag; };

template <bool B, typename T> using maybe_const = __detail::__maybe_const_t<B, T>;

template <input_range... Views>
 requires (view<Views> and ...) and (sizeof...(Views) > 0)
 class zip_view : public view_interface<zip_view<Views...>> {
 X::Tuple<Views...> views_;
 template <bool> class iterator;
 template <bool> class sentinel;

template <bool Const>
 class iterator : public maybe_iterator_category<Views...>
 {
 friend zip_view;
 template <bool> friend class sentinel;

tuple_or_pair<iterator_t<maybe_const<Const, Views>>...> current_;
 constexpr explicit iterator(tuple_or_pair<iterator_t<maybe_const<Const, Views>>...> current)
 : current_(std::move(current))
 { }
 public:
 using iterator_concept = mp_cond<
 mp_bool<(random_access_range<Views> and ...)>, random_access_iterator_tag,
 mp_bool<(bidirectional_range<Views> and ...)>, bidirectional_iterator_tag,
 mp_bool<(forward_range<Views> and ...)>, forward_iterator_tag,
 mp_true, input_iterator_tag
 >;
 using value_type = tuple_or_pair<range_value_t<maybe_const<Const, Views>>...>;
 using reference = tuple_or_pair<range_reference_t<maybe_const<Const, Views>>...>;
 using difference_type = common_type_t<range_difference_t<maybe_const<Const, Views>>...>;

iterator() = default;
 constexpr iterator(iterator<!Const> i) requires Const && (convertible_to<iterator_t<Views>, iterator_t<maybe_const<Const, Views>>> and ...)
 : current_(std::move(i).current_)
 { }

constexpr auto operator*() const -> reference {
 return tuple_transform(*_, current_);
 }
 constexpr auto operator++() -> iterator& {
 tuple_for_each(++_, current_);
 return *this;
 }
 constexpr void operator++(int) { ++*this; } 
 constexpr auto operator++(int) -> iterator requires (forward_range<maybe_const<Const, Views>> and ...) {
 auto tmp = *this;
 ++*this;
 return tmp;
 }

constexpr auto operator--() -> iterator& requires (bidirectional_range<maybe_const<Const, Views>> and ...) {
 tuple_for_each(--_, current_);
 return *this;
 }
 constexpr auto operator--(int) -> iterator requires (bidirectional_range<maybe_const<Const, Views>> and ...) {
 auto tmp = *this;
 --*this;
 return tmp;
 }

constexpr auto operator+=(difference_type x) -> iterator& requires (random_access_range<maybe_const<Const, Views>> and ...) {
 tuple_for_each(_ += x, current_);
 return *this;
 }
 constexpr auto operator-=(difference_type x) -> iterator& requires (random_access_range<maybe_const<Const, Views>> and ...) {
 tuple_for_each(_ -= x, current_);
 return *this;
 }
 constexpr auto operator[](difference_type x) const -> reference requires (random_access_range<maybe_const<Const, Views>> and ...) {
 return tuple_transform(_[x], current_);
 }

constexpr auto operator==(iterator const& rhs) const -> bool requires (equality_comparable<iterator_t<maybe_const<Const, Views>>> and ...) {
 if constexpr ((bidirectional_range<maybe_const<Const, Views>> && ...)) {
 return current_ == rhs.current_;
 } else {
 return idx_any_of<sizeof...(Views)>([&](auto I){ return current_.get(I) == rhs.current_.get(I); });
 }
 }
 constexpr auto operator<=>(iterator const& rhs) const requires (random_access_range<maybe_const<Const, Views>> and ...)
 and (three_way_comparable<iterator_t<maybe_const<Const, Views>>> and ...)
 {
 return current_ <=> rhs.current_;
 }

friend constexpr auto operator+(iterator const& i, difference_type n) -> iterator requires (random_access_range<maybe_const<Const, Views>> and ...) {
 return iterator(tuple_transform(_ + n, i.current_));
 }
 friend constexpr auto operator+(difference_type n, iterator const& i) -> iterator requires (random_access_range<maybe_const<Const, Views>> and ...) {
 return iterator(tuple_transform(_ + n, i.current_));
 }
 friend constexpr auto operator-(iterator const& i, difference_type n) -> iterator requires (random_access_range<maybe_const<Const, Views>> and ...) {
 return iterator(tuple_transform(_ - n, i.current_));
 }
 friend constexpr auto operator-(iterator const& x, iterator const& y) -> difference_type requires (sized_sentinel_for<iterator_t<maybe_const<Const, Views>>, iterator_t<maybe_const<Const, Views>>> and ...) {
 return [&]<size_t... Is>(std::index_sequence<Is...>){
 return ranges::min(
 {difference_type(x.current_.get(mp_size_t<Is>()) - y.current_.get(mp_size_t<Is>()))...},
 std::ranges::less(),
 [](auto x){ return std::abs(x); }
 );
 }(std::index_sequence_for<Views...>());
 }

friend constexpr auto iter_move(iterator const& i) {
                return tuple_transform(ranges::iter_move, i.current_);
            }

friend constexpr void iter_swap(iterator const& x, iterator const& y) {
 mp_for_each<mp_iota_c<sizeof...(Views)>>([&](auto I){
 ranges::iter_swap(x.get(I), y.get(I));
 });
 }
 };

template <bool Const>
 class sentinel {
 friend zip_view;
 tuple_or_pair<sentinel_t<maybe_const<Const, Views>>...> end_;
 constexpr explicit sentinel(tuple_or_pair<sentinel_t<maybe_const<Const, Views>>...> end) : end_(std::move(end)) { }
 public:
 sentinel() = default;
 constexpr sentinel(sentinel<!Const> i) requires Const && (convertible_to<sentinel_t<Views>, sentinel_t<maybe_const<Const, Views>>> and ...)
 : end_(std::move(i).end_)
 { }

template <bool OtherConst>
 requires (sentinel_for<sentinel_t<maybe_const<Const, Views>>, iterator_t<maybe_const<OtherConst, Views>>> and ...)
 constexpr auto operator==(iterator<OtherConst> const& x) const -> bool {
 return idx_any_of<sizeof...(Views)>([&](auto I) -> bool { return x.current_.get(I) == end_.get(I); });
 }

template <bool OtherConst>
 requires (sized_sentinel_for<sentinel_t<maybe_const<Const, Views>>, iterator_t<maybe_const<OtherConst, Views>>> and ...)
 friend constexpr auto operator-(iterator<OtherConst> const& x, sentinel const& y) -> common_type_t<range_difference_t<maybe_const<OtherConst, Views>>...> {
 using R = common_type_t<range_difference_t<maybe_const<OtherConst, Views>>...>;
 return [&]<size_t... Is>(std::index_sequence<Is...>){
 return ranges::min(
 {R(x.current_.get(mp_size_t<Is>()) - y.end_.get(mp_size_t<Is>()))...},
 std::ranges::less(),
 [](auto x){ return std::abs(x); }
 );
 }(std::index_sequence_for<Views...>()); 
 }

public:
        constexpr zip_view() = default;
        constexpr explicit zip_view(Views... views) : views_(std::move(views)...) {}

constexpr auto begin() -> iterator<false> requires (not (simple_view<Views> and ...)) {
 return iterator<false>(tuple_transform(ranges::begin, views_));
 }
 constexpr auto begin() const -> iterator<true> requires (range<Views const> and ...) {
 return iterator<true>(tuple_transform(ranges::begin, views_));
 }

constexpr auto end() -> sentinel<false> requires (not (simple_view<Views> and ...) and not zip_is_common<Views...>) {
 return sentinel<false>(tuple_transform(ranges::end, views_));
 }
 constexpr auto end() -> iterator<false> requires (not (simple_view<Views> and ...) and zip_is_common<Views...>) {
 if constexpr ((random_access_range<Views> and ...)) {
 return begin() + size();
 } else {
 return iterator<false>(tuple_transform(ranges::end, views_));
 }
 }
 constexpr auto end() const -> sentinel<true> requires ((range<Views const> and ...) and not zip_is_common<Views...>) {
 return sentinel<true>(tuple_transform(ranges::end, views_));
 }
 constexpr auto end() const -> iterator<true> requires ((range<Views const> and ...) and zip_is_common<Views...>) {
 if constexpr ((random_access_range<Views> and ...)) {
 return begin() + size();
 } else {
 return iterator<true>(tuple_transform(ranges::end, views_));
 }
 }

constexpr auto size() requires (sized_range<Views> and ...) {
 return tuple_transform(ranges::size, views_).apply([]<typename... I>(I... sizes){
 return ranges::min({common_type_t<I...>(sizes)...});
 });
 }
 constexpr auto size() const requires (sized_range<Views const> and ...) {
 return tuple_transform(ranges::size, views_).apply([]<typename... I>(I... sizes){
 return ranges::min({common_type_t<I...>(sizes)...});
 });
 }
 };

template <class... Rs> zip_view(Rs&&... rs) -> zip_view<views::all_t<Rs>...>;

namespace views {
 inline constexpr auto zip = []<viewable_range... Rs>(Rs&&... rs) {
 if constexpr (sizeof...(Rs) == 0){
 return views::empty<X::Tuple<>>;
 } else {
 return zip_view<all_t<Rs>...>(FWD(rs)...);
 }
 };
 }
}

int main() {
 std::vector<int> v = {1, 2, 3};
 std::vector<std::string> s = {"some", "words", "here"};
 
 auto z = std::views::zip(v, s, v);
 static_assert(std::forward_iterator<decltype(z.begin())>);
 static_assert(std::random_access_iterator<decltype(z.begin())>);
 static_assert(std::ranges::random_access_range<decltype(z)>);
 static_assert(std::ranges::common_range<decltype(z)>);
 static_assert(std::ranges::sized_range<decltype(z)>);

fmt::print("{} elems\n", std::ranges::size(z));
    for (auto const& p : z) {
        fmt::print("{}\n", p);
    }

auto it = z.begin();
    it += 2;
    it -= 2;
    fmt::print("second is {}\n", it[1]);

auto e = std::views::zip(std::views::iota(0), s);
 static_assert(std::random_access_iterator<decltype(e.begin())>);
 static_assert(std::sentinel_for<decltype(e.end()), decltype(e.begin())>);
 static_assert(std::ranges::random_access_range<decltype(e)>);
 static_assert(not std::ranges::common_range<decltype(e)>);
 static_assert(not std::ranges::sized_range<decltype(e)>);

fmt::print("bespoke enumerate\n");
    for (auto const& p : e) {
        fmt::print("{}\n", p);
    }

std::ranges::sort(std::views::zip(s, v));
    fmt::print("Sorted! s={}, v={}\n", s, v);
}