Разделить диапазон на диапазон перекрывающихся диапазонов

Если я правильно понимаю ваши требования, вы можете реализовать генератор в терминах adjacent_find:

namespace detail {
    template<typename IterT, typename SentT>
    struct seg_gen_fn {
        IterT it_;
        SentT end_;
        bool parity_ = true;

        ranges::iterator_range<IterT> operator ()() {
            if (it_ == end_) {
                return {it_, it_};
            }

            auto n = ranges::adjacent_find(
                it_, end_,
                [p = std::exchange(parity_, !parity_)](auto const a, auto const b) {
                    return a && !b == p;
                }
            );
            return {
                std::exchange(it_, n),
                n != end_ ? ranges::next(std::move(n)) : std::move(n)
            };
        }
    };

    template<typename RngT>
    constexpr auto seg_gen(RngT&& rng)
     -> seg_gen_fn<ranges::iterator_t<RngT>, ranges::sentinel_t<RngT>>
    { return {ranges::begin(rng), ranges::end(rng)}; }
} // namespace detail

auto const segmented_view = [](auto&& rng) {
    return ranges::view::generate(detail::seg_gen(decltype(rng)(rng)))
         | ranges::view::take_while([](auto const& seg) { return !seg.empty(); });
};

int main() {
    auto const ns = {1, 2, 3, 0, 4, 0, 5, 0, 6, 7, 8, 0, 0, 9};
    ranges::copy(segmented_view(ns), ranges::ostream_iterator<>{std::cout, "\n"});
}

Интернет-демонстрация
_{Не так кратко, как можно было бы надеяться ...: - [}

Это, вероятно, подходит для одноразового кода, но нужно немного поработать, и его можно будет использовать повторно:

namespace detail {
    namespace tag = ranges::tag;

    template<
        typename RngT, typename PredT, typename IterT = ranges::iterator_t<RngT>,
        typename StateT = ranges::tagged_compressed_tuple<
            tag::begin(IterT), tag::end(ranges::sentinel_t<RngT>),
            tag::current(bool), tag::fun(ranges::semiregular_t<PredT>)
        >
    >
    struct seg_gen_fn : private StateT {
        constexpr seg_gen_fn(RngT&& rng, PredT pred)
          : StateT{ranges::begin(rng), ranges::end(rng), true, std::move(pred)}
        { }

        ranges::iterator_range<IterT> operator ()() {
            StateT& state = *this;
            auto& it = state.begin();
            if (it == state.end()) {
                return {it, it};
            }

            auto& parity = state.current();
            auto n = ranges::adjacent_find(
                it, state.end(),
                [p = std::exchange(parity, !parity), &pred = state.fun()]
                (auto const& a, auto const& b) {
                    return !pred(a) && pred(b) == p;
                }
            );
            return {
                std::exchange(it, n),
                n != state.end() ? ranges::next(std::move(n)) : std::move(n)
            };
        }
    };

    template<typename RngT, typename PredT>
    constexpr seg_gen_fn<RngT, PredT> seg_gen(RngT&& rng, PredT pred) {
        return {std::forward<RngT>(rng), std::move(pred)};
    }
} // namespace detail

auto const segmented_view = [](auto&& rng, auto pred) {
    return ranges::view::generate(detail::seg_gen(decltype(rng)(rng), std::move(pred)))
         | ranges::view::take_while([](auto const& seg) { return !seg.empty(); });
};

int main() {
    auto const ns = {1, 2, 3, 0, 4, 0, 5, 0, 6, 7, 8, 0, 0, 9};
    ranges::copy(
        segmented_view(ns, [](auto const n) { return n == 0; }),
        ranges::ostream_iterator<>{std::cout, "\n"}
    );
}

Интернет-демонстрация

Проверка концепций и прогнозы оставлены как упражнение.