Реализация take_ while_inclusive :views::take_ while, но с включением предиката отсутствия элемента

Для forward_range вы можете сначала дойти до конца take_while_view, а затем продвинуться на один шаг вперед, чтобы получить первый итератор, который не удовлетворяет предикату для создания нового subrange:

auto take_while = vec | std::views::take_while(predicate);
auto last = std::ranges::next(vec.begin(), take_while.end());
auto take_while_inclusive = std::ranges::subrange(
  vec.begin(),
  std::ranges::next(last, 1, vec.end())
);

Демо

Вы можете гарантировать, что он будет лениво оцениваться, написав его как генератор.

template<std::ranges::view V, typename Pred>
    requires ranges::input_range<V> &&
             std::indirect_unary_predicate<const Pred, std::ranges::iterator_t<V>>
std::generator<std::ranges::range_value_t<V>> take_while_inclusive(V&& view, Pred&& pred) {
    auto take_while = vec | std::views::take_while(predicate);
    auto it = take_while.begin();
    for (; it != take_while.end(); ++it) co_yield *it;
    co_yield std::ranges::elements_of(std::ranges::subrange(it, std::ranges::next(it, 1, vec.end())));
}

std::generator находится на C++23, но вы можете его бэкпортировать.

Если вы хотите, чтобы это был адаптер диапазона, вы можете использовать помощник C++23 std::ranges::range_adaptor_closure или написать механизм самостоятельно.

template<typename Pred>
requires std::is_object_v<Pred>
struct take_while_inclusive_fn : std::ranges::range_adaptor_closure<take_while_inclusive_fn> {
    Pred pred;
    template <std::ranges::view V>
    requires ranges::input_range<V> &&
        std::indirect_unary_predicate<const Pred, std::ranges::iterator_t<V>>
    auto operator()(V&& view) { return take_while_inclusive(std::forward<V>(view), pred); }
};

Ответ на мой первоначальный вопрос

Я обнаружил, что реальная реализация того, что я назвал take_while_inclusive в своем первоначальном вопросе, была предложена для C++26 в P3220R0 под именем std::delimit (что, на мой взгляд, на самом деле гораздо лучшее имя)

Реализацию для libc++ можно найти здесь

Если у вас нет таких же ограничений (constexpr, lazy, передать только один раз), как у меня, я думаю, что другие ответы, предложенные здесь, хороши, но это решение объединяет лучшее из всех миров.

Однако

Как это часто бывает, когда мы пытаемся найти решение проблемы, в конечном итоге мы ищем решение подзадачи, не осознавая, что пытаемся решить вопрос не с той стороны. У меня так было, и я благодарю @Caleth за то, что он указал мне на это.

Если вы, как и я, на самом деле пытаетесь собрать диапазон ожидаемых значений в ожидаемый диапазон, я думаю, вам следует попробовать использовать собрать

Основное поведение:

#include <fmt/ranges.h>
int main() {
    std::vector<std::expected<int, std::string>> has_error = {
        1, 2, std::unexpected("NOT INT")};
    std::vector<std::expected<int, std::string>> no_error = {1, 2, 3};

    std::expected<std::vector<int>, std::string> exp_error = has_error 
        | views::collect();
    auto exp_value = no_error | views::collect();

    auto print = [](const auto& expected) {
        if (expected.has_value())
            fmt::println("Valid result : {}", expected.value());
        else
            fmt::println("Error : {}", expected.error());
    };

    print(exp_error);
    print(exp_value);
}

Выход :

Error : NOT INT
Valid result : [1, 2, 3]