[libcxx][views] Add drop_view.

The first view in the libc++ ranges library 🚀

Differential Revision: https://reviews.llvm.org/D102037

libcxx/include/CMakeLists.txt

@@ -141,6 +141,7 @@ set(files
   __ranges/all.h
   __ranges/concepts.h
   __ranges/data.h
+  __ranges/drop_view.h
   __ranges/empty.h
   __ranges/empty_view.h
   __ranges/enable_borrowed_range.h

libcxx/include/__ranges/drop_view.h

@@ -0,0 +1,154 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP___RANGES_DROP_VIEW_H
+#define _LIBCPP___RANGES_DROP_VIEW_H
+
+#include <__config>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/concepts.h>
+#include <__ranges/access.h>
+#include <__ranges/view_interface.h>
+#include <__ranges/all.h>
+#include <type_traits>
+#include <optional>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+namespace ranges {
+  template<view _View>
+  class drop_view
+    : public view_interface<drop_view<_View>> {
+
+    // We cache begin() whenever ranges::next is not guaranteed O(1) to provide an
+    // amortized O(1) begin() method. If this is an input_range, then we cannot cache
+    // begin because begin is not equality preserving.
+    // Note: drop_view<input-range>::begin() is still trivially amortized O(1) because
+    // one can't call begin() on it more than once.
+    static constexpr bool _UseCache = forward_range<_View> && !(random_access_range<_View> && sized_range<_View>);
+    using _Cache = optional<iterator_t<_View>>;
+    struct _Empty { };
+
+    // For forward ranges use std::optional to cache the begin iterator.
+    // No unique address + _Empty means we don't use any extra space when this
+    // is not a forward iterator.
+    [[no_unique_address]] conditional_t<_UseCache, _Cache, _Empty> __cached_begin_;
+    range_difference_t<_View> __count_ = 0;
+    _View __base_ = _View();
+
+public:
+    drop_view() requires default_initializable<_View> = default;
+
+    constexpr drop_view(_View __base, range_difference_t<_View> __count)
+      : __cached_begin_()
+      , __count_(__count)
+      , __base_(_VSTD::move(__base))
+    {
+      _LIBCPP_ASSERT(__count_ >= 0, "count must be greater than or equal to zero.");
+    }
+
+    constexpr drop_view(drop_view const& __other)
+      : __cached_begin_() // Intentionally not propagating the cached begin iterator.
+      , __count_(__other.__count_)
+      , __base_(__other.__base_)
+    { }
+
+    constexpr drop_view(drop_view&& __other)
+      : __cached_begin_() // Intentionally not propagating the cached begin iterator.
+      , __count_(_VSTD::move(__other.__count_))
+      , __base_(_VSTD::move(__other.__base_))
+    { }
+
+    constexpr drop_view& operator=(drop_view const& __other) {
+      if constexpr (_UseCache) {
+        __cached_begin_.reset();
+      }
+      __base_ = __other.__base_;
+      __count_ = __other.__count_;
+      return *this;
+    }
+
+    constexpr drop_view& operator=(drop_view&& __other) {
+      if constexpr (_UseCache) {
+        __cached_begin_.reset();
+        __other.__cached_begin_.reset();
+      }
+      __base_ = _VSTD::move(__other.__base_);
+      __count_ = _VSTD::move(__other.__count_);
+      return *this;
+    }
+
+    constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+    constexpr _View base() && { return _VSTD::move(__base_); }
+
+    constexpr auto begin()
+      requires (!(__simple_view<_View> &&
+                  random_access_range<const _View> && sized_range<const _View>))
+    {
+      if constexpr (_UseCache)
+        if (__cached_begin_)
+          return *__cached_begin_;
+
+      auto __tmp = ranges::next(ranges::begin(__base_), __count_, ranges::end(__base_));
+      if constexpr (_UseCache)
+        __cached_begin_ = __tmp;
+      return __tmp;
+    }
+
+    constexpr auto begin() const
+      requires random_access_range<const _View> && sized_range<const _View>
+    {
+      return ranges::next(ranges::begin(__base_), __count_, ranges::end(__base_));
+    }
+
+    constexpr auto end()
+      requires (!__simple_view<_View>)
+    { return ranges::end(__base_); }
+
+    constexpr auto end() const
+      requires range<const _View>
+    { return ranges::end(__base_); }
+
+    static constexpr auto __size(auto& __self) {
+      const auto __s = ranges::size(__self.__base_);
+      const auto __c = static_cast<decltype(__s)>(__self.__count_);
+      return __s < __c ? 0 : __s - __c;
+    }
+
+    constexpr auto size()
+      requires sized_range<_View>
+    { return __size(*this); }
+
+    constexpr auto size() const
+      requires sized_range<const _View>
+    { return __size(*this); }
+  };
+
+  template<class _Range>
+  drop_view(_Range&&, range_difference_t<_Range>)
+  // TODO: this is just recreating all_t.
+    -> drop_view<decltype(views::all(std::declval<_Range>()))>;
+
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_DROP_VIEW_H

libcxx/include/ranges

@@ -97,6 +97,7 @@ namespace std::ranges {
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
+#include <__ranges/drop_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>

libcxx/test/std/ranges/range.adaptors/range.drop/base.pass.cpp

@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr V base() const& requires copy_constructible<V> { return base_; }
+// constexpr V base() && { return std::move(base_); }
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+constexpr bool test() {
+  std::ranges::drop_view<ContiguousView> dropView1;
+  auto base1 = std::move(dropView1).base();
+  assert(std::ranges::begin(base1) == globalBuff);
+
+  // Note: we should *not* drop two elements here.
+  std::ranges::drop_view<ContiguousView> dropView2(ContiguousView{4}, 2);
+  auto base2 = std::move(dropView2).base();
+  assert(std::ranges::begin(base2) == globalBuff + 4);
+
+  std::ranges::drop_view<CopyableView> dropView3;
+  auto base3 = dropView3.base();
+  assert(std::ranges::begin(base3) == globalBuff);
+  auto base4 = std::move(dropView3).base();
+  assert(std::ranges::begin(base4) == globalBuff);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.drop/begin.pass.cpp

@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr auto begin()
+//   requires (!(simple-view<V> &&
+//               random_access_range<const V> && sized_range<const V>));
+// constexpr auto begin() const
+//   requires random_access_range<const V> && sized_range<const V>;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+template<class T>
+concept BeginInvocable = requires(std::ranges::drop_view<T> t) { t.begin(); };
+
+constexpr bool test() {
+  // random_access_range<const V> && sized_range<const V>
+  std::ranges::drop_view dropView1(ContiguousView(), 4);
+  assert(dropView1.begin() == globalBuff + 4);
+
+  // !random_access_range<const V>
+  std::ranges::drop_view dropView2(ForwardView(), 4);
+  assert(dropView2.begin().base() == globalBuff + 4);
+
+  // !random_access_range<const V>
+  std::ranges::drop_view dropView3(InputView(), 4);
+  assert(dropView3.begin().base() == globalBuff + 4);
+
+  // random_access_range<const V> && sized_range<const V>
+  std::ranges::drop_view dropView4(ContiguousView(), 8);
+  assert(dropView4.begin() == globalBuff + 8);
+
+  // random_access_range<const V> && sized_range<const V>
+  std::ranges::drop_view dropView5(ContiguousView(), 0);
+  assert(dropView5.begin() == globalBuff);
+
+  // random_access_range<const V> && sized_range<const V>
+  const std::ranges::drop_view dropView6(ContiguousView(), 0);
+  assert(dropView6.begin() == globalBuff);
+
+  // random_access_range<const V> && sized_range<const V>
+  std::ranges::drop_view dropView7(ContiguousView(), 10);
+  assert(dropView7.begin() == globalBuff + 8);
+
+  CountedView view8;
+  std::ranges::drop_view dropView8(view8, 5);
+  assert(dropView8.begin().base().base() == globalBuff + 5);
+  assert(dropView8.begin().stride_count() == 5);
+  assert(dropView8.begin().base().base() == globalBuff + 5);
+  assert(dropView8.begin().stride_count() == 5);
+
+  static_assert(!BeginInvocable<const ForwardView>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.drop/ctad.compile.pass.cpp

@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class R>
+// drop_view(R&&, range_difference_t<R>) -> drop_view<views::all_t<R>>;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+namespace ranges = std::ranges;
+
+static_assert(std::same_as<decltype(ranges::drop_view(ContiguousView(), 0)), ranges::drop_view<ContiguousView>>);
+static_assert(std::same_as<decltype(ranges::drop_view(CopyableView(), 0)), ranges::drop_view<CopyableView>>);
+static_assert(std::same_as<decltype(ranges::drop_view(ForwardView(), 0)), ranges::drop_view<ForwardView>>);
+static_assert(std::same_as<decltype(ranges::drop_view(InputView(), 0)), ranges::drop_view<InputView>>);
+
+static_assert(std::same_as<decltype(ranges::drop_view(std::declval<ForwardRange&>(), 0)),
+                           ranges::drop_view<ranges::ref_view<ForwardRange>>>);
+
+static_assert(std::same_as<decltype(ranges::drop_view(BorrowableRange(), 0)),
+                           ranges::drop_view<ranges::subrange<int*>>>);

libcxx/test/std/ranges/range.adaptors/range.drop/ctor.default.pass.cpp

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// drop_view() requires default_initializable<V> = default;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+constexpr bool test() {
+  std::ranges::drop_view<ContiguousView> dropView1;
+  assert(std::ranges::begin(dropView1) == globalBuff);
+
+  static_assert( std::is_default_constructible_v<std::ranges::drop_view<ForwardView>>);
+  static_assert(!std::is_default_constructible_v<std::ranges::drop_view<NoDefaultCtorForwardView>>);
+
+  static_assert( std::is_nothrow_default_constructible_v<std::ranges::drop_view<ForwardView>>);
+  static_assert(!std::is_nothrow_default_constructible_v<ThrowingDefaultCtorForwardView>);
+  static_assert(!std::is_nothrow_default_constructible_v<std::ranges::drop_view<ThrowingDefaultCtorForwardView>>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.drop/ctor.view.pass.cpp

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr drop_view(V base, range_difference_t<V> count);
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+constexpr bool test() {
+  std::ranges::drop_view dropView1(ContiguousView(), 4);
+  assert(dropView1.size() == 4);
+  assert(dropView1.begin() == globalBuff + 4);
+
+  std::ranges::drop_view dropView2(ForwardView(), 4);
+  assert(dropView2.begin().base() == globalBuff + 4);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.drop/dangling.cache.pass.cpp

@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// If we have a copy-propagating cache, when we copy ZeroOnDestroy, we will get a
+// dangling reference to the copied-from object. This test ensures that we do not
+// propagate the cache on copy.
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+struct ZeroOnDestroy : std::ranges::view_base {
+  unsigned count = 0;
+  int buff[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  constexpr ForwardIter begin() { return ForwardIter(buff); }
+  constexpr ForwardIter begin() const { return ForwardIter(); }
+  constexpr ForwardIter end() { return ForwardIter(buff + 8); }
+  constexpr ForwardIter end() const { return ForwardIter(); }
+
+  ~ZeroOnDestroy() {
+    memset(buff, 0, sizeof(buff));
+  }
+
+  static auto dropFirstFour() {
+    ZeroOnDestroy zod;
+    std::ranges::drop_view dv(zod, 4);
+    // Make sure we call begin here so the next call to begin will
+    // use the cached iterator.
+    assert(*dv.begin() == 5);
+    // Intentionally invoke the copy ctor here.
+    return std::ranges::drop_view(dv);
+  }
+};
+
+int main(int, char**) {
+  auto noDanlingCache = ZeroOnDestroy::dropFirstFour();
+  // If we use the cached version, it will reference the copied-from view.
+  // Worst case this is a segfault, best case it's an assertion fired.
+  assert(*noDanlingCache.begin() == 5);
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.drop/end.pass.cpp

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr auto end()
+//   requires (!simple-view<V>)
+// constexpr auto end() const
+//   requires range<const V>
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+constexpr bool test() {
+  // range<const V>
+  std::ranges::drop_view dropView1(ContiguousView(), 4);
+  assert(dropView1.end() == globalBuff + 8);
+
+  // !simple-view<V>
+  std::ranges::drop_view dropView2(InputView(), 4);
+  assert(dropView2.end() == globalBuff + 8);
+
+  // range<const V>
+  const std::ranges::drop_view dropView3(ContiguousView(), 0);
+  assert(dropView3.end() == globalBuff + 8);
+
+  // !simple-view<V>
+  const std::ranges::drop_view dropView4(InputView(), 2);
+  assert(dropView4.end() == globalBuff + 8);
+
+  // range<const V>
+  std::ranges::drop_view dropView5(ContiguousView(), 10);
+  assert(dropView5.end() == globalBuff + 8);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.drop/general.pass.cpp

@@ -0,0 +1,91 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// Some basic examples of how drop_view might be used in the wild. This is a general
+// collection of sample algorithms and functions that try to mock general usage of
+// this view.
+
+#include <ranges>
+
+#include <vector>
+#include <list>
+#include <string>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "types.h"
+
+template<class T>
+concept ValidDropView = requires { typename std::ranges::drop_view<T>; };
+
+static_assert(ValidDropView<ContiguousView>);
+static_assert(!ValidDropView<Range>);
+
+template<std::ranges::view View>
+bool orderedFibonacci(View v, int n = 1) {
+  if (v.size() < 3)
+    return true;
+
+  if (v[2] != v[0] + v[1])
+    return false;
+
+  return orderedFibonacci(std::ranges::drop_view(v.base(), n), n + 1);
+}
+
+template<std::ranges::view View>
+std::ranges::view auto makeEven(View v) {
+  return std::ranges::drop_view(v, v.size() % 2);
+}
+
+template<std::ranges::view View, class T>
+int indexOf(View v, T element) {
+  int index = 0;
+  for (auto e : v) {
+    if (e == element)
+      return index;
+    index++;
+  }
+  return -1;
+}
+
+template<std::ranges::view View, class T>
+std::ranges::view auto removeBefore(View v, T element) {
+  std::ranges::drop_view out(v, indexOf(v, element) + 1);
+  return View(out.begin(), out.end());
+}
+
+template<>
+constexpr bool std::ranges::enable_view<std::vector<int>> = true;
+
+template<>
+constexpr bool std::ranges::enable_view<std::list<int>> = true;
+
+template<>
+constexpr bool std::ranges::enable_view<std::string> = true;
+
+int main(int, char**) {
+  const std::vector vec = {1,1,2,3,5,8,13};
+  assert(orderedFibonacci(std::ranges::drop_view(vec, 0)));
+  const std::vector vec2 = {1,1,2,3,5,8,14};
+  assert(!orderedFibonacci(std::ranges::drop_view(vec2, 0)));
+
+  const std::list l = {1, 2, 3};
+  auto el = makeEven(l);
+  assert(el.size() == 2);
+  assert(*el.begin() == 2);
+
+  const std::string s = "Hello, World";
+  assert(removeBefore(s, ' ') == "World");
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.drop/size.pass.cpp

@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr auto size()
+//   requires sized_range<V>
+// constexpr auto size() const
+//   requires sized_range<const V>
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+template<class T>
+concept SizeInvocable = requires(std::ranges::drop_view<T> t) { t.size(); };
+
+constexpr bool test() {
+  // sized_range<V>
+  std::ranges::drop_view dropView1(ContiguousView(), 4);
+  assert(dropView1.size() == 4);
+
+  // sized_range<V>
+  std::ranges::drop_view dropView2(ContiguousView(), 0);
+  assert(dropView2.size() == 8);
+
+  // sized_range<const V>
+  const std::ranges::drop_view dropView3(ContiguousView(), 8);
+  assert(dropView3.size() == 0);
+
+  // sized_range<const V>
+  const std::ranges::drop_view dropView4(ContiguousView(), 10);
+  assert(dropView4.size() == 0);
+
+  // Because ForwardView is not a sized_range.
+  static_assert(!SizeInvocable<ForwardView>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.drop/types.h

@@ -0,0 +1,108 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_DROP_TYPES_H
+#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_DROP_TYPES_H
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+int globalBuff[8];
+
+struct ContiguousView : std::ranges::view_base {
+  int start_;
+  constexpr ContiguousView(int start = 0) : start_(start) {}
+  constexpr ContiguousView(ContiguousView&&) = default;
+  constexpr ContiguousView& operator=(ContiguousView&&) = default;
+  constexpr friend int* begin(ContiguousView& view) { return globalBuff + view.start_; }
+  constexpr friend int* begin(ContiguousView const& view) { return globalBuff + view.start_; }
+  constexpr friend int* end(ContiguousView&) { return globalBuff + 8; }
+  constexpr friend int* end(ContiguousView const&) { return globalBuff + 8; }
+};
+
+struct CopyableView : std::ranges::view_base {
+  int start_;
+  constexpr CopyableView(int start = 0) : start_(start) {}
+  constexpr CopyableView(CopyableView const&) = default;
+  constexpr CopyableView& operator=(CopyableView const&) = default;
+  constexpr friend int* begin(CopyableView& view) { return globalBuff + view.start_; }
+  constexpr friend int* begin(CopyableView const& view) { return globalBuff + view.start_; }
+  constexpr friend int* end(CopyableView&) { return globalBuff + 8; }
+  constexpr friend int* end(CopyableView const&) { return globalBuff + 8; }
+};
+
+using ForwardIter = forward_iterator<int*>;
+struct ForwardView : std::ranges::view_base {
+  constexpr ForwardView() = default;
+  constexpr ForwardView(ForwardView&&) = default;
+  constexpr ForwardView& operator=(ForwardView&&) = default;
+  constexpr friend ForwardIter begin(ForwardView&) { return ForwardIter(globalBuff); }
+  constexpr friend ForwardIter begin(ForwardView const&) { return ForwardIter(globalBuff); }
+  constexpr friend ForwardIter end(ForwardView&) { return ForwardIter(globalBuff + 8); }
+  constexpr friend ForwardIter end(ForwardView const&) { return ForwardIter(globalBuff + 8); }
+};
+
+struct ForwardRange {
+  ForwardIter begin() const;
+  ForwardIter end() const;
+  ForwardIter begin();
+  ForwardIter end();
+};
+
+struct ThrowingDefaultCtorForwardView : std::ranges::view_base {
+  ThrowingDefaultCtorForwardView() noexcept(false);
+  ForwardIter begin() const;
+  ForwardIter end() const;
+  ForwardIter begin();
+  ForwardIter end();
+};
+
+struct NoDefaultCtorForwardView : std::ranges::view_base {
+  NoDefaultCtorForwardView() = delete;
+  ForwardIter begin() const;
+  ForwardIter end() const;
+  ForwardIter begin();
+  ForwardIter end();
+};
+
+struct BorrowableRange {
+  friend int* begin(BorrowableRange const& range);
+  friend int* end(BorrowableRange const&);
+  friend int* begin(BorrowableRange& range);
+  friend int* end(BorrowableRange&);
+};
+
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<BorrowableRange> = true;
+
+struct InputView : std::ranges::view_base {
+  constexpr cpp20_input_iterator<int*> begin() const { return cpp20_input_iterator<int*>(globalBuff); }
+  constexpr int* end() const { return globalBuff + 8; }
+  constexpr cpp20_input_iterator<int*> begin() { return cpp20_input_iterator<int*>(globalBuff); }
+  constexpr int* end() { return globalBuff + 8; }
+};
+
+constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return lhs.base() == rhs; }
+constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return rhs.base() == lhs; }
+
+struct Range {
+  friend int* begin(Range const&);
+  friend int* end(Range const&);
+  friend int* begin(Range&);
+  friend int* end(Range&);
+};
+
+using CountedIter = stride_counting_iterator<forward_iterator<int*>>;
+struct CountedView : std::ranges::view_base {
+  constexpr CountedIter begin() { return CountedIter(ForwardIter(globalBuff)); }
+  constexpr CountedIter begin() const { return CountedIter(ForwardIter(globalBuff)); }
+  constexpr CountedIter end() { return CountedIter(ForwardIter(globalBuff + 8)); }
+  constexpr CountedIter end() const { return CountedIter(ForwardIter(globalBuff + 8)); }
+};
+
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_DROP_TYPES_H