Iterate over equal ranges of range with C++20 - c++

Question

I am wondering if C++20 ranges have some nice way for me to iterate over the equal ranges of sorted container(or in general case any sorted range).
I have this "manual" solution that works, but it is not nice in a sense that it is not really composable (I do not get some view of equal range views back, I just provide function to be called).
#include <vector>
#include <ranges>
#include <iostream>
#include <fmt/ranges.h>
template<typename Cont, typename Fn>
void for_each_equal_range(const Cont& cont, Fn fn){
auto current_begin = cont.begin();
while(true){
if (current_begin==cont.end()){
return;
}
auto [eq_begin, eq_end] = std::equal_range(current_begin, cont.end(), *current_begin);
fn(eq_begin, eq_end);
current_begin = eq_end;
}
}
int main() {
std::vector vals {1,2,2,3,3,3,47};
for_each_equal_range(vals, [](const auto b, const auto e){
std::cout << "size: " << std::distance(b,e) << std::endl;
std::ranges::subrange elems(b, e);
std::cout << fmt::format("{}",elems) << std::endl;
});
}
I wish I had something like:
vals | equal_range_split | std::ranges::for_each(...);
In case there is some confusion wrt what range means here:
equal range is good old STL equal_range meaning
ranges is C++20 ranges library.
Also I know C++20 has std::ranges::equal_range algorithm, but it seems to be not that helpful for my use case.

Answer 1

Not quite what you are looking for, but if you have a coroutine generator template, something like
using namespace std::ranges;
template<typename Range, typename Compare = std::less>
generator<subrange<iterator_t<Range>>> equal_ranges(Range&& range, Compare compare = {}) {
for (auto current_begin = cont.begin(); current_begin != cont.end();) {
auto [eq_begin, eq_end] = std::equal_range(current_begin, cont.end(), *current_begin, compare);
co_yield { eq_begin, eq_end };
current_begin = eq_end;
}
}
template<typename Compare>
struct equal_ranges_holder {
Compare compare;
};
template<typename Compare = std::less>
equal_ranges_holder<Compare> equal_ranges(Compare compare = {}) { return { compare }; }
template<typename Range, typename Compare>
auto operator|(Range&& range, equal_ranges_holder<Compare> holder) {
return equal_ranges(range, holder.compare);
}
Alternatively, it's fairly simple to make a single pass equal_range_view.
using namespace std::ranges;
template<borrowed_range Range, std::strict_weak_order Compare = std::less>
class equal_range_view : public view_interface<equal_range_view> {
using base_iterator = iterator_t<Range>;
using base_sentinel = sentinel_t<Range>;
Range range;
Compare compare;
public:
class sentinel {};
class iterator {
base_iterator base;
base_sentinel end;
Compare compare;
public:
using value_type = subrange<base_iterator>;
using reference = value_type;
using pointer = value_type *;
using difference_type = std::ptrdiff_t;
using iterator_category = std::input_iterator_tag;
equal_range_iterator(base_iterator base, base_sentinel end, Compare compare) : base(base), end(end), compare(compare) {}
reference operator*() {
auto [first, last] = std::equal_range(base, end, compare);
return { first, last };
}
iterator& operator++() {
auto [_, last] = std::equal_range(base, end, compare);
base = last;
return *this;
}
bool operator==(sentinel) const {
return base == end;
}
bool operator!=(sentinel) const {
return base != end;
}
};
explicit equal_range_view(Range range, Compare compare = {}) : range(range), compare(compare) {}
iterator begin() { return { range.begin(), range.end(), compare }; }
sentinel end() { return {}; }
};

Answer 2

In C++20, pipe operator has not defined for std::ranges::equal_range and std::ranges::for_each yet. So simple technique to implement above code is like:
for (int global = *vals.begin() - 1 ;
auto val : vals | std::ranges::views::filter([&](auto value){return value != global ;}))
{
std::ranges::for_each(std::ranges::equal_range(vals, val), [](auto& x){ std::cout << x << std::endl; });
global = val;
}