Compiler Explorer

Source code

#include <functional>
#include <concepts>
#include <ranges>
#include 
#include <compare>

////////////////////////////////////////////////////////////////////////
// https://brevzin.github.io/c++/2019/09/23/declarative-cpos/
struct deleted_t { };

template <typename F>
struct delete_if {
 [[no_unique_address]] F f;

constexpr delete_if(F f) : f(std::move(f)) { }

template <typename... Args>
 requires std::invocable<F const&, Args...>
 constexpr auto operator()(Args&&...) const -> deleted_t;
};

#define FWD(x) static_cast<decltype(x)&&>(x)
#define RETURNS(e) -> decltype(e) { return e; }

template <typename... Fs>
class first_of
{ };

template <typename... Fs>
first_of(Fs...) -> first_of<Fs...>;

template <typename F, typename... Fs>
class first_of<F, Fs...>
{
private:
 using Rest = first_of<Fs...>;
 [[no_unique_address]] F first;
 [[no_unique_address]] Rest rest;

public:
    constexpr first_of(F f, Fs... fs)
        : first(std::move(f))
        , rest(std::move(fs)...)
    { }

template <typename... Args,
 bool First = std::is_invocable_v<F const&, Args...>,
 typename Which = std::conditional_t<First, F, Rest> const&>
 constexpr auto operator()(Args&&... args) const
 noexcept(std::is_nothrow_invocable_v<Which, Args...>)
 -> std::invoke_result_t<Which, Args...>
 {
 if constexpr (First) {
 return std::invoke(first, FWD(args)...);
 } else {
 return std::invoke(rest, FWD(args)...);
 }
 }

template <typename... Args>
 requires std::invocable<F const&, Args...> &&
 std::same_as<
 std::invoke_result_t<F const&, Args...>,
 deleted_t>
 void operator()(Args&&...) const = delete;
};
////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////
// const-iterator wrapping, pulled out of a views::const implementation https://godbolt.org/z/7MGEEj

template <typename It> struct iterator_concept_for { };
template <typename It> requires std::contiguous_iterator<It>
struct iterator_concept_for<It> {
 using iterator_concept = std::contiguous_iterator_tag;
};

template <typename It> struct iterator_category_for { };
template <std::forward_iterator It>
struct iterator_category_for<It> {
 using iterator_category = typename std::iterator_traits<It>::iterator_category;
};

template <std::input_iterator It>
using const_ref_for = std::common_reference_t<std::iter_value_t<It> const &&, std::iter_reference_t<It>>;

template <typename It>
concept ConstantIterator = std::input_iterator<It>
 && std::same_as<const_ref_for<It>, std::iter_reference_t<It>>;

template <typename R>
concept ConstantRange = std::ranges::range<R> && ConstantIterator<std::ranges::iterator_t<R>>;

template <typename T, typename U>
concept DifferentFrom = not std::same_as<std::remove_cvref_t<T>, std::remove_cvref_t>;

template <typename T, template <class...> class Z>
inline constexpr bool is_specialization_of_v = false;
template <class... Args, template <class...> class Z>
inline constexpr bool is_specialization_of_v<Z<Args...>, Z> = true;

template <typename T, template <class...> class Z>
concept NotA = (not is_specialization_of_v<T, Z>);

template <std::input_iterator It>
class basic_const_iterator : public iterator_concept_for<It>
 , public iterator_category_for<It>
{
 It it;

public:
 using value_type = std::iter_value_t<It>;
 using difference_type = std::iter_difference_t<It>;
 using reference = const_ref_for<It>;

basic_const_iterator() = default;
 basic_const_iterator(It it) : it(std::move(it)) { }
 template <std::convertible_to<It> U>
 basic_const_iterator(basic_const_iterator c) : it(std::move(c.base())) { }
 basic_const_iterator(std::convertible_to<It> auto&& c) : it(FWD(c)) { }

auto operator++() -> basic_const_iterator& { ++it; return *this; }
 auto operator++(int) -> basic_const_iterator requires std::forward_iterator<It> { auto cpy = *this; ++*this; return cpy; }
 void operator++(int) { ++*this; }

auto operator--() -> basic_const_iterator& requires std::bidirectional_iterator<It> { --it; return *this; }
 auto operator--(int) -> basic_const_iterator requires std::bidirectional_iterator<It> { auto cpy = *this; --*this; return cpy; }

auto operator+(difference_type n) const -> basic_const_iterator requires std::random_access_iterator<It> { return const_iterator(it + n); }
 auto operator-(difference_type n) const -> basic_const_iterator requires std::random_access_iterator<It> { return const_iterator(it - n); }
 friend auto operator+(difference_type n, basic_const_iterator const& rhs) -> basic_const_iterator { return rhs + n; }
 auto operator+=(difference_type n) -> basic_const_iterator& requires std::random_access_iterator<It> { it += n; return *this; }
 auto operator-=(difference_type n) -> basic_const_iterator& requires std::random_access_iterator<It> { it -= n; return *this; }
 auto operator-(basic_const_iterator const& rhs) const -> difference_type requires std::random_access_iterator<It> { return it - rhs.it; }
 auto operator[](difference_type n) const -> reference requires std::random_access_iterator<It> { return it[n]; }

auto operator*() const -> reference { return *it; }
 auto operator->() const -> value_type const* requires std::contiguous_iterator<It> { return std::to_address(it); }

template <std::sentinel_for<It> S>
 auto operator==(S const& s) const -> bool {
 return it == s;
 }

friend constexpr bool operator<(const basic_const_iterator& x, const basic_const_iterator& y)
 requires std::random_access_iterator<It>
 {
 return x.it < y.it;
 }
 friend constexpr bool operator>(const basic_const_iterator& x, const basic_const_iterator& y)
 requires std::random_access_iterator<It>
 {
 return x.it > y.it;
 }
 friend constexpr bool operator<=(const basic_const_iterator& x, const basic_const_iterator& y)
 requires std::random_access_iterator<It>
 {
 return x.it <= y.it;
 }
 friend constexpr bool operator>=(const basic_const_iterator& x, const basic_const_iterator& y)
 requires std::random_access_iterator<It>
 {
 return x.it >= y.it;
 }
 friend constexpr auto operator<=>(const basic_const_iterator& x, const basic_const_iterator& y)
 requires std::random_access_iterator<It> && std::three_way_comparable<It>
 {
 return x.it <=> y.it;
 }

#ifdef USE_SPACESHIP
 template <DifferentFrom<basic_const_iterator> Rhs>
 requires std::random_access_iterator<It>
 and std::totally_ordered_with<It, Rhs>
 auto operator<=>(Rhs const& rhs) const {
 if constexpr (std::three_way_comparable_with<It, Rhs>) {
 return it <=> rhs;
 } else if constexpr (std::sized_sentinel_for<Rhs, It>) {
 return (it - rhs) <=> 0;
 } else {
 if (it < rhs) return std::strong_ordering::less;
 if (rhs < it) return std::strong_ordering::greater;
 return std::strong_ordering::equal;
 }
 }
 #else

#define REL_CMP(op) \
 template <DifferentFrom<basic_const_iterator> I> \
 friend constexpr bool operator op(const basic_const_iterator& x, const I& y) \
 requires std::random_access_iterator<It> && std::totally_ordered_with<It, I> \
 { \
 return x.it op y; \
 } \
 template <NotA<::basic_const_iterator> I> \
 friend constexpr bool operator op(const I& x, const basic_const_iterator& y) \
 requires std::random_access_iterator<It> && std::totally_ordered_with<It, I> \
 { \
 return x op y.it; \
 }

REL_CMP(<)
 REL_CMP(>)
 REL_CMP(<=)
 REL_CMP(>=)

template <DifferentFrom<basic_const_iterator> I>
 friend constexpr auto operator<=>(const basic_const_iterator& x, const I& y)
 requires std::random_access_iterator<It>
 && std::totally_ordered_with<It, I>
 && std::three_way_comparable_with<It, I>
 {
 return x.it <=> y;
 }
 #endif

template <std::sized_sentinel_for<It> S>
 auto operator-(S const& s) const -> std::iter_difference_t<It> {
 return it - s;
 }

template <DifferentFrom<basic_const_iterator> S>
 requires std::sized_sentinel_for<S, It>
 friend auto operator-(S const& s, basic_const_iterator const& rhs) -> std::iter_difference_t<It> {
 return s - rhs.it;
 }

auto base() -> It& { return it; }
    auto base() const -> It const& { return it; }
};

template <typename T, std::common_with<T> U>
struct std::common_type<basic_const_iterator<T>, U> {
 using type = basic_const_iterator<std::common_type_t<T, U>>;
};
template <typename T, std::common_with<T> U>
struct std::common_type<U, basic_const_iterator<T>> {
 using type = basic_const_iterator<std::common_type_t<T, U>>;
};
template <typename T, std::common_with<T> U>
struct std::common_type<basic_const_iterator<T>, basic_const_iterator> {
 using type = basic_const_iterator<std::common_type_t<T, U>>;
};

template <std::input_iterator It>
constexpr auto make_const_iterator(It it) -> ConstantIterator auto {
 if constexpr (ConstantIterator<It>) {
 return it;
 } else {
 return basic_const_iterator<It>(it);
 }
}

template <std::input_iterator It>
using const_iterator = decltype(make_const_iterator(std::declval<It>()));

template <typename S>
constexpr auto make_const_sentinel(S s) {
 if constexpr (std::input_iterator<S>) {
 return make_const_iterator(std::move(s));
 } else {
 return s;
 }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////

inline constexpr auto delete_if_nonborrowed_rvalue =
 delete_if([]<class R>(R&&)
 requires (not std::ranges::enable_borrowed_range<std::remove_cvref_t<R>>)
 && std::is_rvalue_reference_v<R&&>
 { });

inline constexpr auto possibly_const = []<std::ranges::range R>(R& r) -> auto& {
 if constexpr (ConstantRange<R const> and not ConstantRange<R>) {
 return const_cast<R const&>(r);
 } else {
 return r;
 }
};

inline constexpr auto cbegin = first_of(
    // 1. non-borrowed rvalue
    delete_if_nonborrowed_rvalue,
    // 2. possibly-wrapped begin of possibly-const r
    [](std::ranges::range auto&& r)
        RETURNS(make_const_iterator(std::ranges::begin(possibly_const(r))))
);

inline constexpr auto cend = first_of(
    // 1. non-borrowed rvalue
    delete_if_nonborrowed_rvalue,
    // 2. possibly-wrapped end of possibly-const r
    [](std::ranges::range auto&& r)
        RETURNS(make_const_sentinel(std::ranges::end(possibly_const(r))))
);
inline constexpr auto crbegin = first_of(
    // 1. non-borrowed rvalue
    delete_if_nonborrowed_rvalue,
    // 2. make_const_iterator(rbegin(E))
    [](std::ranges::range auto&& r) RETURNS(make_const_iterator(std::ranges::rbegin(possibly_const(r))))
);
inline constexpr auto crend = first_of(
    // 1. non-borrowed rvalue
    delete_if_nonborrowed_rvalue,
    // 2. make_const_iterator(rend(E))
    [](std::ranges::range auto&& r) RETURNS(make_const_iterator(std::ranges::rend(possibly_const(r))))
);

//////////////////////////
// views::const_
template <typename R>
concept SimpleView = std::ranges::__detail::__simple_view<R>;

template <std::ranges::input_range V>
 requires std::ranges::view<V>
class const_view : public std::ranges::view_interface<const_view<V>> {
 V base = V();
public:
 constexpr const_view() = default;
 constexpr const_view(V base) : base(std::move(base)) { }

constexpr auto begin() requires (!SimpleView<V>) { return cbegin(base); }
 constexpr auto end() requires (!SimpleView<V>) { return cend(base); }
 constexpr auto size() requires std::ranges::sized_range<V> { return std::ranges::size(base); }

constexpr auto begin() const requires std::ranges::range<V const> { return cbegin(base); }
 constexpr auto end() const requires std::ranges::range<V const> { return cend(base); }
 constexpr auto size() const requires std::ranges::sized_range<V const> { return std::ranges::size(base); }
};

template <typename V>
inline constexpr bool ::std::ranges::enable_borrowed_range<const_view<V>> =
 std::ranges::enable_borrowed_range<V>;

// libstdc++ specific (hopefully standard version coming soon!)
inline constexpr std::views::__adaptor::_RangeAdaptorClosure const_ =
 []<std::ranges::viewable_range R>(R&& r)
 {
 using U = std::remove_cvref_t<R>;

if constexpr (ConstantRange<std::views::all_t<R>>) {
 return std::views::all(FWD(r));
 } else if constexpr (ConstantRange and not std::ranges::view) {
 return std::views::all(std::as_const(r));
 } else {
 return const_view<std::views::all_t<R>>(std::views::all(FWD(r)));
 }
 };
//////////////////////////

void f(std::span<int> s, std::vector<int> v) {
 auto si = cbegin(s);
 auto se = cend(s);

static_assert(std::contiguous_iterator<decltype(si)>);
 static_assert(std::same_as<std::iter_reference_t<decltype(si)>, int const&>);
 static_assert(std::same_as<decltype(si), decltype(se)>);

auto vi = cbegin(v);
 auto ve = cend(v);
 static_assert(std::same_as<decltype(vi), std::vector<int>::const_iterator>);
 static_assert(std::same_as<decltype(vi), decltype(ve)>);

std::vector<int> const& vc = v;
 auto vci = cbegin(vc);
 auto vce = cend(vc);
 static_assert(std::same_as<decltype(vci), std::vector<int>::const_iterator>);
 static_assert(std::same_as<decltype(vci), decltype(vce)>);

static_assert(std::invocable<decltype(cbegin), std::span<int>>);
 static_assert(not std::invocable<decltype(cbegin), std::vector<int>>);

static_assert(std::same_as<decltype(crbegin(v)), decltype(v.crbegin())>);
 static_assert(std::same_as<decltype(crend(v)), decltype(v.crend())>);
}

void g(std::vector<int> v) {
 auto evens = v | std::views::filter([](int i){ return i % 2 == 0; });

auto ci = cbegin(evens);
 auto ce = cend(evens);
 static_assert(std::same_as<std::iter_reference_t<decltype(ci)>, int const&>);

auto const_evens = evens | const_;
 static_assert(std::same_as<std::ranges::range_reference_t<decltype(const_evens)>, int const&>);

auto evens2 = std::as_const(v) | std::views::filter([](int i){ return i % 2 == 0; });
 static_assert(std::same_as<std::ranges::range_reference_t<decltype(evens2)>, int const&>);
 auto const_evens2 = const_(evens2);
 static_assert(std::same_as<decltype(evens2), decltype(const_evens2)>);

auto vc = v | const_;
 static_assert(std::same_as<decltype(vc), std::ranges::ref_view<std::vector<int> const>>);
}

struct zsentinel {
    auto operator==(char* p) const -> bool {
        return *p == '\0';
    }
};

struct zstring {
    char* p;
    auto begin() const -> char* { return p; }
    auto end() const -> zsentinel { return {}; }
};

void h(zstring zs) {
    auto ci = cbegin(zs);
    auto ce = cend(zs);

static_assert(std::same_as<std::iter_reference_t<decltype(ci)>, char const&>);
 static_assert(std::contiguous_iterator<decltype(ci)>);
 static_assert(std::sentinel_for<decltype(ce), decltype(ci)>);
}

void single(std::ranges::single_view<int> s) {
 auto ci = cbegin(s);
 static_assert(ConstantIterator<decltype(ci)>);

auto c = s | const_;
 static_assert(not ConstantRange<decltype(s)>);
 static_assert(ConstantRange<decltype(s) const>);
 static_assert(ConstantRange<decltype(c)>);
 static_assert(std::same_as<std::ranges::range_reference_t<decltype(c)>, int const&>);
}

void const_single(std::ranges::single_view<int> const cs) {
 auto ci = cbegin(cs);
 static_assert(ConstantIterator<decltype(ci)>);

auto c = cs | const_;
 static_assert(ConstantRange<decltype(cs)>);
 static_assert(ConstantRange<decltype(c)>);
 static_assert(std::same_as<std::ranges::range_reference_t<decltype(c)>, int const&>);
}

template <typename T, typename U>
concept weak_equality_comparable_with = requires (std::remove_reference_t<T> const& t, std::remove_reference_t const& u) {
 { t == u } -> std::convertible_to<bool>;
 { t != u } -> std::convertible_to<bool>;
 { u == t } -> std::convertible_to<bool>;
 { u != t } -> std::convertible_to<bool>;
};

static_assert(weak_equality_comparable_with<const_iterator<int*>, int const*>);

void mix(std::vector<int> a, zstring b) {
 using std::ranges::iterator_t;
 using std::ranges::sentinel_t;
 using std::ranges::range;
 using std::sentinel_for;
 using std::equality_comparable_with;
 using std::three_way_comparable_with;

auto validate_iter_sentinel = []<typename R>(R& r){
 auto const_r = const_(r);
 using C = decltype(const_r);

static_assert(equality_comparable_with<iterator_t<R>, iterator_t<C>>);
 static_assert(equality_comparable_with<iterator_t<R>, iterator_t<C const>>);
 static_assert(equality_comparable_with<iterator_t<R const>, iterator_t<C>>);
 static_assert(equality_comparable_with<iterator_t<R const>, iterator_t<C const>>);

static_assert(sentinel_for<sentinel_t<C>, iterator_t<C>>);
 static_assert(sentinel_for<sentinel_t<C const>, iterator_t<C>>);
 static_assert(sentinel_for<sentinel_t<C>, iterator_t<C const>>);
 static_assert(sentinel_for<sentinel_t<C const>, iterator_t<C const>>);

static_assert(sentinel_for<sentinel_t<C>, iterator_t<R>>);
 static_assert(sentinel_for<sentinel_t<C const>, iterator_t<R>>);
 static_assert(sentinel_for<sentinel_t<C>, iterator_t<R const>>);
 static_assert(sentinel_for<sentinel_t<C const>, iterator_t<R const>>);

static_assert(sentinel_for<sentinel_t<R>, iterator_t<C>>);
 static_assert(sentinel_for<sentinel_t<R>, iterator_t<C const>>);
 static_assert(sentinel_for<sentinel_t<R const>, iterator_t<C>>);
 static_assert(sentinel_for<sentinel_t<R const>, iterator_t<C const>>);

static_assert(three_way_comparable_with<iterator_t<R>, iterator_t<C>>);
 static_assert(three_way_comparable_with<iterator_t<R>, iterator_t<C const>>);
 static_assert(three_way_comparable_with<iterator_t<R const>, iterator_t<C>>);
 static_assert(three_way_comparable_with<iterator_t<R const>, iterator_t<C const>>);
 };

auto c = a | std::views::transform([](int& i) -> int& { return i; });
    auto d = b | std::views::transform([](char& c) -> char& { return c; });

validate_iter_sentinel(a);
    validate_iter_sentinel(b);
    validate_iter_sentinel(c);
    validate_iter_sentinel(d);
    validate_iter_sentinel(std::as_const(a));
    validate_iter_sentinel(std::as_const(b));
    validate_iter_sentinel(std::as_const(c));
    validate_iter_sentinel(std::as_const(d));
}

template <bool C>
struct legacy_ra_iter {
 using value_type = int;
 using reference = std::conditional_t<C, int const&, int&>;
 using difference_type = std::ptrdiff_t;
 using iterator_category = std::random_access_iterator_tag;

legacy_ra_iter();
 legacy_ra_iter(legacy_ra_iter<!C> const&) requires C;

auto operator*() const -> reference;
    auto operator++() -> legacy_ra_iter&;
    auto operator++(int) -> legacy_ra_iter;
    auto operator--() -> legacy_ra_iter&;
    auto operator--(int) -> legacy_ra_iter;

#pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wnon-template-friend"
    auto operator-(legacy_ra_iter const&) const -> difference_type;
    auto operator-(difference_type) const -> legacy_ra_iter;
    auto operator+(difference_type) const -> legacy_ra_iter;
    friend auto operator+(difference_type, legacy_ra_iter const&) -> legacy_ra_iter;
    auto operator+=(difference_type) -> legacy_ra_iter&;
    auto operator-=(difference_type) -> legacy_ra_iter&;
    auto operator[](difference_type) const -> reference;

friend auto operator==(legacy_ra_iter, legacy_ra_iter) -> bool;
 friend auto operator!=(legacy_ra_iter, legacy_ra_iter) -> bool;
 friend auto operator< (legacy_ra_iter, legacy_ra_iter) -> bool;
 friend auto operator<=(legacy_ra_iter, legacy_ra_iter) -> bool;
 friend auto operator> (legacy_ra_iter, legacy_ra_iter) -> bool;
 friend auto operator>=(legacy_ra_iter, legacy_ra_iter) -> bool;
 #pragma GCC diagnostic pop
};

static_assert(std::random_access_iterator<legacy_ra_iter<false>>);
static_assert(std::random_access_iterator<legacy_ra_iter<true>>);

// cross-comparable but not cross-subtractible
static_assert(std::totally_ordered_with<legacy_ra_iter<false>, legacy_ra_iter<true>>);
static_assert(not std::sized_sentinel_for<legacy_ra_iter<true>, legacy_ra_iter<false>>);
static_assert(not std::sized_sentinel_for<legacy_ra_iter<false>, legacy_ra_iter<true>>);
static_assert(std::sized_sentinel_for<legacy_ra_iter<true>, legacy_ra_iter<true>>);
static_assert(std::sized_sentinel_for<legacy_ra_iter<false>, legacy_ra_iter<false>>);

// so we need to reflect that
static_assert(std::totally_ordered_with<legacy_ra_iter<false>, const_iterator<legacy_ra_iter<false>>>);
static_assert(std::totally_ordered_with<legacy_ra_iter<false>, const_iterator<legacy_ra_iter<true>>>);
static_assert(std::totally_ordered_with<legacy_ra_iter<true>, const_iterator<legacy_ra_iter<false>>>);
static_assert(std::totally_ordered_with<legacy_ra_iter<true>, const_iterator<legacy_ra_iter<true>>>);

static_assert(std::sized_sentinel_for<legacy_ra_iter<true>, const_iterator<legacy_ra_iter<true>>>);
static_assert(std::sized_sentinel_for<legacy_ra_iter<false>, const_iterator<legacy_ra_iter<false>>>);
static_assert(std::sized_sentinel_for<const_iterator<legacy_ra_iter<true>>, legacy_ra_iter<true>>);
static_assert(std::sized_sentinel_for<const_iterator<legacy_ra_iter<false>>, legacy_ra_iter<false>>);
static_assert(not std::sized_sentinel_for<legacy_ra_iter<false>, const_iterator<legacy_ra_iter<true>>>);
static_assert(not std::sized_sentinel_for<legacy_ra_iter<true>, const_iterator<legacy_ra_iter<false>>>);
static_assert(not std::sized_sentinel_for<const_iterator<legacy_ra_iter<true>>, legacy_ra_iter<false>>);
static_assert(not std::sized_sentinel_for<const_iterator<legacy_ra_iter<false>>, legacy_ra_iter<true>>);

// final boss?
static_assert(std::equality_comparable<basic_const_iterator<int*>>);
static_assert(std::equality_comparable<basic_const_iterator<int volatile*>>);
static_assert(std::equality_comparable_with<basic_const_iterator<int*>, basic_const_iterator<int volatile*>>);

static_assert(std::totally_ordered<basic_const_iterator<int*>>);
static_assert(std::totally_ordered<basic_const_iterator<int volatile*>>);
static_assert(std::totally_ordered_with<basic_const_iterator<int*>, basic_const_iterator<int volatile*>>);
static_assert(std::three_way_comparable_with<basic_const_iterator<int*>, basic_const_iterator<int volatile*>>);