Compiler Explorer

Source code

#include <fmt/format.h>
#include <fmt/ranges.h>

#include <algorithm>
#include <iterator>
#include <ranges>
#include <utility>
#include <type_traits>
#include <span>
#include <string_view>

namespace std {

namespace __idk_detail {
		template <typename T, template <typename...> class Templ>
		struct __is_specialization_of_impl : ::std::false_type { };
		template <typename... T, template <typename...> class Templ>
		struct __is_specialization_of_impl<Templ<T...>, Templ> : ::std::true_type { };
	} // namespace __idk_detail

//////
	/// @brief Checks whether the given full, complete type from the first argument is related to the raw template name
	/// provided in the second.
	template <typename T, template <typename...> class Templ>
	using is_specialization_of = __idk_detail::__is_specialization_of_impl<remove_cvref_t<T>, Templ>;

//////
	/// @brief A @c _v alias for ztd::is_specialization_of.
	template <typename T, template <typename...> class Templ>
	inline constexpr bool is_specialization_of_v = is_specialization_of<T, Templ>::value;

} // namespace std

namespace std {

//////
	/// @brief The tag_t alias produces the type of the given reconstruction point. It's used to directly hook into the
	/// tag_invoke infrastructure.
	//////
	template <auto& _Name>
	using tag_t = ::std::remove_cv_t<::std::remove_reference_t<decltype(_Name)>>;

namespace __tginv_detail {
		namespace __adl {

#if 0
			// poison pill
			// This is disabled in general becase the poison pill is actually creating serious problems on MSVC, GCC,
			// and under select conditions Clang. I can imagine that there's some special change made in the standard
			// between C++14/1 and C++20 and on so that this works better but I truthfully cannot be assed to figure
			// it out.
			constexpr void tag_invoke() = delete;
#endif

template <typename _Tag, typename... _Args>
			constexpr auto __adl_tag_invoke(_Tag&& __tag, _Args&&... __args) noexcept(
			     noexcept(tag_invoke(::std::declval<_Tag>(), ::std::declval<_Args>()...)))
			     -> decltype(tag_invoke(::std::declval<_Tag>(), ::std::declval<_Args>()...)) {
				return tag_invoke(::std::forward<_Tag>(__tag), ::std::forward<_Args>(__args)...);
			}
		} // namespace __adl

class tag_invoke_fn {
		public:
			template <typename _Tag, typename... _Args>
			constexpr auto operator()(_Tag&& __tag, _Args&&... __args) const
			     noexcept(noexcept(__adl::__adl_tag_invoke(::std::declval<_Tag>(), ::std::declval<_Args>()...)))
			          -> decltype(__adl::__adl_tag_invoke(::std::declval<_Tag>(), ::std::declval<_Args>()...)) {
				return __adl::__adl_tag_invoke(::std::forward<_Tag>(__tag), ::std::forward<_Args>(__args)...);
			}
		};
	} // namespace __tginv_detail

//////
	/// @brief The tag invoke function.
	///
	//////
	inline constexpr __tginv_detail::tag_invoke_fn tag_invoke {};

namespace __tginv_detail {
		template <bool, typename _Tag, typename... _Args>
		class __is_nothrow_tag_invocable_i : public ::std::false_type { };

template <typename _Tag, typename... _Args>
		class __is_nothrow_tag_invocable_i<true, _Tag, _Args...>
		: public ::std::integral_constant<bool, ::std::is_nothrow_invocable_v<decltype(tag_invoke), _Tag, _Args...>> {
		};
	} // namespace __tginv_detail

//////
	/// @brief Whether or not a given tag type and its arguments are tag invocable.
	///
	//////
	template <typename _Tag, typename... _Args>
	class is_tag_invocable : public ::std::is_invocable<decltype(tag_invoke), _Tag, _Args...> { };

//////
	/// @brief A @c _v alias for ztd::is_tag_invocable.
	///
	//////
	template <typename _Tag, typename... _Args>
	inline constexpr bool is_tag_invocable_v = is_tag_invocable<_Tag, _Args...>::value;

//////
	/// @brief Whether or not a given tag type and its arguments are both invocable and marked as a @c noexcept
	/// invocation.
	///
	//////
	template <typename _Tag, typename... _Args>
	class is_nothrow_tag_invocable
	: public __tginv_detail::__is_nothrow_tag_invocable_i<is_tag_invocable_v<_Tag, _Args...>, _Tag, _Args...> { };

//////
	/// @brief A @c _v alias for ztd::is_nothrow_tag_invocable.
	///
	//////
	template <typename _Tag, typename... _Args>
	inline constexpr bool is_nothrow_tag_invocable_v = is_nothrow_tag_invocable<_Tag, _Args...>::value;

//////
	/// @brief A class representing the type that results from a tag invocation.
	///
	//////
	template <typename _Tag, typename... _Args>
	using tag_invoke_result = ::std::invoke_result<decltype(tag_invoke), _Tag, _Args...>;

//////
	/// @brief A @c _t alias that gives the actual type that results from a tag invocation.
	///
	//////
	template <typename _Tag, typename... _Args>
	using tag_invoke_result_t = typename tag_invoke_result<_Tag, _Args...>::type;

namespace __hijack {
        //////
        /// @brief A token to derive from, which in some cases allows external members to place customization points and
        /// extension functions in the __hijack namespace. Extension points would be defined in the "namespace ztd {
        /// namespace __hijack { /* here */ }}" area.
        //////
        struct token { };
    }

} // namespace std

namespace std { namespace ranges {
	namespace __rng_detail {

class __reconstruct_fn;

template <typename _It, typename _Sen>
		static constexpr bool __is_cascade_iterator_reconstruct_noexcept() noexcept {
			if constexpr (((::std::is_class_v<_It> || ::std::is_enum_v<_It>)
				              || (::std::is_class_v<_Sen> || ::std::is_enum_v<_Sen>))
				&& is_tag_invocable_v<__reconstruct_fn, _It, _Sen>) {
				return is_nothrow_tag_invocable_v<__reconstruct_fn, _It, _Sen>;
			}
			else {
				return ::std::is_nothrow_constructible_v<subrange<remove_cvref_t<_It>, remove_cvref_t<_Sen>>, _It,
					_Sen>;
			}
		}

template <typename _InPlace, typename _It, typename _Sen>
		static constexpr bool __is_cascade_reconstruct_noexcept() noexcept {
			return is_tag_invocable_v<__reconstruct_fn, _InPlace, _It, _Sen>
				? is_nothrow_tag_invocable_v<__reconstruct_fn, _InPlace, _It, _Sen>
				: __is_cascade_iterator_reconstruct_noexcept<_It, _Sen>();
		}

template <typename _InPlace, typename _Range, typename _It, typename _Sen>
		static constexpr bool __is_cascade_range_iterator_reconstruct_noexcept() noexcept {
			return is_tag_invocable_v<__reconstruct_fn, _InPlace, _Range, _It, _Sen>
				? is_nothrow_tag_invocable_v<__reconstruct_fn, _InPlace, _Range, _It, _Sen>
				: __is_cascade_reconstruct_noexcept<_InPlace, _It, _Sen>();
		}

template <typename _InPlace, typename _Range>
		static constexpr bool __is_cascade_range_reconstruct_noexcept() noexcept {
			return __is_cascade_range_iterator_reconstruct_noexcept<_InPlace, _Range, ::std::ranges::iterator_t<_Range>,
				::std::ranges::sentinel_t<_Range>>();
		}

template <typename _InPlaceOrIt, typename _RangeOrSen>
		static constexpr bool __is_cascade_range_reconstruct_or_iterator_reconstruct_noexcept() noexcept {
			if constexpr (::std::is_specialization_of_v<::std::remove_cvref_t<_InPlaceOrIt>, ::std::in_place_type_t>) {
				return __is_cascade_range_reconstruct_noexcept<_InPlaceOrIt, _RangeOrSen>();
			}
			else {
				return __is_cascade_iterator_reconstruct_noexcept<_InPlaceOrIt, _RangeOrSen>();
			}
		}

class __reconstruct_fn : public ::std::__hijack::token {
		public:
			template <typename _InPlaceTag, typename _It, typename _Sen>
			constexpr auto operator()(
				::std::in_place_type_t<_InPlaceTag> __inplace, _It&& __iterator, _Sen&& __sentinel) const
				noexcept(__is_cascade_reconstruct_noexcept<::std::in_place_type_t<_InPlaceTag>, _It, _Sen>()) {
				if constexpr (is_tag_invocable_v<__reconstruct_fn, ::std::in_place_type_t<_InPlaceTag>, _It,
					              _Sen>) {
					return ::std::tag_invoke(
						*this, __inplace, ::std::forward<_It>(__iterator), ::std::forward<_Sen>(__sentinel));
				}
				else {
					(void)__inplace;
					return (*this)(::std::forward<_It>(__iterator), ::std::forward<_Sen>(__sentinel));
				}
			}

template <typename _InPlaceTag, typename _Range, typename _It, typename _Sen>
			constexpr decltype(auto) operator()(
				::std::in_place_type_t<_InPlaceTag> __inplace, _Range&& __range, _It&& __it, _Sen&& __sen) const
				noexcept(__is_cascade_range_iterator_reconstruct_noexcept<::std::in_place_type_t<_InPlaceTag>,
				     _Range, _It, _Sen>()) {
				if constexpr (is_tag_invocable_v<__reconstruct_fn, ::std::in_place_type_t<_InPlaceTag>, _Range, _It,
					              _Sen>) {
					return ::std::tag_invoke(*this, __inplace, ::std::forward<_Range>(__range),
						::std::forward<_It>(__it), ::std::forward<_Sen>(__sen));
				}
				else {
					return (*this)(__inplace, ::std::forward<_It>(__it), ::std::forward<_Sen>(__sen));
				}
			}

template <typename _InPlaceOrIt, typename _RangeOrSen>
			constexpr decltype(auto) operator()(
				_InPlaceOrIt&& __inplace_or_iterator, _RangeOrSen&& __range_or_sentinel) const
				noexcept(
				     __is_cascade_range_reconstruct_or_iterator_reconstruct_noexcept<_InPlaceOrIt, _RangeOrSen>()) {
				if constexpr (is_specialization_of_v<remove_cvref_t<_InPlaceOrIt>, ::std::in_place_type_t>) {
					if constexpr (is_tag_invocable_v<__reconstruct_fn, _InPlaceOrIt, _RangeOrSen>) {
						return ::std::tag_invoke(*this, ::std::forward<_InPlaceOrIt>(__inplace_or_iterator),
							::std::forward<_RangeOrSen>(__range_or_sentinel));
					}
					else {
						return (*this)(::std::forward<_InPlaceOrIt>(__inplace_or_iterator),
							::std::forward<_RangeOrSen>(__range_or_sentinel),
							::std::ranges::begin(__range_or_sentinel),
							::std::ranges::end(__range_or_sentinel));
					}
				}
				else if constexpr (((::std::is_class_v<_InPlaceOrIt> || ::std::is_enum_v<_InPlaceOrIt>)
					                   || (::std::is_class_v<_RangeOrSen> || ::std::is_enum_v<_RangeOrSen>))
					&& is_tag_invocable_v<__reconstruct_fn, _InPlaceOrIt, _RangeOrSen>) {
					return ::std::tag_invoke(*this, ::std::forward<_InPlaceOrIt>(__inplace_or_iterator),
						::std::forward<_RangeOrSen>(__range_or_sentinel));
				}
				else {
					// static_assert(ztd::always_false_v<_InPlaceOrIt>, "fuck off");
					return subrange<remove_cvref_t<_InPlaceOrIt>, remove_cvref_t<_RangeOrSen>>(
						::std::forward<_InPlaceOrIt>(__inplace_or_iterator),
						::std::forward<_RangeOrSen>(__range_or_sentinel));
				}
			}
		};

} // namespace __rng_detail

inline namespace _c {
		//////
		/// @brief An implementation of the P1664 (https://wg21.link/p1664 |
		/// https://thephd.dev/_vendor/future_cxx/papers/d1664.html) reconstructible ranges extension point. It is
		/// derives from std::__hijack::token in order for outside implementations to have a common place to put
		/// reconstruction for things outside of their control, without needing to place it in the global namespace or
		/// the immediate ztd::ranges namespace, where there are too many other types that could force asking more
		/// questions about what is in the list for ADL and drive up compile-times.
		inline constexpr __rng_detail::__reconstruct_fn reconstruct = {};
	} // namespace _c

}} // namespace std::ranges

// P1664, reconstructible range extension points
namespace std { namespace __hijack {
    template <typename _Ty, decltype(::std::dynamic_extent) _Extent, typename _It, typename _Sen>
        requires ::std::contiguous_iterator<_It> && ::std::contiguous_iterator<_Sen>
	constexpr ::std::span<_Ty> tag_invoke(std::tag_t<::std::ranges::reconstruct>,
		::std::in_place_type_t<::std::span<_Ty, _Extent>>, _It __iterator, _Sen __sentinel) noexcept {
		if constexpr (!::std::is_integral_v<_Sen>) {
			auto __iterator_address = *&__iterator;
			return ::std::span<_Ty>(__iterator_address, static_cast<::std::size_t>(__sentinel - __iterator));
		}
		else {
			auto __iterator_address = &*__iterator;
			return ::std::span<_Ty>(__iterator_address, __sentinel);
		}
	}

template <typename _Ty, typename _Traits, typename _It, typename _Sen>
        requires ::std::contiguous_iterator<_It> && ::std::contiguous_iterator<_Sen>
	constexpr ::std::basic_string_view<_Ty, _Traits> tag_invoke(std::tag_t<::std::ranges::reconstruct>,
		::std::in_place_type_t<::std::basic_string_view<_Ty, _Traits>>, _It __iterator, _Sen __sentinel) noexcept {
		using _SizeType = typename ::std::basic_string_view<_Ty, _Traits>::size_type;
		if constexpr (!::std::is_integral_v<_Sen>) {
            auto __iterator_address = &*__iterator;
			_SizeType __ptr_size = static_cast<_SizeType>(__sentinel - __iterator);
			return ::std::basic_string_view<_Ty, _Traits>(__iterator_address, __ptr_size);
		}
		else {
            auto __iterator_address = &*__iterator;
			return ::std::basic_string_view<_Ty, _Traits>(
				__iterator_address, static_cast<_SizeType>(__sentinel));
		}
	}
}} // namespace std::__hijack

namespace std::ranges {

template <typename _Range, typename _It = ranges::iterator_t<remove_cvref_t<_Range>>,
    typename _Sen = ranges::sentinel_t<remove_cvref_t<_Range>>>
	using reconstruct_t = decltype(ranges::reconstruct(
        ::std::declval<::std::in_place_type_t<remove_cvref_t<_Range>>>(),
		     ::std::declval<_It>(), ::std::declval<_Sen>()
    ));

template <typename _Tag, typename _Range = _Tag>
	using tag_range_reconstruct_t = decltype(ranges::reconstruct(
		::std::declval<::std::in_place_type_t<remove_cvref_t<_Tag>>>(),
        ::std::declval<_Range>()
    ));

} // namespace std::ranges

// The existing split implementation, as modified by P2210
namespace std::ranges {

template <input_range _Vp, forward_range _Pattern>
requires view<_Vp> && view<_Pattern> &&
    indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
                          ranges::equal_to> &&
    (forward_range<_Vp> ||
     __detail::__tiny_range<_Pattern>)class revzin_lazy_split_view
    : public view_interface<revzin_lazy_split_view<_Vp, _Pattern>> {
 private:
  template <bool _Const>
  struct _InnerIter;

template <bool _Const>
  struct _OuterIter {
   private:
    using _Parent = __detail::__maybe_const_t<_Const, revzin_lazy_split_view>;
    using _Base = __detail::__maybe_const_t<_Const, _Vp>;

constexpr bool __at_end() const {
      return __current() == ranges::end(_M_parent->_M_base) && !trailing_empty;
    }

// [range.split.outer] p1
    //  Many of the following specifications refer to the notional member
    //  current of outer-iterator.  current is equivalent to current_ if
    //  V models forward_range, and parent_->current_ otherwise.
    constexpr auto& __current() noexcept {
      if constexpr (forward_range<_Vp>)
        return _M_current;
      else
        return _M_parent->_M_current;
    }

constexpr auto& __current() const noexcept {
      if constexpr (forward_range<_Vp>)
        return _M_current;
      else
        return _M_parent->_M_current;
    }

_Parent* _M_parent = nullptr;

// XXX: _M_current is present only if "V models forward_range"
    [[no_unique_address]] __detail::__maybe_present_t<forward_range<_Vp>,
                                                      iterator_t<_Base>>
        _M_current;

// P2210: need this extra member on the outer iterator
    bool trailing_empty = false;

public:
    using iterator_concept =
        conditional_t<forward_range<_Base>, forward_iterator_tag,
                      input_iterator_tag>;
    using iterator_category = input_iterator_tag;
    using difference_type = range_difference_t<_Base>;

struct value_type : view_interface<value_type> {
     private:
      _OuterIter _M_i = _OuterIter();

public:
      value_type() = default;

constexpr explicit value_type(_OuterIter __i) : _M_i(std::move(__i)) {}

constexpr _InnerIter<_Const> begin() const requires copyable<_OuterIter> {
        return _InnerIter<_Const>{_M_i};
      }

constexpr _InnerIter<_Const> begin() requires(!copyable<_OuterIter>) {
        return _InnerIter<_Const>{std::move(_M_i)};
      }

constexpr default_sentinel_t end() const { return default_sentinel; }
    };

_OuterIter() = default;

constexpr explicit _OuterIter(_Parent* __parent) requires(
        !forward_range<_Base>)
        : _M_parent(__parent) {}

constexpr _OuterIter(_Parent* __parent,
                         iterator_t<_Base> __current) requires
        forward_range<_Base> : _M_parent(__parent),
                               _M_current(std::move(__current)) {}

constexpr _OuterIter(_OuterIter<!_Const> __i) requires _Const
        && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
        : _M_parent(__i._M_parent), _M_current(std::move(__i._M_current)) {}

constexpr value_type operator*() const { return value_type{*this}; }

constexpr _OuterIter& operator++() {
      const auto __end = ranges::end(_M_parent->_M_base);
      if (__current() == __end) {
        // LWG3478: there's no trailing empty range (if there was one before)
        trailing_empty = false;
        return *this;
      }

const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
      if (__pbegin == __pend) {
        ++__current();
      } else if constexpr (__detail::__tiny_range<_Pattern>) {
        __current() = ranges::find(std::move(__current()), __end, *__pbegin);
        if (__current() != __end) {
          ++__current();
          // LWG3478: if the delimiter is the last element, we still have one more empty to go
          if (__current() == __end) {
            trailing_empty = true;
          }
        }
      } else {
        do {
          auto [__b, __p] = ranges::mismatch(__current(), __end,
                                               __pbegin, __pend);
          if (__p == __pend) {
            __current() = __b;
            // LWG3478: set trailing_empty to true in this case
            if (__current() == __end) {
              trailing_empty = true;
            }
            break;
          }
        } while (++__current() != __end);
      }
      return *this;
    }

constexpr decltype(auto) operator++(int) {
      if constexpr (forward_range<_Base>) {
        auto __tmp = *this;
        ++*this;
        return __tmp;
      } else
        ++*this;
    }

friend constexpr bool operator==(const _OuterIter& __x,
                                     const _OuterIter& __y) requires
        forward_range<_Base> {
      // P2210: also check trailing_empty
      return __x._M_current == __y._M_current &&
             __x.trailing_empty == __y.trailing_empty;
    }

friend constexpr bool operator==(const _OuterIter& __x,
                                     default_sentinel_t) {
      return __x.__at_end();
    };

friend _OuterIter<!_Const>;
    friend _InnerIter<_Const>;
  };

template <bool _Const>
  struct _InnerIter {
   private:
    using _Base = __detail::__maybe_const_t<_Const, _Vp>;

constexpr bool __at_end() const {
      auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
      auto __end = ranges::end(_M_i._M_parent->_M_base);
      if constexpr (__detail::__tiny_range<_Pattern>) {
        const auto& __cur = _M_i_current();
        if (__cur == __end) return true;
        if (__pcur == __pend) return _M_incremented;
        return *__cur == *__pcur;
      } else {
        auto __cur = _M_i_current();
        if (__cur == __end) return true;
        if (__pcur == __pend) return _M_incremented;
        do {
          if (*__cur != *__pcur) return false;
          if (++__pcur == __pend) return true;
        } while (++__cur != __end);
        return false;
      }
    }

static constexpr auto _S_iter_cat() {
      using _Cat =
          typename iterator_traits<iterator_t<_Base>>::iterator_category;
      if constexpr (derived_from<_Cat, forward_iterator_tag>)
        return forward_iterator_tag{};
      else
        return _Cat{};
    }

constexpr auto& _M_i_current() noexcept { return _M_i.__current(); }

constexpr auto& _M_i_current() const noexcept { return _M_i.__current(); }

_OuterIter<_Const> _M_i = _OuterIter<_Const>();
    bool _M_incremented = false;

public:
    using iterator_concept = typename _OuterIter<_Const>::iterator_concept;
    using iterator_category = decltype(_S_iter_cat());
    using value_type = range_value_t<_Base>;
    using difference_type = range_difference_t<_Base>;

_InnerIter() = default;

constexpr explicit _InnerIter(_OuterIter<_Const> __i)
        : _M_i(std::move(__i)) {}

constexpr decltype(auto) operator*() const { return *_M_i_current(); }

// P2210: add base() to inner iterator
    constexpr iterator_t<_Base> base()
        const& requires copyable<iterator_t<_Base>> {
      return _M_i_current();
    }
    constexpr iterator_t<_Base> base() && { return std::move(_M_i_current()); }

constexpr _InnerIter& operator++() {
      _M_incremented = true;
      if constexpr (!forward_range<_Base>)
        if constexpr (_Pattern::size() == 0) return *this;
      ++_M_i_current();
      return *this;
    }

constexpr decltype(auto) operator++(int) {
      if constexpr (forward_range<_Vp>) {
        auto __tmp = *this;
        ++*this;
        return __tmp;
      } else
        ++*this;
    }

friend constexpr bool operator==(const _InnerIter& __x,
                                     const _InnerIter& __y) requires
        forward_range<_Base> {
      return __x._M_i == __y._M_i;
    }

friend constexpr bool operator==(const _InnerIter& __x,
                                     default_sentinel_t) {
      return __x.__at_end();
    }

friend constexpr decltype(auto) iter_move(const _InnerIter& __i) noexcept(
        noexcept(ranges::iter_move(__i._M_i_current()))) {
      return ranges::iter_move(__i._M_i_current());
    }

friend constexpr void
    iter_swap(const _InnerIter& __x, const _InnerIter& __y) noexcept(noexcept(
        ranges::iter_swap(__x._M_i_current(), __y._M_i_current()))) requires
        indirectly_swappable<iterator_t<_Base>> {
      ranges::iter_swap(__x._M_i_current(), __y._M_i_current());
    }
  };

_Pattern _M_pattern = _Pattern();
  // XXX: _M_current is "present only if !forward_range<V>"
  [[no_unique_address]] __detail::__maybe_present_t<!forward_range<_Vp>,
                                                    iterator_t<_Vp>>
      _M_current;
  _Vp _M_base = _Vp();

public:
  revzin_lazy_split_view() = default;

constexpr revzin_lazy_split_view(_Vp __base, _Pattern __pattern)
      : _M_pattern(std::move(__pattern)), _M_base(std::move(__base)) {}

template <input_range _Range>
  requires constructible_from<_Vp, views::all_t<_Range>> &&
      constructible_from<_Pattern, single_view<range_value_t<_Range>>>
  constexpr revzin_lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
      : _M_pattern(std::move(__e)),
        _M_base(views::all(std::forward<_Range>(__r))) {}

constexpr _Vp base() const& requires copy_constructible<_Vp> {
    return _M_base;
  }

constexpr _Vp base() && { return std::move(_M_base); }

constexpr auto begin() {
    if constexpr (forward_range<_Vp>)
      return _OuterIter<__detail::__simple_view<_Vp>>{this,
                                                      ranges::begin(_M_base)};
    else {
      _M_current = ranges::begin(_M_base);
      return _OuterIter<false>{this};
    }
  }

constexpr auto begin() const requires forward_range<_Vp> &&
      forward_range<const _Vp> {
    return _OuterIter<true>{this, ranges::begin(_M_base)};
  }

constexpr auto end() requires forward_range<_Vp> && common_range<_Vp> {
    return _OuterIter<__detail::__simple_view<_Vp>>{this, ranges::end(_M_base)};
  }

constexpr auto end() const {
    if constexpr (forward_range<_Vp> && forward_range<const _Vp> &&
                  common_range<const _Vp>)
      return _OuterIter<true>{this, ranges::end(_M_base)};
    else
      return default_sentinel;
  }
};

template <typename _Range, typename _Pred>
revzin_lazy_split_view(_Range&&, _Pred&&)
    -> revzin_lazy_split_view<views::all_t<_Range>, views::all_t<_Pred>>;

template <input_range _Range>
revzin_lazy_split_view(_Range&&, range_value_t<_Range>)
    -> revzin_lazy_split_view<views::all_t<_Range>,
                       single_view<range_value_t<_Range>>>;

namespace views {
inline constexpr __adaptor::_RangeAdaptor revzin_lazy_split =
    []<viewable_range _Range, typename _Fp>(_Range&& __r, _Fp&& __f) {
      return revzin_lazy_split_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
    };
}  // namespace views
}  // namespace std::ranges

// The new split implementation from P2210, here named revzin_split/revzin_split_view
namespace std::ranges {

template <forward_range V, forward_range Pattern>
requires view<V> && view<Pattern> &&
    indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
class revzin_split_view : public view_interface<revzin_split_view<V, Pattern>> {
 private:
  using _ReV = ::std::ranges::reconstruct_t<V, iterator_t<V>, iterator_t<V>>;
  V base_ = V();
  Pattern pattern_ = Pattern();
  struct iterator;
  struct sentinel;

struct iterator {
  private:
    friend sentinel;
    revzin_split_view* parent_ = nullptr;
    iterator_t<_ReV> cur_ = iterator_t<_ReV>();
    _ReV next_ = _ReV();
    bool trailing_empty_ = false;

public:
    using iterator_concept = forward_iterator_tag;
    using iterator_category = input_iterator_tag;
    using value_type = _ReV;
    using difference_type = range_difference_t<V>;

iterator() = default;
    constexpr iterator(revzin_split_view& parent, iterator_t<V> current,
                       _ReV next)
        : parent_(&parent), cur_(current), next_(next) {}

constexpr iterator_t<V> base() const { return cur_; }
    constexpr value_type operator*() const { return ::std::ranges::reconstruct(::std::in_place_type<V>, cur_, next_.begin()); }

constexpr iterator& operator++() {
      cur_ = next_.begin();
      if (cur_ != ranges::end(parent_->base_)) {
        cur_ = next_.end();
        if (cur_ == ranges::end(parent_->base_)) {
          trailing_empty_ = true;
          next_ = {cur_, cur_};
        } else {
          next_ = parent_->find_next(cur_);
        }
      } else {
        trailing_empty_ = false;
      }
      return *this;
    }
    constexpr iterator operator++(int) {
      auto tmp = *this;
      ++*this;
      return tmp;
    }

constexpr bool operator==(const iterator& rhs) const {
      return cur_ == rhs.cur_ && trailing_empty_ == rhs.trailing_empty_;
    }
  };

struct sentinel {
  private:
    sentinel_t<V> end_ = sentinel_t<V>();
    
  public:
    sentinel() = default;
    constexpr explicit sentinel(revzin_split_view& parent)
        : end_(ranges::end(parent.base_))
    { }
    
    constexpr bool operator==(const iterator& x) const {
        return x.cur_ == end_ && !x.trailing_empty_;
    }
  };

public:
  revzin_split_view() = default;
  constexpr revzin_split_view(V base, Pattern pattern)
      : base_(std::move(base)), pattern_(std::move(pattern)) {}

template <forward_range R>
  requires constructible_from<V, views::all_t<R>> &&
      constructible_from<Pattern, single_view<range_value_t<R>>>
  constexpr revzin_split_view(R&& r, range_value_t<R> e)
      : base_(views::all(std::forward<R>(r))),
        pattern_(views::single(std::move(e))) {}

constexpr V base() const& requires copyable<V> { return base_; }
  constexpr V base() && { return std::move(base_); }

constexpr iterator begin() {
    return {*this, ranges::begin(base_), find_next(ranges::begin(base_))};
  }

constexpr auto end() {
    if constexpr (common_range<V>) {
      return iterator{*this, ranges::end(base_), {}};
    } else {
      return sentinel{*this};
    }
  }

constexpr _ReV find_next(iterator_t<_ReV> it) {
    auto [b, e] = ranges::search(subrange(it, ranges::end(base_)), pattern_);
    if (b != ranges::end(base_) && ranges::empty(pattern_)) {
      ++b;
      ++e;
    }
    return ::std::ranges::reconstruct(::std::in_place_type<V>, b, e);
  }
};

template <class R, class P>
revzin_split_view(R&&, P&&) -> revzin_split_view<views::all_t<R>, views::all_t<P>>;

template <forward_range R>
revzin_split_view(R&&, range_value_t<R>)
    -> revzin_split_view<views::all_t<R>, single_view<range_value_t<R>>>;

namespace views {
inline constexpr __adaptor::_RangeAdaptor revzin_split =
    []<viewable_range _Range, typename _Fp>(_Range&& __r, _Fp&& __f) {
      return revzin_split_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
    };
}
}

struct zstring_sentinel {
    bool operator==(char const* p) const {
        return *p == '\0';
    }
};

struct zstring : std::ranges::view_interface<zstring> {
    char const* p = nullptr;
    constexpr zstring() = default;
    constexpr zstring(char const* p) : p(p) { }
    constexpr auto begin() const { return p; }
    constexpr auto end() const { return zstring_sentinel{}; }

friend inline constexpr zstring tag_invoke(std::tag_t<std::ranges::reconstruct>,
        const char* f,
        zstring_sentinel) {
        return {f};
    }

friend inline constexpr std::string_view tag_invoke(std::tag_t<std::ranges::reconstruct>,
        std::in_place_type_t<zstring>,
        const char* f,
        const char* l) {
        return std::string_view{f, static_cast<std::size_t>(l - f)};
    }
};

template <typename R>
concept forward_only_range =
    std::ranges::forward_range<R>
    && !std::ranges::bidirectional_range<R>;

int main() {
  namespace rg = std::ranges;
  static_assert(rg::view<zstring>);
  {
    // the new one is a forward range of contiguous ranges
    using V = rg::revzin_split_view<zstring, rg::single_view<char>>;
    static_assert(rg::view<V>);
    static_assert(forward_only_range<V>);
    static_assert(!rg::common_range<V>);
    static_assert(rg::contiguous_range<rg::range_reference_t<V>>);
    static_assert(std::is_same_v<rg::range_reference_t<V>, std::string_view>);

// the old one is a forward range of forward ranges
    using LV = rg::revzin_lazy_split_view<zstring, rg::single_view<char>>;
    static_assert(rg::view<LV>);
    static_assert(forward_only_range<LV>);
    static_assert(!rg::common_range<LV>);
    static_assert(forward_only_range<rg::range_reference_t<LV>>);
  }

{
    // preserve common
    using V = rg::revzin_split_view<std::string_view, std::string_view>;
    static_assert(forward_only_range<V>);
    static_assert(rg::common_range<V>);
    static_assert(rg::contiguous_range<rg::range_reference_t<V>>);
    static_assert(std::is_same_v<rg::range_reference_t<V>, std::string_view>);
  }

std::string_view test = "meow";
  auto re_test = std::ranges::reconstruct(std::in_place_type<std::string_view>, test);
  static_assert(std::is_same_v<decltype(test), decltype(re_test)>);

using namespace std::literals;
  fmt::print("revzin_split\n");
  fmt::print("{}\n", "a b c"sv | std::views::revzin_split(' '));
  fmt::print("{}\n", "a b c "sv | std::views::revzin_split(' '));
  fmt::print("{}\n", "abc"sv | std::views::revzin_split(""sv));
  fmt::print("{}\n", std::views::revzin_split("xxyx"sv, "xy"sv));
  fmt::print("{}\n", zstring{" x  "} | std::views::revzin_split(' '));

fmt::print("revzin_lazy_split\n");
  fmt::print("{}\n", "a b c"sv | std::views::revzin_lazy_split(' '));
  fmt::print("{}\n", "a b c "sv | std::views::revzin_lazy_split(' '));
  fmt::print("{}\n", "abc"sv | std::views::revzin_lazy_split(""sv));
  fmt::print("{}\n", std::views::revzin_lazy_split("xxyx"sv, "xy"sv));
  fmt::print("{}\n", zstring{" x  "} | std::views::revzin_lazy_split(' '));
}