[libcxx-commits] [libcxx] 7af89a3 - [libc++] Implement ranges::fill{, _n}
Nikolas Klauser via libcxx-commits
libcxx-commits at lists.llvm.org
Wed May 25 01:28:01 PDT 2022
Author: Nikolas Klauser
Date: 2022-05-25T10:27:13+02:00
New Revision: 7af89a379cce98382418be5b5433be6163e037f4
URL: https://github.com/llvm/llvm-project/commit/7af89a379cce98382418be5b5433be6163e037f4
DIFF: https://github.com/llvm/llvm-project/commit/7af89a379cce98382418be5b5433be6163e037f4.diff
LOG: [libc++] Implement ranges::fill{, _n}
Reviewed By: var-const, #libc
Spies: libcxx-commits, mgorny
Differential Revision: https://reviews.llvm.org/D123462
Added:
libcxx/include/__algorithm/ranges_fill.h
libcxx/include/__algorithm/ranges_fill_n.h
libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill.pass.cpp
libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill_n.pass.cpp
Modified:
libcxx/docs/Status/RangesAlgorithms.csv
libcxx/include/CMakeLists.txt
libcxx/include/algorithm
libcxx/include/module.modulemap
libcxx/test/libcxx/private_headers.verify.cpp
libcxx/test/support/almost_satisfies_types.h
Removed:
################################################################################
diff --git a/libcxx/docs/Status/RangesAlgorithms.csv b/libcxx/docs/Status/RangesAlgorithms.csv
index 4395c91aa24b7..1a5989db42bf2 100644
--- a/libcxx/docs/Status/RangesAlgorithms.csv
+++ b/libcxx/docs/Status/RangesAlgorithms.csv
@@ -42,8 +42,8 @@ Write,copy_n,Nikolas Klauser,`D122982 <https://llvm.org/D122982>`_,✅
Write,copy_backward,Nikolas Klauser,`D122982 <https://llvm.org/D122982>`_,✅
Write,move,Not assigned,n/a,Not started
Write,move_backward,Not assigned,n/a,Not started
-Write,fill,Not assigned,n/a,Not started
-Write,fill_n,Not assigned,n/a,Not started
+Write,fill,Nikolas Klauser,`D123462 <https://reviews.llvm.org/D123462>`_,✅
+Write,fill_n,Nikolas Klauser,`D123462 <https://reviews.llvm.org/D123462>`_,✅
Write,transform,Nikolas Klauser,`D122173 <https://llvm.org/D122173>`_,✅
Write,generate,Not assigned,n/a,Not started
Write,generate_n,Not assigned,n/a,Not started
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index b6e4f6d6cf526..68482bf716f1f 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -72,6 +72,8 @@ set(files
__algorithm/ranges_copy_n.h
__algorithm/ranges_count.h
__algorithm/ranges_count_if.h
+ __algorithm/ranges_fill.h
+ __algorithm/ranges_fill_n.h
__algorithm/ranges_find.h
__algorithm/ranges_find_if.h
__algorithm/ranges_find_if_not.h
diff --git a/libcxx/include/__algorithm/ranges_fill.h b/libcxx/include/__algorithm/ranges_fill.h
new file mode 100644
index 0000000000000..846e31885141b
--- /dev/null
+++ b/libcxx/include/__algorithm/ranges_fill.h
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___ALGORITHM_RANGES_FILL_H
+#define _LIBCPP___ALGORITHM_RANGES_FILL_H
+
+#include <__algorithm/ranges_fill_n.h>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+namespace __fill {
+struct __fn {
+ template <class _Type, output_iterator<const _Type&> _Iter, sentinel_for<_Iter> _Sent>
+ _LIBCPP_HIDE_FROM_ABI constexpr
+ _Iter operator()(_Iter __first, _Sent __last, const _Type& __value) const {
+ if constexpr(random_access_iterator<_Iter>) {
+ return ranges::fill_n(__first, __last - __first, __value);
+ } else {
+ for (; __first != __last; ++__first)
+ *__first = __value;
+ return __first;
+ }
+ }
+
+ template <class _Type, output_range<const _Type&> _Range>
+ _LIBCPP_HIDE_FROM_ABI constexpr
+ borrowed_iterator_t<_Range> operator()(_Range&& __range, const _Type& __value) const {
+ return (*this)(ranges::begin(__range), ranges::end(__range), __value);
+ }
+};
+} // namespace __fill
+
+inline namespace __cpo {
+ inline constexpr auto fill = __fill::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP___ALGORITHM_RANGES_FILL_H
diff --git a/libcxx/include/__algorithm/ranges_fill_n.h b/libcxx/include/__algorithm/ranges_fill_n.h
new file mode 100644
index 0000000000000..d93c573406ec3
--- /dev/null
+++ b/libcxx/include/__algorithm/ranges_fill_n.h
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___ALGORITHM_RANGES_FILL_N_H
+#define _LIBCPP___ALGORITHM_RANGES_FILL_N_H
+
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/incrementable_traits.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+namespace __fill_n {
+struct __fn {
+ template <class _Type, output_iterator<const _Type&> _Iter>
+ _LIBCPP_HIDE_FROM_ABI constexpr
+ _Iter operator()(_Iter __first, iter_
diff erence_t<_Iter> __n, const _Type& __value) const {
+ for (; __n != 0; --__n) {
+ *__first = __value;
+ ++__first;
+ }
+ return __first;
+ }
+};
+} // namespace __fill_n
+
+inline namespace __cpo {
+ inline constexpr auto fill_n = __fill_n::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP___ALGORITHM_RANGES_FILL_N_H
diff --git a/libcxx/include/algorithm b/libcxx/include/algorithm
index 224c9e1ab8465..ba8ac23e4bddc 100644
--- a/libcxx/include/algorithm
+++ b/libcxx/include/algorithm
@@ -283,6 +283,14 @@ namespace ranges {
requires permutable<iterator_t<R>>
constexpr borrowed_iterator_t<R> ranges::reverse(R&& r); // since C++20
+ template<class T, output_iterator<const T&> O, sentinel_for<O> S>
+ constexpr O ranges::fill(O first, S last, const T& value); // since C++20
+
+ template<class T, output_range<const T&> R>
+ constexpr borrowed_iterator_t<R> ranges::fill(R&& r, const T& value); // since C++20
+
+ template<class T, output_iterator<const T&> O>
+ constexpr O ranges::fill_n(O first, iter_
diff erence_t<O> n, const T& value); // since C++20
}
constexpr bool // constexpr in C++20
@@ -1005,6 +1013,8 @@ template <class BidirectionalIterator, class Compare>
#include <__algorithm/ranges_copy_n.h>
#include <__algorithm/ranges_count.h>
#include <__algorithm/ranges_count_if.h>
+#include <__algorithm/ranges_fill.h>
+#include <__algorithm/ranges_fill_n.h>
#include <__algorithm/ranges_find.h>
#include <__algorithm/ranges_find_if.h>
#include <__algorithm/ranges_find_if_not.h>
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index 6a771ea69fe90..d3a4b45c4d96d 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -304,6 +304,8 @@ module std [system] {
module ranges_copy_n { private header "__algorithm/ranges_copy_n.h" }
module ranges_count { private header "__algorithm/ranges_count.h" }
module ranges_count_if { private header "__algorithm/ranges_count_if.h" }
+ module ranges_fill { private header "__algorithm/ranges_fill.h" }
+ module ranges_fill_n { private header "__algorithm/ranges_fill_n.h" }
module ranges_find { private header "__algorithm/ranges_find.h" }
module ranges_find_if { private header "__algorithm/ranges_find_if.h" }
module ranges_find_if_not { private header "__algorithm/ranges_find_if_not.h" }
diff --git a/libcxx/test/libcxx/private_headers.verify.cpp b/libcxx/test/libcxx/private_headers.verify.cpp
index fe0f19baf6af9..16186899f3810 100644
--- a/libcxx/test/libcxx/private_headers.verify.cpp
+++ b/libcxx/test/libcxx/private_headers.verify.cpp
@@ -109,6 +109,8 @@ END-SCRIPT
#include <__algorithm/ranges_copy_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_n.h'}}
#include <__algorithm/ranges_count.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_count.h'}}
#include <__algorithm/ranges_count_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_count_if.h'}}
+#include <__algorithm/ranges_fill.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_fill.h'}}
+#include <__algorithm/ranges_fill_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_fill_n.h'}}
#include <__algorithm/ranges_find.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find.h'}}
#include <__algorithm/ranges_find_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_if.h'}}
#include <__algorithm/ranges_find_if_not.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_if_not.h'}}
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill.pass.cpp
new file mode 100644
index 0000000000000..b82d753e7ef60
--- /dev/null
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill.pass.cpp
@@ -0,0 +1,143 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<class T, output_iterator<const T&> O, sentinel_for<O> S>
+// constexpr O ranges::fill(O first, S last, const T& value);
+// template<class T, output_range<const T&> R>
+// constexpr borrowed_iterator_t<R> ranges::fill(R&& r, const T& value);
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+#include <string>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+template <class Iter, class Sent = sentinel_wrapper<Iter>>
+concept HasFillIt = requires(Iter iter, Sent sent) { std::ranges::fill(iter, sent, int{}); };
+
+static_assert(HasFillIt<int*>);
+static_assert(!HasFillIt<OutputIteratorNotIndirectlyWritable>);
+static_assert(!HasFillIt<OutputIteratorNotInputOrOutputIterator>);
+static_assert(!HasFillIt<int*, SentinelForNotSemiregular>);
+static_assert(!HasFillIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+template <class Range>
+concept HasFillR = requires(Range range) { std::ranges::fill(range, int{}); };
+
+static_assert(HasFillR<UncheckedRange<int*>>);
+static_assert(!HasFillR<OutputRangeNotIndirectlyWritable>);
+static_assert(!HasFillR<OutputRangeNotInputOrOutputIterator>);
+static_assert(!HasFillR<OutputRangeNotSentinelSemiregular>);
+static_assert(!HasFillR<OutputRangeNotSentinelEqualityComparableWith>);
+
+template <class It, class Sent = It>
+constexpr void test_iterators() {
+ { // simple test
+ {
+ int a[3];
+ std::same_as<It> auto ret = std::ranges::fill(It(a), Sent(It(a + 3)), 1);
+ assert(std::all_of(a, a + 3, [](int i) { return i == 1; }));
+ assert(base(ret) == a + 3);
+ }
+ {
+ int a[3];
+ auto range = std::ranges::subrange(It(a), Sent(It(a + 3)));
+ std::same_as<It> auto ret = std::ranges::fill(range, 1);
+ assert(std::all_of(a, a + 3, [](int i) { return i == 1; }));
+ assert(base(ret) == a + 3);
+ }
+ }
+
+ { // check that an empty range works
+ {
+ std::array<int, 0> a;
+ auto ret = std::ranges::fill(It(a.data()), Sent(It(a.data())), 1);
+ assert(base(ret) == a.data());
+ }
+ {
+ std::array<int, 0> a;
+ auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data())));
+ auto ret = std::ranges::fill(range, 1);
+ assert(base(ret) == a.data());
+ }
+ }
+}
+
+constexpr bool test() {
+ test_iterators<cpp17_output_iterator<int*>, sentinel_wrapper<cpp17_output_iterator<int*>>>();
+ test_iterators<cpp20_output_iterator<int*>, sentinel_wrapper<cpp20_output_iterator<int*>>>();
+ test_iterators<forward_iterator<int*>>();
+ test_iterators<bidirectional_iterator<int*>>();
+ test_iterators<random_access_iterator<int*>>();
+ test_iterators<contiguous_iterator<int*>>();
+ test_iterators<int*>();
+
+ { // check that every element is copied once
+ struct S {
+ bool copied = false;
+ constexpr S& operator=(const S&) {
+ copied = true;
+ return *this;
+ }
+ };
+ {
+ S a[5];
+ std::ranges::fill(a, a + 5, S {true});
+ assert(std::all_of(a, a + 5, [](S& s) { return s.copied; }));
+ }
+ {
+ S a[5];
+ std::ranges::fill(a, S {true});
+ assert(std::all_of(a, a + 5, [](S& s) { return s.copied; }));
+ }
+ }
+
+ { // check that std::ranges::dangling is returned
+ [[maybe_unused]] std::same_as<std::ranges::dangling> decltype(auto) ret =
+ std::ranges::fill(std::array<int, 10> {}, 1);
+ }
+
+ { // check that std::ranges::dangling isn't returned with a borrowing range
+ std::array<int, 10> a{};
+ [[maybe_unused]] std::same_as<std::array<int, 10>::iterator> decltype(auto) ret =
+ std::ranges::fill(std::views::all(a), 1);
+ assert(std::all_of(a.begin(), a.end(), [](int i) { return i == 1; }));
+ }
+
+ { // check that non-trivially copyable items are copied properly
+ {
+ std::array<std::string, 10> a;
+ auto ret = std::ranges::fill(a.begin(), a.end(), "long long string so no SSO");
+ assert(ret == a.data() + a.size());
+ assert(std::all_of(a.begin(), a.end(), [](auto& s) { return s == "long long string so no SSO"; }));
+ }
+ {
+ std::array<std::string, 10> a;
+ auto ret = std::ranges::fill(a, "long long string so no SSO");
+ assert(ret == a.data() + a.size());
+ assert(std::all_of(a.begin(), a.end(), [](auto& s) { return s == "long long string so no SSO"; }));
+ }
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill_n.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill_n.pass.cpp
new file mode 100644
index 0000000000000..1e984a8367c24
--- /dev/null
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill_n.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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<class T, output_iterator<const T&> O>
+// constexpr O ranges::fill_n(O first, iter_
diff erence_t<O> n, const T& value);
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+#include <string>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+template <class Iter>
+concept HasFillN = requires(Iter iter) { std::ranges::fill_n(iter, int{}, int{}); };
+
+struct WrongType {};
+
+static_assert(HasFillN<int*>);
+static_assert(!HasFillN<WrongType*>);
+static_assert(!HasFillN<OutputIteratorNotIndirectlyWritable>);
+static_assert(!HasFillN<OutputIteratorNotInputOrOutputIterator>);
+
+template <class It, class Sent = It>
+constexpr void test_iterators() {
+ { // simple test
+ int a[3];
+ std::same_as<It> decltype(auto) ret = std::ranges::fill_n(It(a), 3, 1);
+ assert(std::all_of(a, a + 3, [](int i) { return i == 1; }));
+ assert(base(ret) == a + 3);
+ }
+
+ { // check that an empty range works
+ std::array<int, 0> a;
+ auto ret = std::ranges::fill_n(It(a.data()), 0, 1);
+ assert(base(ret) == a.data());
+ }
+}
+
+constexpr bool test() {
+ test_iterators<cpp17_output_iterator<int*>, sentinel_wrapper<cpp17_output_iterator<int*>>>();
+ test_iterators<cpp20_output_iterator<int*>, sentinel_wrapper<cpp20_output_iterator<int*>>>();
+ test_iterators<forward_iterator<int*>>();
+ test_iterators<bidirectional_iterator<int*>>();
+ test_iterators<random_access_iterator<int*>>();
+ test_iterators<contiguous_iterator<int*>>();
+ test_iterators<int*>();
+
+ { // check that every element is copied once
+ struct S {
+ bool copied = false;
+ constexpr S& operator=(const S&) {
+ assert(!copied);
+ copied = true;
+ return *this;
+ }
+ };
+
+ S a[5];
+ std::ranges::fill_n(a, 5, S {});
+ assert(std::all_of(a, a + 5, [](S& s) { return s.copied; }));
+ }
+
+ { // check that non-trivially copyable items are copied properly
+ std::array<std::string, 10> a;
+ auto ret = std::ranges::fill_n(a.data(), 10, "long long string so no SSO");
+ assert(ret == a.data() + a.size());
+ assert(std::all_of(a.begin(), a.end(), [](auto& s) { return s == "long long string so no SSO"; }));
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/support/almost_satisfies_types.h b/libcxx/test/support/almost_satisfies_types.h
index 49984a42c88e4..99ea852d2ff9a 100644
--- a/libcxx/test/support/almost_satisfies_types.h
+++ b/libcxx/test/support/almost_satisfies_types.h
@@ -107,6 +107,7 @@ class SentinelForNotSemiregular {
};
using InputRangeNotSentinelSemiregular = UncheckedRange<cpp20_input_iterator<int*>, SentinelForNotSemiregular>;
+using OutputRangeNotSentinelSemiregular = UncheckedRange<cpp20_output_iterator<int*>, SentinelForNotSemiregular>;
static_assert(std::input_or_output_iterator<SentinelForNotSemiregular>);
static_assert(!std::semiregular<SentinelForNotSemiregular>);
@@ -123,6 +124,8 @@ class SentinelForNotWeaklyEqualityComparableWith {
using InputRangeNotSentinelEqualityComparableWith =
UncheckedRange<cpp20_input_iterator<int*>, SentinelForNotWeaklyEqualityComparableWith>;
+using OutputRangeNotSentinelEqualityComparableWith =
+ UncheckedRange<cpp20_output_iterator<int*>, SentinelForNotWeaklyEqualityComparableWith>;
static_assert(std::input_or_output_iterator<SentinelForNotWeaklyEqualityComparableWith>);
static_assert(std::semiregular<SentinelForNotWeaklyEqualityComparableWith>);
@@ -220,4 +223,39 @@ static_assert(std::forward_iterator<PermutableNotSwappable>);
static_assert(!std::permutable<PermutableNotSwappable>);
static_assert(!std::indirectly_swappable<PermutableNotSwappable>);
+class OutputIteratorNotInputOrOutputIterator {
+public:
+ using
diff erence_type = long;
+ using value_type = int;
+ using iterator_category = std::input_iterator_tag;
+
+ int& operator++();
+ void operator++(int);
+ int& operator*();
+};
+
+using OutputRangeNotInputOrOutputIterator = UncheckedRange<InputIteratorNotInputOrOutputIterator>;
+
+static_assert(!std::input_or_output_iterator<OutputIteratorNotInputOrOutputIterator>);
+static_assert(std::indirectly_writable<OutputIteratorNotInputOrOutputIterator, int>);
+static_assert(!std::output_iterator<OutputIteratorNotInputOrOutputIterator, int>);
+static_assert(!std::ranges::input_range<OutputRangeNotInputOrOutputIterator>);
+
+class OutputIteratorNotIndirectlyWritable {
+public:
+ using
diff erence_type = long;
+ using iterator_category = std::input_iterator_tag;
+
+ OutputIteratorNotIndirectlyWritable& operator++();
+ void operator++(int);
+ const int& operator*() const;
+};
+
+using OutputRangeNotIndirectlyWritable = UncheckedRange<OutputIteratorNotIndirectlyWritable>;
+
+static_assert(std::input_or_output_iterator<OutputIteratorNotIndirectlyWritable>);
+static_assert(!std::indirectly_writable<OutputIteratorNotIndirectlyWritable, int>);
+static_assert(!std::output_iterator<OutputIteratorNotIndirectlyWritable, int>);
+static_assert(!std::ranges::output_range<OutputIteratorNotIndirectlyWritable, int>);
+
#endif // ALMOST_SATISFIES_TYPES_H
More information about the libcxx-commits
mailing list