This is an archive of the discontinued LLVM Phabricator instance.

Differential D125156

[libc++][ranges] Implement `views::drop`.
ClosedPublic

Authored by var-const on May 6 2022, 10:56 PM.

Details

Reviewers
ldionne
Group Reviewers
Restricted Project
Commits
rG8200e1253f6f: [libc++][ranges] Implement `views::drop`.
Summary

The view itself has been implemented previously -- this patch only adds
the ability to pipe it.

Also finishes the implementation of P1739 and
LWG3407.

Diff Detail

Event Timeline

var-const created this revision.May 6 2022, 10:56 PM
Herald added a project: Restricted Project. · View Herald TranscriptMay 6 2022, 10:56 PM
var-const requested review of this revision.May 6 2022, 10:56 PM
Herald added a project: Restricted Project. · View Herald TranscriptMay 6 2022, 10:56 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
var-const updated this revision to Diff 427817.May 6 2022, 10:58 PM

Tiny formatting fix.

var-const added inline comments.May 6 2022, 11:00 PM
libcxx/include/__ranges/drop_view.h
259

Not sure if this is worth making the actual implementation differ from the expressions in the return type and the noexcept clause. Calculating std::min twice seems wasteful (though I guess it should be easily optimized by the compiler?).

Harbormaster completed remote builds in B163282: Diff 427817.May 7 2022, 12:06 AM
ldionne accepted this revision.May 9 2022, 7:59 AM
ldionne added a subscriber: ldionne.

LGTM

libcxx/include/__ranges/drop_view.h
158–160

To avoid those getting out of sync, perhaps we should instead make _StoreSize public and access it directly from here as subrange::_StoreSize?

This revision is now accepted and ready to land.May 9 2022, 7:59 AM
ldionne mentioned this in D116950: [libc++] Add the std::ranges::drop range adaptor object.May 9 2022, 7:59 AM
ldionne added inline comments.May 9 2022, 8:02 AM
libcxx/include/__ranges/drop_view.h
259

I think it makes sense to have it differ from the expression in the noexcept. Also, we shouldn't be computing ranges::distance(__rng) more than once.

ldionne mentioned this in D115122: [libc++] [ranges] Implement views::take, views::drop, ranges::equal. [WIP, needs tests].May 9 2022, 8:02 AM
var-const updated this revision to Diff 428196.May 9 2022, 2:02 PM
var-const marked an inline comment as done.

Make subrange::_StoreSize public; rebase.

var-const marked an inline comment as done.May 9 2022, 2:03 PM
var-const added inline comments.
libcxx/include/__ranges/drop_view.h
158–160

Done, thanks. I was thinking the same thing but was concerned about making this implementation detail public; on the other hand, with the "mangled" internal name it should be clear it shouldn't be used.

Harbormaster completed remote builds in B163570: Diff 428196.May 9 2022, 6:10 PM
This revision was landed with ongoing or failed builds.May 10 2022, 9:31 AM
Closed by commit rG8200e1253f6f: [libc++][ranges] Implement `views::drop`. (authored by var-const, committed by varconst <varconsteq@gmail.com>). · Explain Why
This revision was automatically updated to reflect the committed changes.
varconst <varconsteq@gmail.com> added a commit: rG8200e1253f6f: [libc++][ranges] Implement `views::drop`..
var-const marked an inline comment as done.May 10 2022, 9:33 AM

Merging -- the AIX failure with atomics looks unrelated.

Revision Contents

PathSize
libcxx/
docs/
Status/
2 lines
2 lines
2 lines
include/
__ranges/
182 lines
5 lines
test/
std/
ranges/
range.adaptors/
range.drop/
range.take/
160 lines
range.take/
3 lines

Diff 428410

libcxx/docs/Status/Cxx20Papers.csv

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Lines
"`P1961R0 <https://wg21.link/P1961R0>`__","LWG","Harmonizing the definitions of total order for pointers","Belfast","* *","" "`P1961R0 <https://wg21.link/P1961R0>`__","LWG","Harmonizing the definitions of total order for pointers","Belfast","* *",""
"`P1965R0 <https://wg21.link/P1965R0>`__","LWG","Blanket Wording for Specifying ""Hidden Friends""","Belfast","* *","" "`P1965R0 <https://wg21.link/P1965R0>`__","LWG","Blanket Wording for Specifying ""Hidden Friends""","Belfast","* *",""
"","","","","","" "","","","","",""
"`P0586R2 <https://wg21.link/P0586R2>`__","LWG","Safe integral comparisons","Prague","|Complete|","13.0" "`P0586R2 <https://wg21.link/P0586R2>`__","LWG","Safe integral comparisons","Prague","|Complete|","13.0"
"`P0593R6 <https://wg21.link/P0593R6>`__","CWG","Implicit creation of objects for low-level object manipulation","Prague","* *","" "`P0593R6 <https://wg21.link/P0593R6>`__","CWG","Implicit creation of objects for low-level object manipulation","Prague","* *",""
"`P1115R3 <https://wg21.link/P1115R3>`__","LWG","Improving the Return Value of Erase-Like Algorithms II: Free erase/erase if","Prague","|Complete|","11.0" "`P1115R3 <https://wg21.link/P1115R3>`__","LWG","Improving the Return Value of Erase-Like Algorithms II: Free erase/erase if","Prague","|Complete|","11.0"
"`P1243R4 <https://wg21.link/P1243R4>`__","LWG","Rangify New Algorithms","Prague","* *","" "`P1243R4 <https://wg21.link/P1243R4>`__","LWG","Rangify New Algorithms","Prague","* *",""
"`P1460R1 <https://wg21.link/P1460R1>`__","LWG","Mandating the Standard Library: Clause 20 - Utilities library","Prague","* *","" "`P1460R1 <https://wg21.link/P1460R1>`__","LWG","Mandating the Standard Library: Clause 20 - Utilities library","Prague","* *",""
"`P1739R4 <https://wg21.link/P1739R4>`__","LWG","Avoid template bloat for safe_ranges in combination with ""subrange-y"" view adaptors","Prague","* *","" "`P1739R4 <https://wg21.link/P1739R4>`__","LWG","Avoid template bloat for safe_ranges in combination with ""subrange-y"" view adaptors","Prague","|Complete|","15.0"
"`P1831R1 <https://wg21.link/P1831R1>`__","LWG","Deprecating volatile: library","Prague","* *","" "`P1831R1 <https://wg21.link/P1831R1>`__","LWG","Deprecating volatile: library","Prague","* *",""
"`P1868R2 <https://wg21.link/P1868R2>`__","LWG","width: clarifying units of width and precision in std::format","Prague","|Complete|","14.0" "`P1868R2 <https://wg21.link/P1868R2>`__","LWG","width: clarifying units of width and precision in std::format","Prague","|Complete|","14.0"
"`P1908R1 <https://wg21.link/P1908R1>`__","CWG","Reserving Attribute Namespaces for Future Use","Prague","* *","" "`P1908R1 <https://wg21.link/P1908R1>`__","CWG","Reserving Attribute Namespaces for Future Use","Prague","* *",""
"`P1937R2 <https://wg21.link/P1937R2>`__","CWG","Fixing inconsistencies between constexpr and consteval functions","Prague","* *","" "`P1937R2 <https://wg21.link/P1937R2>`__","CWG","Fixing inconsistencies between constexpr and consteval functions","Prague","* *",""
"`P1956R1 <https://wg21.link/P1956R1>`__","LWG","On the names of low-level bit manipulation functions","Prague","|Complete|","12.0" "`P1956R1 <https://wg21.link/P1956R1>`__","LWG","On the names of low-level bit manipulation functions","Prague","|Complete|","12.0"
"`P1957R2 <https://wg21.link/P1957R2>`__","CWG","Converting from ``T*``\ to bool should be considered narrowing (re: US 212)","Prague","* *","" "`P1957R2 <https://wg21.link/P1957R2>`__","CWG","Converting from ``T*``\ to bool should be considered narrowing (re: US 212)","Prague","* *",""
"`P1963R0 <https://wg21.link/P1963R0>`__","LWG","Fixing US 313","Prague","* *","" "`P1963R0 <https://wg21.link/P1963R0>`__","LWG","Fixing US 313","Prague","* *",""
"`P1964R2 <https://wg21.link/P1964R2>`__","LWG","Wording for boolean-testable","Prague","|Complete|","13.0" "`P1964R2 <https://wg21.link/P1964R2>`__","LWG","Wording for boolean-testable","Prague","|Complete|","13.0"
Show All 28 Lines

libcxx/docs/Status/Cxx2bIssues.csv

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines
`2762 <https://wg21.link/LWG2762>`__,"``unique_ptr operator*()`` should be ``noexcept``","October 2021","","" `2762 <https://wg21.link/LWG2762>`__,"``unique_ptr operator*()`` should be ``noexcept``","October 2021","",""
`3121 <https://wg21.link/LWG3121>`__,"``tuple`` constructor constraints for ``UTypes&&...`` overloads","October 2021","","" `3121 <https://wg21.link/LWG3121>`__,"``tuple`` constructor constraints for ``UTypes&&...`` overloads","October 2021","",""
`3123 <https://wg21.link/LWG3123>`__,"``duration`` constructor from representation shouldn't be effectively non-throwing","October 2021","","","|chrono|" `3123 <https://wg21.link/LWG3123>`__,"``duration`` constructor from representation shouldn't be effectively non-throwing","October 2021","","","|chrono|"
`3146 <https://wg21.link/LWG3146>`__,"Excessive unwrapping in ``std::ref/cref``","October 2021","|Complete|","14.0" `3146 <https://wg21.link/LWG3146>`__,"Excessive unwrapping in ``std::ref/cref``","October 2021","|Complete|","14.0"
`3152 <https://wg21.link/LWG3152>`__,"``common_type`` and ``common_reference`` have flaws in common","October 2021","","" `3152 <https://wg21.link/LWG3152>`__,"``common_type`` and ``common_reference`` have flaws in common","October 2021","",""
`3293 <https://wg21.link/LWG3293>`__,"``move_iterator operator+()`` has incorrect constraints","October 2021","|Complete|","15.0","|ranges|" `3293 <https://wg21.link/LWG3293>`__,"``move_iterator operator+()`` has incorrect constraints","October 2021","|Complete|","15.0","|ranges|"
`3361 <https://wg21.link/LWG3361>`__,"``safe_range<SomeRange&>`` case","October 2021","|Nothing To Do|","","|ranges|" `3361 <https://wg21.link/LWG3361>`__,"``safe_range<SomeRange&>`` case","October 2021","|Nothing To Do|","","|ranges|"
`3392 <https://wg21.link/LWG3392>`__,"``ranges::distance()`` cannot be used on a move-only iterator with a sized sentinel","October 2021","|Complete|","14.0","|ranges|" `3392 <https://wg21.link/LWG3392>`__,"``ranges::distance()`` cannot be used on a move-only iterator with a sized sentinel","October 2021","|Complete|","14.0","|ranges|"
`3407 <https://wg21.link/LWG3407>`__,"Some problems with the wording changes of P1739R4","October 2021","","","|ranges|" `3407 <https://wg21.link/LWG3407>`__,"Some problems with the wording changes of P1739R4","October 2021","|Complete|","15.0","|ranges|"
`3422 <https://wg21.link/LWG3422>`__,"Issues of ``seed_seq``'s constructors","October 2021","|Complete|","14.0" `3422 <https://wg21.link/LWG3422>`__,"Issues of ``seed_seq``'s constructors","October 2021","|Complete|","14.0"
`3470 <https://wg21.link/LWG3470>`__,"``convertible-to-non-slicing`` seems to reject valid case","October 2021","|Complete|","14.0","|ranges|" `3470 <https://wg21.link/LWG3470>`__,"``convertible-to-non-slicing`` seems to reject valid case","October 2021","|Complete|","14.0","|ranges|"
`3480 <https://wg21.link/LWG3480>`__,"``directory_iterator`` and ``recursive_directory_iterator`` are not C++20 ranges","October 2021","|Complete|","14.0","|ranges|" `3480 <https://wg21.link/LWG3480>`__,"``directory_iterator`` and ``recursive_directory_iterator`` are not C++20 ranges","October 2021","|Complete|","14.0","|ranges|"
`3498 <https://wg21.link/LWG3498>`__,"Inconsistent ``noexcept``-specifiers for ``basic_syncbuf``","October 2021","","" `3498 <https://wg21.link/LWG3498>`__,"Inconsistent ``noexcept``-specifiers for ``basic_syncbuf``","October 2021","",""
`3535 <https://wg21.link/LWG3535>`__,"``join_view::iterator::iterator_category`` and ``::iterator_concept`` lie","October 2021","|Complete|","15.0","|ranges|" `3535 <https://wg21.link/LWG3535>`__,"``join_view::iterator::iterator_category`` and ``::iterator_concept`` lie","October 2021","|Complete|","15.0","|ranges|"
`3554 <https://wg21.link/LWG3554>`__,"``chrono::parse`` needs ``const charT*`` and ``basic_string_view<charT>`` overloads","October 2021","","","|chrono|" `3554 <https://wg21.link/LWG3554>`__,"``chrono::parse`` needs ``const charT*`` and ``basic_string_view<charT>`` overloads","October 2021","","","|chrono|"
`3557 <https://wg21.link/LWG3557>`__,"The ``static_cast`` expression in ``convertible_to`` has the wrong operand","October 2021","|Complete|","14.0" `3557 <https://wg21.link/LWG3557>`__,"The ``static_cast`` expression in ``convertible_to`` has the wrong operand","October 2021","|Complete|","14.0"
`3559 <https://wg21.link/LWG3559>`__,"Semantic requirements of ``sized_range`` is circular","October 2021","|Nothing To Do|","","|ranges|" `3559 <https://wg21.link/LWG3559>`__,"Semantic requirements of ``sized_range`` is circular","October 2021","|Nothing To Do|","","|ranges|"
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/docs/Status/RangesIssues.csv

"Number","Name","Status","First released version" "Number","Name","Status","First released version"
`P0896R4 <https://wg21.link/P0896R4>`__,<ranges>,, `P0896R4 <https://wg21.link/P0896R4>`__,<ranges>,,
`P1035R7 <https://wg21.link/P1035R7>`__,Input Range Adaptors,, `P1035R7 <https://wg21.link/P1035R7>`__,Input Range Adaptors,,
`P1207R4 <https://wg21.link/P1207R4>`__,Movability Of Single-Pass Iterators,, `P1207R4 <https://wg21.link/P1207R4>`__,Movability Of Single-Pass Iterators,,
`P1243R4 <https://wg21.link/P1243R4>`__,Rangify New Algorithms,, `P1243R4 <https://wg21.link/P1243R4>`__,Rangify New Algorithms,,
`P1248R1 <https://wg21.link/P1248R1>`__,Fixing Relations,|Complete|,13.0 `P1248R1 <https://wg21.link/P1248R1>`__,Fixing Relations,|Complete|,13.0
`P1252R2 <https://wg21.link/P1252R2>`__,Ranges Design Cleanup,, `P1252R2 <https://wg21.link/P1252R2>`__,Ranges Design Cleanup,,
`P1391R4 <https://wg21.link/P1391R4>`__,Range Constructor For string_view,|Complete|,14.0 `P1391R4 <https://wg21.link/P1391R4>`__,Range Constructor For string_view,|Complete|,14.0
`P1456R1 <https://wg21.link/P1456R1>`__,Move-Only Views,, `P1456R1 <https://wg21.link/P1456R1>`__,Move-Only Views,,
`P1474R1 <https://wg21.link/P1474R1>`__,Helpful Pointers For contiguous_iterator,, `P1474R1 <https://wg21.link/P1474R1>`__,Helpful Pointers For contiguous_iterator,,
`P1522R1 <https://wg21.link/P1522R1>`__,Iterator Difference Type And Integer Overflow,, `P1522R1 <https://wg21.link/P1522R1>`__,Iterator Difference Type And Integer Overflow,,
`P1523R1 <https://wg21.link/P1523R1>`__,Views And Size Types,, `P1523R1 <https://wg21.link/P1523R1>`__,Views And Size Types,,
`P1638R1 <https://wg21.link/P1638R1>`__,basic_istream_view::iterator Should Not Be Copyable,, `P1638R1 <https://wg21.link/P1638R1>`__,basic_istream_view::iterator Should Not Be Copyable,,
`P1716R3 <https://wg21.link/P1716R3>`__,Range Comparison Algorithms Are Over-Constrained,, `P1716R3 <https://wg21.link/P1716R3>`__,Range Comparison Algorithms Are Over-Constrained,,
`P1739R4 <https://wg21.link/P1739R4>`__,Avoiding Template Bloat For Ranges,, `P1739R4 <https://wg21.link/P1739R4>`__,Avoiding Template Bloat For Ranges,|Complete|,15.0
`P1862R1 <https://wg21.link/P1862R1>`__,Range Adaptors For Non-Copyable Iterators,, `P1862R1 <https://wg21.link/P1862R1>`__,Range Adaptors For Non-Copyable Iterators,,
`P1870R1 <https://wg21.link/P1870R1>`__,safe_range,, `P1870R1 <https://wg21.link/P1870R1>`__,safe_range,,
`P1871R1 <https://wg21.link/P1871R1>`__,disable_sized_sentinel_for,|Complete|,14.0 `P1871R1 <https://wg21.link/P1871R1>`__,disable_sized_sentinel_for,|Complete|,14.0
`P1878R1 <https://wg21.link/P1878R1>`__,Constraining Readable Types,, `P1878R1 <https://wg21.link/P1878R1>`__,Constraining Readable Types,,
`P1970R2 <https://wg21.link/P1970R2>`__,ranges::ssize,, `P1970R2 <https://wg21.link/P1970R2>`__,ranges::ssize,,
`P1983R0 <https://wg21.link/P1983R0>`__,Fixing Minor Ranges Issues,, `P1983R0 <https://wg21.link/P1983R0>`__,Fixing Minor Ranges Issues,,
`P1994R1 <https://wg21.link/P1994R1>`__,elements_view Needs Its Own sentinel,, `P1994R1 <https://wg21.link/P1994R1>`__,elements_view Needs Its Own sentinel,,
`P2091R0 <https://wg21.link/P2091R0>`__,Fixing Issues With Range Access CPOs,, `P2091R0 <https://wg21.link/P2091R0>`__,Fixing Issues With Range Access CPOs,,
Show All 10 Lines

libcxx/include/__ranges/drop_view.h

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANGES_DROP_VIEW_H #ifndef _LIBCPP___RANGES_DROP_VIEW_H
#define _LIBCPP___RANGES_DROP_VIEW_H #define _LIBCPP___RANGES_DROP_VIEW_H
#include <__algorithm/min.h>
#include <__assert> #include <__assert>
#include <__config> #include <__config>
#include <__functional/bind_back.h>
#include <__fwd/span.h>
#include <__fwd/string_view.h>
#include <__iterator/concepts.h> #include <__iterator/concepts.h>
#include <__iterator/distance.h>
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <__iterator/next.h> #include <__iterator/next.h>
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/all.h> #include <__ranges/all.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/empty_view.h>
#include <__ranges/enable_borrowed_range.h> #include <__ranges/enable_borrowed_range.h>
#include <__ranges/iota_view.h>
#include <__ranges/non_propagating_cache.h> #include <__ranges/non_propagating_cache.h>
#include <__ranges/range_adaptor.h>
#include <__ranges/size.h> #include <__ranges/size.h>
#include <__ranges/subrange.h>
#include <__ranges/view_interface.h> #include <__ranges/view_interface.h>
#include <__utility/auto_cast.h>
#include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <concepts> #include <concepts>
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Linespublic:
{ return __size(*this); } { return __size(*this); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr auto size() const constexpr auto size() const
requires sized_range<const _View> requires sized_range<const _View>
{ return __size(*this); } { return __size(*this); }
}; };
template<class _Range> template<class _Range>
drop_view(_Range&&, range_difference_t<_Range>) -> drop_view<views::all_t<_Range>>; drop_view(_Range&&, range_difference_t<_Range>) -> drop_view<views::all_t<_Range>>;
template<class _Tp> template<class _Tp>
inline constexpr bool enable_borrowed_range<drop_view<_Tp>> = enable_borrowed_range<_Tp>; inline constexpr bool enable_borrowed_range<drop_view<_Tp>> = enable_borrowed_range<_Tp>;
namespace views {
namespace __drop {
template <class _Tp>
inline constexpr bool __is_empty_view = false;
template <class _Tp>
inline constexpr bool __is_empty_view<empty_view<_Tp>> = true;
template <class _Tp>
inline constexpr bool __is_passthrough_specialization = false;
template <class _Tp, size_t _Extent>
inline constexpr bool __is_passthrough_specialization<span<_Tp, _Extent>> = true;
template <class _CharT, class _Traits>
inline constexpr bool __is_passthrough_specialization<basic_string_view<_CharT, _Traits>> = true;
template <class _Np, class _Bound>
inline constexpr bool __is_passthrough_specialization<iota_view<_Np, _Bound>> = true;
template <class _Iter, class _Sent, subrange_kind _Kind>
inline constexpr bool __is_passthrough_specialization<subrange<_Iter, _Sent, _Kind>> =
!subrange<_Iter, _Sent, _Kind>::_StoreSize;
template <class _Tp>
inline constexpr bool __is_subrange_specialization_with_store_size = false;
ldionneUnsubmitted
Done
ReplyInline Actions

To avoid those getting out of sync, perhaps we should instead make _StoreSize public and access it directly from here as subrange::_StoreSize?

ldionne: To avoid those getting out of sync, perhaps we should instead make `_StoreSize` public and…
var-constAuthorUnsubmitted
Done
ReplyInline Actions

Done, thanks. I was thinking the same thing but was concerned about making this implementation detail public; on the other hand, with the "mangled" internal name it should be clear it shouldn't be used.

var-const: Done, thanks. I was thinking the same thing but was concerned about making this implementation…
template <class _Iter, class _Sent, subrange_kind _Kind>
inline constexpr bool __is_subrange_specialization_with_store_size<subrange<_Iter, _Sent, _Kind>> =
subrange<_Iter, _Sent, _Kind>::_StoreSize;
template <class _Tp>
struct __passthrough_type;
template <class _Tp, size_t _Extent>
struct __passthrough_type<span<_Tp, _Extent>> {
using type = span<_Tp>;
};
template <class _CharT, class _Traits>
struct __passthrough_type<basic_string_view<_CharT, _Traits>> {
using type = basic_string_view<_CharT, _Traits>;
};
template <class _Np, class _Bound>
struct __passthrough_type<iota_view<_Np, _Bound>> {
using type = iota_view<_Np, _Bound>;
};
template <class _Iter, class _Sent, subrange_kind _Kind>
struct __passthrough_type<subrange<_Iter, _Sent, _Kind>> {
using type = subrange<_Iter, _Sent, _Kind>;
};
template <class _Tp>
using __passthrough_type_t = typename __passthrough_type<_Tp>::type;
struct __fn {
// [range.drop.overview]: the `empty_view` case.
template <class _Range, convertible_to<range_difference_t<_Range>> _Np>
requires __is_empty_view<remove_cvref_t<_Range>>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
constexpr auto operator()(_Range&& __range, _Np&&) const
noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))))
-> decltype( _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)))
{ return _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)); }
// [range.drop.overview]: the `span | basic_string_view | iota_view | subrange (StoreSize == false)` case.
template <class _Range,
convertible_to<range_difference_t<_Range>> _Np,
class _RawRange = remove_cvref_t<_Range>,
class _Dist = range_difference_t<_Range>>
requires (!__is_empty_view<_RawRange> &&
random_access_range<_RawRange> &&
sized_range<_RawRange> &&
__is_passthrough_specialization<_RawRange>)
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
constexpr auto operator()(_Range&& __rng, _Np&& __n) const
noexcept(noexcept(__passthrough_type_t<_RawRange>(
ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
ranges::end(__rng)
)))
-> decltype( __passthrough_type_t<_RawRange>(
// Note: deliberately not forwarding `__rng` to guard against double moves.
ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
ranges::end(__rng)
))
{ return __passthrough_type_t<_RawRange>(
ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
ranges::end(__rng)
); }
// [range.drop.overview]: the `subrange (StoreSize == true)` case.
template <class _Range,
convertible_to<range_difference_t<_Range>> _Np,
class _RawRange = remove_cvref_t<_Range>,
class _Dist = range_difference_t<_Range>>
requires (!__is_empty_view<_RawRange> &&
random_access_range<_RawRange> &&
sized_range<_RawRange> &&
__is_subrange_specialization_with_store_size<_RawRange>)
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
constexpr auto operator()(_Range&& __rng, _Np&& __n) const
noexcept(noexcept(_RawRange(
ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
ranges::end(__rng),
std::__to_unsigned_like(ranges::distance(__rng) -
std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))
)))
-> decltype( _RawRange(
// Note: deliberately not forwarding `__rng` to guard against double moves.
ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
ranges::end(__rng),
std::__to_unsigned_like(ranges::distance(__rng) -
std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))
))
{
// Introducing local variables avoids calculating `min` and `distance` twice (at the cost of diverging from the
// expression used in the `noexcept` clause and the return statement).
auto dist = ranges::distance(__rng);
auto clamped = std::min<_Dist>(dist, std::forward<_Np>(__n));
return _RawRange(
ranges::begin(__rng) + clamped,
ranges::end(__rng),
std::__to_unsigned_like(dist - clamped)
);}
var-constAuthorUnsubmitted
Done
ReplyInline Actions

Not sure if this is worth making the actual implementation differ from the expressions in the return type and the noexcept clause. Calculating std::min twice seems wasteful (though I guess it should be easily optimized by the compiler?).

var-const: Not sure if this is worth making the actual implementation differ from the expressions in the…
ldionneUnsubmitted
Done
ReplyInline Actions

I think it makes sense to have it differ from the expression in the noexcept. Also, we shouldn't be computing ranges::distance(__rng) more than once.

ldionne: I think it makes sense to have it differ from the expression in the `noexcept`. Also, we…
// [range.drop.overview]: the "otherwise" case.
template <class _Range, convertible_to<range_difference_t<_Range>> _Np,
class _RawRange = remove_cvref_t<_Range>>
// Note: without specifically excluding the other cases, GCC sees this overload as ambiguous with the other
// overloads.
requires (!(__is_empty_view<_RawRange> ||
(__is_subrange_specialization_with_store_size<_RawRange> &&
sized_range<_RawRange> &&
random_access_range<_RawRange>) ||
(__is_passthrough_specialization<_RawRange> &&
sized_range<_RawRange> &&
random_access_range<_RawRange>)
))
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
constexpr auto operator()(_Range&& __range, _Np&& __n) const
noexcept(noexcept(drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n))))
-> decltype( drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n)))
{ return drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n)); }
template <class _Np>
requires constructible_from<decay_t<_Np>, _Np>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
constexpr auto operator()(_Np&& __n) const
noexcept(is_nothrow_constructible_v<decay_t<_Np>, _Np>)
{ return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Np>(__n))); }
};
} // namespace __drop
inline namespace __cpo {
inline constexpr auto drop = __drop::__fn{};
} // namespace __cpo
} // namespace views
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES) #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_DROP_VIEW_H #endif // _LIBCPP___RANGES_DROP_VIEW_H

libcxx/include/__ranges/subrange.h

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Linesnamespace ranges {
template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent = _Iter, template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent = _Iter,
subrange_kind _Kind = sized_sentinel_for<_Sent, _Iter> subrange_kind _Kind = sized_sentinel_for<_Sent, _Iter>
? subrange_kind::sized ? subrange_kind::sized
: subrange_kind::unsized> : subrange_kind::unsized>
requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>) requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
class _LIBCPP_TEMPLATE_VIS subrange class _LIBCPP_TEMPLATE_VIS subrange
: public view_interface<subrange<_Iter, _Sent, _Kind>> : public view_interface<subrange<_Iter, _Sent, _Kind>>
{ {
private: public:
// Note: this is an internal implementation detail that is public only for internal usage.
static constexpr bool _StoreSize = (_Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _Iter>); static constexpr bool _StoreSize = (_Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _Iter>);
private:
static constexpr bool _MustProvideSizeAtConstruction = !_StoreSize; // just to improve compiler diagnostics static constexpr bool _MustProvideSizeAtConstruction = !_StoreSize; // just to improve compiler diagnostics
struct _Empty { constexpr _Empty(auto) noexcept { } }; struct _Empty { constexpr _Empty(auto) noexcept { } };
using _Size = conditional_t<_StoreSize, make_unsigned_t<iter_difference_t<_Iter>>, _Empty>; using _Size = conditional_t<_StoreSize, make_unsigned_t<iter_difference_t<_Iter>>, _Empty>;
_LIBCPP_NO_UNIQUE_ADDRESS _Iter __begin_ = _Iter(); _LIBCPP_NO_UNIQUE_ADDRESS _Iter __begin_ = _Iter();
_LIBCPP_NO_UNIQUE_ADDRESS _Sent __end_ = _Sent(); _LIBCPP_NO_UNIQUE_ADDRESS _Sent __end_ = _Sent();
_LIBCPP_NO_UNIQUE_ADDRESS _Size __size_ = 0; _LIBCPP_NO_UNIQUE_ADDRESS _Size __size_ = 0;
public: public:
▲ Show 20 Lines • Show All 200 Lines • Show Last 20 Lines

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

  • This file was copied from libcxx/test/std/ranges/range.adaptors/range.take/adaptor.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-incomplete-ranges // UNSUPPORTED: libcpp-has-no-incomplete-ranges
// std::views::take // std::views::drop
#include <ranges> #include <ranges>
#include <array> #include <array>
#include <cassert> #include <cassert>
#include <concepts> #include <concepts>
#include <span>
#include <string_view> #include <string_view>
#include <utility> #include <utility>
#include "test_iterators.h" #include "test_iterators.h"
#include "types.h"
template <class View, class T> template <class View, class T>
concept CanBePiped = requires (View&& view, T&& t) { concept CanBePiped = requires (View&& view, T&& t) {
{ std::forward<View>(view) | std::forward<T>(t) }; { std::forward<View>(view) | std::forward<T>(t) };
}; };
struct SizedView : std::ranges::view_base { struct SizedView : std::ranges::view_base {
int* begin_ = nullptr; int* begin_ = nullptr;
int* end_ = nullptr; int* end_ = nullptr;
constexpr SizedView(int* begin, int* end) : begin_(begin), end_(end) {} constexpr SizedView(int* begin, int* end) : begin_(begin), end_(end) {}
constexpr auto begin() const { return forward_iterator<int*>(begin_); } constexpr auto begin() const { return forward_iterator<int*>(begin_); }
constexpr auto end() const { return sized_sentinel<forward_iterator<int*>>(forward_iterator<int*>(end_)); } constexpr auto end() const { return sized_sentinel<forward_iterator<int*>>(forward_iterator<int*>(end_)); }
}; };
static_assert(std::ranges::forward_range<SizedView>); static_assert(std::ranges::forward_range<SizedView>);
static_assert(std::ranges::sized_range<SizedView>); static_assert(std::ranges::sized_range<SizedView>);
static_assert(std::ranges::view<SizedView>); static_assert(std::ranges::view<SizedView>);
struct SizedViewWithUnsizedSentinel : std::ranges::view_base {
using iterator = random_access_iterator<int*>;
using sentinel = sentinel_wrapper<random_access_iterator<int*>>;
int* begin_ = nullptr;
int* end_ = nullptr;
constexpr SizedViewWithUnsizedSentinel(int* begin, int* end) : begin_(begin), end_(end) {}
constexpr auto begin() const { return iterator(begin_); }
constexpr auto end() const { return sentinel(iterator(end_)); }
constexpr size_t size() const { return end_ - begin_; }
};
static_assert(std::ranges::random_access_range<SizedViewWithUnsizedSentinel>);
static_assert(std::ranges::sized_range<SizedViewWithUnsizedSentinel>);
static_assert(!std::sized_sentinel_for<SizedViewWithUnsizedSentinel::sentinel, SizedViewWithUnsizedSentinel::iterator>);
static_assert(std::ranges::view<SizedViewWithUnsizedSentinel>);
template <class T> template <class T>
constexpr void test_small_range(const T& input) { constexpr void test_small_range(const T& input) {
constexpr int N = 100; constexpr int N = 100;
auto size = std::ranges::size(input); auto size = std::ranges::size(input);
auto result = input | std::views::take(N);
assert(size < N); assert(size < N);
assert(result.size() == size);
auto result = input | std::views::drop(N);
assert(result.empty());
} }
constexpr bool test() { constexpr bool test() {
constexpr int N = 8; constexpr int N = 8;
int buf[N] = {1, 2, 3, 4, 5, 6, 7, 8}; int buf[N] = {1, 2, 3, 4, 5, 6, 7, 8};
// Test that `std::views::take` is a range adaptor. // Test that `std::views::drop` is a range adaptor.
{ {
using SomeView = SizedView; using SomeView = SizedView;
// Test `view | views::take` // Test `view | views::drop`
{ {
SomeView view(buf, buf + N); SomeView view(buf, buf + N);
std::same_as<std::ranges::take_view<SomeView>> decltype(auto) result = view | std::views::take(3); std::same_as<std::ranges::drop_view<SomeView>> decltype(auto) result = view | std::views::drop(3);
assert(result.base().begin_ == buf); assert(result.base().begin_ == buf);
assert(result.base().end_ == buf + N); assert(result.base().end_ == buf + N);
assert(result.size() == 3); assert(base(result.begin()) == buf + 3);
assert(base(base(result.end())) == buf + N);
assert(result.size() == 5);
} }
// Test `adaptor | views::take` // Test `adaptor | views::drop`
{ {
SomeView view(buf, buf + N); SomeView view(buf, buf + N);
auto f = [](int i) { return i; }; auto f = [](int i) { return i; };
auto const partial = std::views::transform(f) | std::views::take(3); auto const partial = std::views::transform(f) | std::views::drop(3);
using Result = std::ranges::take_view<std::ranges::transform_view<SomeView, decltype(f)>>; using Result = std::ranges::drop_view<std::ranges::transform_view<SomeView, decltype(f)>>;
std::same_as<Result> decltype(auto) result = partial(view); std::same_as<Result> decltype(auto) result = partial(view);
assert(result.base().base().begin_ == buf); assert(result.base().base().begin_ == buf);
assert(result.base().base().end_ == buf + N); assert(result.base().base().end_ == buf + N);
assert(result.size() == 3); assert(base(result.begin().base()) == buf + 3);
assert(base(base(result.end().base())) == buf + N);
assert(result.size() == 5);
} }
// Test `views::take | adaptor` // Test `views::drop | adaptor`
{ {
SomeView view(buf, buf + N); SomeView view(buf, buf + N);
auto f = [](int i) { return i; }; auto f = [](int i) { return i; };
auto const partial = std::views::take(3) | std::views::transform(f); auto const partial = std::views::drop(3) | std::views::transform(f);
using Result = std::ranges::transform_view<std::ranges::take_view<SomeView>, decltype(f)>; using Result = std::ranges::transform_view<std::ranges::drop_view<SomeView>, decltype(f)>;
std::same_as<Result> decltype(auto) result = partial(view); std::same_as<Result> decltype(auto) result = partial(view);
assert(result.base().base().begin_ == buf); assert(result.base().base().begin_ == buf);
assert(result.base().base().end_ == buf + N); assert(result.base().base().end_ == buf + N);
assert(result.size() == 3); assert(base(result.begin().base()) == buf + 3);
assert(base(base(result.end().base())) == buf + N);
assert(result.size() == 5);
} }
// Check SFINAE friendliness // Check SFINAE friendliness
{ {
struct NotAView { }; struct NotAView { };
static_assert(!std::is_invocable_v<decltype(std::views::take)>); static_assert(!std::is_invocable_v<decltype(std::views::drop)>);
static_assert(!std::is_invocable_v<decltype(std::views::take), NotAView, int>); static_assert(!std::is_invocable_v<decltype(std::views::drop), NotAView, int>);
static_assert( CanBePiped<SomeView&, decltype(std::views::take(3))>); static_assert( CanBePiped<SomeView&, decltype(std::views::drop(3))>);
static_assert( CanBePiped<int(&)[10], decltype(std::views::take(3))>); static_assert( CanBePiped<int(&)[10], decltype(std::views::drop(3))>);
static_assert(!CanBePiped<int(&&)[10], decltype(std::views::take(3))>); static_assert(!CanBePiped<int(&&)[10], decltype(std::views::drop(3))>);
static_assert(!CanBePiped<NotAView, decltype(std::views::take(3))>); static_assert(!CanBePiped<NotAView, decltype(std::views::drop(3))>);
static_assert(!CanBePiped<SomeView&, decltype(std::views::take(/*n=*/NotAView{}))>); static_assert(!CanBePiped<SomeView&, decltype(std::views::drop(/*n=*/NotAView{}))>);
} }
} }
{ {
static_assert(std::same_as<decltype(std::views::take), decltype(std::ranges::views::take)>); static_assert(std::same_as<decltype(std::views::drop), decltype(std::ranges::views::drop)>);
} }
// `views::take(empty_view, n)` returns an `empty_view`. // `views::drop(empty_view, n)` returns an `empty_view`.
{ {
using Result = std::ranges::empty_view<int>; using Result = std::ranges::empty_view<int>;
[[maybe_unused]] std::same_as<Result> decltype(auto) result = std::views::empty<int> | std::views::take(3); [[maybe_unused]] std::same_as<Result> decltype(auto) result = std::views::empty<int> | std::views::drop(3);
} }
// `views::take(span, n)` returns a `span`. // `views::drop(span, n)` returns a `span`.
{ {
std::span<int> s(buf); std::span<int> s(buf);
std::same_as<decltype(s)> decltype(auto) result = s | std::views::take(3); std::same_as<decltype(s)> decltype(auto) result = s | std::views::drop(5);
assert(result.size() == 3); assert(result.size() == 3);
} }
// `views::take(span, n)` returns a `span` with a dynamic extent, regardless of the input `span`. // `views::drop(span, n)` returns a `span` with a dynamic extent, regardless of the input `span`.
{ {
std::span<int, 8> s(buf); std::span<int, 8> s(buf);
std::same_as<std::span<int, std::dynamic_extent>> decltype(auto) result = s | std::views::take(3); std::same_as<std::span<int, std::dynamic_extent>> decltype(auto) result = s | std::views::drop(3);
assert(result.size() == 3); assert(result.size() == 5);
} }
// `views::take(string_view, n)` returns a `string_view`. // `views::drop(string_view, n)` returns a `string_view`.
{ {
{ {
std::string_view sv = "abcdef"; std::string_view sv = "abcdef";
std::same_as<decltype(sv)> decltype(auto) result = sv | std::views::take(3); std::same_as<decltype(sv)> decltype(auto) result = sv | std::views::drop(2);
assert(result.size() == 3); assert(result.size() == 4);
} }
{ {
std::u32string_view sv = U"abcdef"; std::u32string_view sv = U"abcdef";
std::same_as<decltype(sv)> decltype(auto) result = sv | std::views::take(3); std::same_as<decltype(sv)> decltype(auto) result = sv | std::views::drop(2);
assert(result.size() == 3); assert(result.size() == 4);
} }
} }
// `views::take(subrange, n)` returns a `subrange`. // `views::drop(iota_view, n)` returns an `iota_view`.
{ {
auto subrange = std::ranges::subrange(buf, buf + N); auto iota = std::views::iota(1, 8);
using Result = std::ranges::subrange<int*>; // The second template argument of the resulting `iota_view` is different because it has to be able to hold
std::same_as<Result> decltype(auto) result = subrange | std::views::take(3); // the `range_difference_t` of the input `iota_view`.
assert(result.size() == 3); using Result = std::ranges::iota_view<int, int>;
std::same_as<Result> decltype(auto) result = iota | std::views::drop(3);
assert(result.size() == 4);
assert(*result.begin() == 4);
assert(*std::ranges::next(result.begin(), 3) == 7);
} }
// `views::take(subrange, n)` doesn't return a `subrange` if it's not a random access range. // `views::drop(subrange, n)` returns a `subrange` when `subrange::StoreSize == false`.
{ {
SizedView v(buf, buf + N); auto subrange = std::ranges::subrange(buf, buf + N);
auto subrange = std::ranges::subrange(v.begin(), v.end()); LIBCPP_STATIC_ASSERT(!decltype(subrange)::_StoreSize);
using Result = std::ranges::take_view<std::ranges::subrange<forward_iterator<int*>, using Result = std::ranges::subrange<int*>;
sized_sentinel<forward_iterator<int*>>>>; std::same_as<Result> decltype(auto) result = subrange | std::views::drop(3);
std::same_as<Result> decltype(auto) result = subrange | std::views::take(3); assert(result.size() == 5);
assert(result.size() == 3);
} }
// `views::take(subrange, n)` returns a `subrange` with all default template arguments. // `views::drop(subrange, n)` returns a `subrange` when `subrange::StoreSize == true`.
{ {
std::ranges::subrange<int*, sized_sentinel<int*>, std::ranges::subrange_kind::sized> subrange; using View = SizedViewWithUnsizedSentinel;
View view(buf, buf + N);
using Subrange = std::ranges::subrange<View::iterator, View::sentinel, std::ranges::subrange_kind::sized>;
auto subrange = Subrange(view.begin(), view.end(), std::ranges::distance(view.begin(), view.end()));
LIBCPP_STATIC_ASSERT(decltype(subrange)::_StoreSize);
using Result = std::ranges::subrange<int*, int*, std::ranges::subrange_kind::sized>; std::same_as<Subrange> decltype(auto) result = subrange | std::views::drop(3);
[[maybe_unused]] std::same_as<Result> decltype(auto) result = subrange | std::views::take(3); assert(result.size() == 5);
} }
// `views::take(iota_view, n)` returns an `iota_view`. // `views::drop(subrange, n)` doesn't return a `subrange` if it's not a random access range.
{ {
auto iota = std::views::iota(1, 8); SizedView v(buf, buf + N);
// The second template argument of the resulting `iota_view` is different because it has to be able to hold auto subrange = std::ranges::subrange(v.begin(), v.end());
// the `range_difference_t` of the input `iota_view`.
using Result = std::ranges::iota_view<int, std::ranges::range_difference_t<decltype(iota)>>; using Result = std::ranges::drop_view<std::ranges::subrange<forward_iterator<int*>,
std::same_as<Result> decltype(auto) result = iota | std::views::take(3); sized_sentinel<forward_iterator<int*>>>>;
assert(result.size() == 3); std::same_as<Result> decltype(auto) result = subrange | std::views::drop(3);
assert(result.size() == 5);
} }
// When the size of the input range `s` is shorter than `n`, only `s` elements are taken. // When the size of the input range `s` is shorter than `n`, an `empty_view` is returned.
{ {
test_small_range(std::span(buf)); test_small_range(std::span(buf));
test_small_range(std::string_view("abcdef")); test_small_range(std::string_view("abcdef"));
test_small_range(std::ranges::subrange(buf, buf + N)); test_small_range(std::ranges::subrange(buf, buf + N));
test_small_range(std::views::iota(1, 8)); test_small_range(std::views::iota(1, 8));
} }
// Test that it's possible to call `std::views::take` with any single argument as long as the resulting closure is // Test that it's possible to call `std::views::drop` with any single argument as long as the resulting closure is
// never invoked. There is no good use case for it, but it's valid. // never invoked. There is no good use case for it, but it's valid.
{ {
struct X { }; struct X { };
[[maybe_unused]] auto partial = std::views::take(X{}); [[maybe_unused]] auto partial = std::views::drop(X{});
} }
return true; return true;
} }
int main(int, char**) { int main(int, char**) {
test(); test();
static_assert(test()); static_assert(test());
return 0; return 0;
} }

libcxx/test/std/ranges/range.adaptors/range.take/adaptor.pass.cpp

  • This file was copied to libcxx/test/std/ranges/range.adaptors/range.drop/adaptor.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-has-no-incomplete-ranges // UNSUPPORTED: libcpp-has-no-incomplete-ranges
// std::views::take // std::views::take
#include <ranges> #include <ranges>
#include <array>
#include <cassert> #include <cassert>
#include <concepts> #include <concepts>
#include <span>
#include <string_view> #include <string_view>
#include <utility> #include <utility>
#include "test_iterators.h" #include "test_iterators.h"
#include "types.h"
template <class View, class T> template <class View, class T>
concept CanBePiped = requires (View&& view, T&& t) { concept CanBePiped = requires (View&& view, T&& t) {
{ std::forward<View>(view) | std::forward<T>(t) }; { std::forward<View>(view) | std::forward<T>(t) };
}; };
struct SizedView : std::ranges::view_base { struct SizedView : std::ranges::view_base {
int* begin_ = nullptr; int* begin_ = nullptr;
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines