Difference between revisions of "cpp/experimental/ranges"

Latest revision as of 10:56, 28 November 2023

The C++ Extensions for Ranges, ISO/IEC TS 21425:2017, specifies one modification to the core language and defines new components for the C++ standard library listed on this page.

The Ranges TS is based on the C++14 standard as modified by the Concepts TS.

Merged into ISO C++ The functionality described on this page was merged into the mainline ISO C++ standard as of 10/2018; see the ranges library, the constrained algorithms library, and the core concepts library (since C++20)

Core language concepts
Defined in header `<experimental/ranges/concepts>`
Defined in namespace `std::experimental::ranges`
Same	specifies that a type is the same as another type (concept) [edit]
DerivedFrom	specifies that a type is derived from another type (concept) [edit]
ConvertibleTo	specifies that a type is implicitly convertible to another type (concept) [edit]
CommonReference	specifies that two types share a common reference type (concept) [edit]
Common	specifies that two types share a common type (concept) [edit]
Integral	specifies that a type is an integral type (concept) [edit]
SignedIntegral	specifies that a type is an integral type that is signed (concept) [edit]
UnsignedIntegral	specifies that a type is an integral type that is not signed (concept) [edit]
Assignable	specifies that a type is assignable from another type (concept) [edit]
SwappableSwappableWith	specifies that a type can be swapped or that two types can be swapped with each other (concept) [edit]
Comparison concepts
Defined in header `<experimental/ranges/concepts>`
Defined in namespace `std::experimental::ranges`
Boolean	specifies that a type can be used in Boolean contexts (concept) [edit]
WeaklyEqualityComparableWith	specifies that two types can be compared for equality using operators == and != (concept) [edit]
EqualityComparableEqualityComparableWith	specifies that operator == is an equivalence relation (concept) [edit]
StrictTotallyOrderedStrictTotallyOrderedWith	specifies that the comparison operators on the type yield a total order (concept) [edit]
Object concepts
Defined in header `<experimental/ranges/concepts>`
Defined in namespace `std::experimental::ranges`
Destructible	specifies that an object of the type can be destroyed (concept) [edit]
Constructible	specifies that a variable of the type can be constructed from or bound to a set of argument types (concept) [edit]
DefaultConstructible	specifies that an object of a type can be default constructed (concept) [edit]
MoveConstructible	specifies that an object of a type can be move constructed (concept) [edit]
CopyConstructible	specifies that an object of a type can be copy constructed and move constructed (concept) [edit]
Movable	specifies that an object of a type can be moved and swapped (concept) [edit]
Copyable	specifies that an object of a type can be copied, moved, and swapped (concept) [edit]
Semiregular	specifies that an object of a type can be copied, moved, swapped, and default constructed (concept) [edit]
Regular	specifies that a type is regular, that is, it is both `Semiregular` and `EqualityComparable` (concept) [edit]
Callable concepts
Defined in header `<experimental/ranges/concepts>`
Defined in namespace `std::experimental::ranges`
InvocableRegularInvocable	specifies that a callable type can be invoked with a given set of argument types (concept) [edit]
Predicate	specifies that a callable type is a Boolean predicate (concept) [edit]
Relation	specifies that a callable type is a binary relation (concept) [edit]
StrictWeakOrder	specifies that a `Relation` imposes a strict weak ordering (concept) [edit]
Random number generator concept
Defined in header `<experimental/ranges/random>`
Defined in namespace `std::experimental::ranges`
UniformRandomNumberGenerator	specifies that a type qualifies as a uniform random number generator (concept) [edit]

[edit] General utilities

Utility components
Defined in header `<experimental/ranges/utility>`
Defined in namespace `std::experimental::ranges`
swap	swaps the value of two objects (customization point object)[edit]
exchange	replaces the argument with a new value and returns its previous value (function template) [edit]
Function objects
Defined in header `<experimental/ranges/functional>`
Defined in namespace `std::experimental::ranges`
invoke	invokes a Callable object with the given arguments (function template) [edit]
equal_to	function object implementing x == y (class template) [edit]
not_equal_to	function object implementing x != y (class template) [edit]
greater	function object implementing x > y (class template) [edit]
less	function object implementing x < y (class template) [edit]
greater_equal	function object implementing x >= y (class template) [edit]
less_equal	function object implementing x <= y (class template) [edit]
identity	function object that returns its argument unchanged (class) [edit]
Metaprogramming and type traits
Defined in header `<experimental/ranges/type_traits>`
Defined in namespace `std::experimental::ranges`
is_swappable_withis_swappableis_nothrow_swappable_withis_nothrow_swappable	checks if objects of a type can be swapped with objects of same or different type (class template) [edit]
common_reference	determine the common reference type of a set of types (class template) [edit]
common_type	determine the common type of a set of types (class template) [edit]
Tagged pairs and tuples
Defined in header `<experimental/ranges/utility>`
Defined in namespace `std::experimental::ranges`
TagSpecifier	specifies that a type is a tag specifier (concept) [edit]
TaggedType	specifies that a type represents a tag specifier and its element type (concept) [edit]
tagged	augument a tuple-like type with named accessors (class template) [edit]
tagged_pair	alias template for a tagged std::pair (alias template)[edit]
make_tagged_pair	convenience function for creating a `tagged_pair` (function template) [edit]
Defined in header `<experimental/ranges/tuple>`
tagged_tuple	alias template for a tagged std::tuple (alias template)[edit]
make_tagged_tuple	convenience function for creating a `tagged_tuple` (function template) [edit]
Defined in header `<experimental/ranges/algorithm>`
Defined in namespace `std::experimental::ranges::tag`
inin1in2outout1out2funminmaxbeginend	tag specifiers for use with ranges::tagged (class) [edit]

[edit] Iterators

Defined in header `<experimental/ranges/iterator>`
Iterator-related concepts
Defined in namespace `std::experimental::ranges`
Iterator concepts
Readable	specifies that a type is readable by applying operator `*` (concept) [edit]
Writable	specifies that a value can be written to an iterator's referenced object (concept) [edit]
WeaklyIncrementable	specifies that a `Semiregular` type can be incremented with pre- and post-increment operators (concept) [edit]
Incrementable	specifies that the increment operation on a `WeaklyIncrementable` type is equality-preserving and that the type is `EqualityComparable` (concept) [edit]
Iterator	specifies that objects of a type can be incremented and dereferenced (concept) [edit]
Sentinel	specifies that objects of a type is a sentinel for an `Iterator` type (concept) [edit]
SizedSentinel	specifies that the `-` operator can be applied to an iterator and a sentinel to calculate their difference in constant time (concept) [edit]
InputIterator	specifies that a type is an input iterator, that is, its referenced values can be read and it can be both pre- and post-incremented (concept) [edit]
OutputIterator	specifies that a type is an output iterator for a given value type, that is, values of that type can be written to it and it can be both pre- and post-incremented (concept) [edit]
ForwardIterator	specifies that an `InputIterator` is a forward iterator, supporting equality comparison and multi-pass (concept) [edit]
BidirectionalIterator	specifies that a `ForwardIterator` is a bidirectional iterator, supporting movement backwards (concept) [edit]
RandomAccessIterator	specifies that a `BidirectionalIterator` is a random-access iterator, supporting advancement in constant time and subscripting (concept) [edit]
Indirect callable concepts
IndirectUnaryInvocableIndirectRegularUnaryInvocable	specifies that a callable type can be invoked with the result of dereferencing a `Readable` type (concept) [edit]
IndirectUnaryPredicate	specifies that a callable object, when invoked with the result of dereferencing a `Readable` type, satisfies `Predicate` (concept) [edit]
IndirectRelation	specifies that a callable object, when invoked with the result of dereferencing some `Readable` types, satisfies `Relation` (concept) [edit]
IndirectStrictWeakOrder	specifies that a callable object, when invoked with the result of dereferencing some `Readable` types, satisfies `StrictWeakOrder` (concept) [edit]
Common algorithm requirements
IndirectlyMovable	specifies that values may be moved from a `Readable` type to a `Writable` type (concept) [edit]
IndirectlyMovableStorable	specifies that values may be moved from a `Readable` type to a `Writable` type and that the move may be performed via an intermediate object (concept) [edit]
IndirectlyCopyable	specifies that values may be copied from a `Readable` type to a `Writable` type (concept) [edit]
IndirectlyCopyableStorable	specifies that values may be copied from a `Readable` type to a `Writable` type and that the copy may be performed via an intermediate object (concept) [edit]
IndirectlySwappable	specifies that the values referenced by two `Readable` types can be swapped (concept) [edit]
IndirectlyComparable	specifies that the values referenced by two `Readable` types can be compared (concept) [edit]
Permutable	specifies the common requirements of algorithms that reorder elements in place (concept) [edit]
Mergeable	specifies the requirements of algorithms that merge sorted sequences into an output sequence by copying elements (concept) [edit]
Sortable	specifies the common requirements of algorithms that permute sequences into ordered sequences (concept) [edit]
Concept utilities
indirect_result_of	compute the result of invoking a callable object on the result of dereferencing some set of `Readable` types (class template) [edit]
projected	helper template for specifying the constraints on algorithms that accept projections (class template) [edit]
Iterator primitives
Iterator utilities
Defined in namespace `std::experimental::ranges`
iter_move	casts the result of dereferencing an object to its associated rvalue reference type (customization point object)[edit]
iter_swap	swap the values referenced by two dereferenceable objects (customization point object)[edit]
Iterator traits
Defined in namespace `std::experimental::ranges`
difference_type	obtains the difference type of a `WeaklyIncrementable` type (class template) [edit]
value_type	obtains the value type of a `Readable` type (class template) [edit]
iterator_category	obtains the iterator category of an input iterator type (class template) [edit]
iterator_traits	compatibility traits class that collects an iterator’s associated types (alias template)[edit]
reference_trvalue_reference_titer_common_reference_t	obtains a dereferenceable object's associated reference types (alias template)[edit]
Iterator category tags
Defined in namespace `std::experimental::ranges`
input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tag	empty class types used to indicate iterator categories (class) [edit]
std::iterator_traits specializations
Defined in namespace `std`
std::iterator_traits<InputIterator>std::iterator_traits<OutputIterator>	specializes std::iterator_traits for ranges TS iterators (class template specialization) [edit]
Iterator operations
Defined in namespace `std::experimental::ranges`
advance	advances an iterator by given distance (function template) [edit]
distance	returns the distance between an iterator and a sentinel, or between the beginning and the end of a range (function template) [edit]
next	increment an iterator (function template) [edit]
prev	decrement an iterator (function template) [edit]
Iterator adaptors
Defined in namespace `std::experimental::ranges`
reverse_iterator	iterator adaptor for reverse-order traversal (class template) [edit]
back_insert_iterator	iterator adaptor for insertion at the end of a container (class template) [edit]
front_insert_iterator	iterator adaptor for insertion at the front of a container (class template) [edit]
insert_iterator	iterator adaptor for insertion into a container (class template) [edit]
move_iterator	iterator adaptor which dereferences to an rvalue reference (class template) [edit]
move_sentinel	sentinel adaptor for use with `move_iterator` (class template) [edit]
common_iterator	adapt an iterator-sentinel pair into a common iterator type for use with legacy algorithms (class template) [edit]
counted_iterator	iterator adaptor that keeps track of its distance from its starting position (class template) [edit]
default_sentinel	empty sentinel type for use with iterator types that know the bound of their range (class) [edit]
dangling	wrapper for a possibly dangling iterator (class template) [edit]
safe_iterator_t	alias template that wraps the iterator type of an rvalue range with `dangling` (alias template)[edit]
unreachable	sentinel type used with any iterator to denote an infinite range (class) [edit]
Stream iterators
Defined in namespace `std::experimental::ranges`
istream_iterator	input iterator that reads from std::basic_istream (class template) [edit]
ostream_iterator	output iterator that writes to std::basic_ostream (class template) [edit]
istreambuf_iterator	input iterator that reads from std::basic_streambuf (class template) [edit]
ostreambuf_iterator	output iterator that writes to std::basic_streambuf (class template) [edit]

[edit] Ranges

Defined in header `<experimental/ranges/range>`
Range concepts
Range	specifies that a type is a range, that is, it provides a `begin` iterator and an `end` sentinel (concept) [edit]
SizedRange	specifies that a range knows its size in constant time (concept) [edit]
View	specifies that a range is a view, that is, it has constant time copy/move/assignment (concept) [edit]
BoundedRange	specifies that a range has identical iterator and sentinel types (concept) [edit]
InputRange	specifies a range whose iterator type satisfies `InputIterator` (concept) [edit]
OutputRange	specifies a range whose iterator type satisfies `OutputIterator` (concept) [edit]
ForwardRange	specifies a range whose iterator type satisfies `ForwardIterator` (concept) [edit]
BidirectionalRange	specifies a range whose iterator type satisfies `BidirectionalIterator` (concept) [edit]
RandomAccessRange	specifies a range whose iterator type satisfies `RandomAccessIterator` (concept) [edit]
Range access
Defined in namespace `std::experimental::ranges`
begincbegin	returns an iterator to the beginning of a range (customization point object)[edit]
endcend	returns an iterator to the end of a range (customization point object)[edit]
rbegincrbegin	returns a reverse iterator to a range (customization point object)[edit]
rendcrend	returns a reverse end iterator to a range (customization point object)[edit]
Range primitives
Defined in namespace `std::experimental::ranges`
size	obtains the size of a range whose size can be calculated in constant time (customization point object)[edit]
empty	checks whether a range is empty (customization point object)[edit]
datacdata	obtains a pointer to the beginning of a contiguous range (customization point object)[edit]
iterator_tsentinel_t	obtains the iterator and sentinel types of a range (alias template)[edit]

[edit] Algorithms

Defined in header `<experimental/ranges/algorithm>`
Non-modifying sequence operations
Defined in namespace `std::experimental::ranges`
all_ofany_ofnone_of	checks if a predicate is true for all, any or none of the elements in a range (function template) [edit]
for_each	applies a function to a range of elements (function template) [edit]
countcount_if	returns the number of elements satisfying specific criteria (function template) [edit]
mismatch	finds the first position where two ranges differ (function template) [edit]
equal	determines if two sets of elements are the same (function template) [edit]
lexicographical_compare	returns true if one range is lexicographically less than another (function template) [edit]
findfind_iffind_if_not	finds the first element satisfying specific criteria (function template) [edit]
find_end	finds the last sequence of elements in a certain range (function template) [edit]
find_first_of	searches for any one of a set of elements (function template) [edit]
adjacent_find	finds the first two adjacent items that are equal (or satisfy a given predicate) (function template) [edit]
search	searches for a range of elements (function template) [edit]
search_n	searches for a number consecutive copies of an element in a range (function template) [edit]
Modifying sequence operations
Defined in namespace `std::experimental::ranges`
copycopy_if	copies a range of elements to a new location (function template) [edit]
copy_n	copies a number of elements to a new location (function template) [edit]
copy_backward	copies a range of elements in backwards order (function template) [edit]
move	moves a range of elements to a new location (function template) [edit]
move_backward	moves a range of elements to a new location in backwards order (function template) [edit]
fill	assigns a range of elements a certain value (function template) [edit]
fill_n	assigns a value to a number of elements (function template) [edit]
transform	applies a function to a range of elements (function template) [edit]
generate	saves the result of a function in a range (function template) [edit]
generate_n	saves the result of N applications of a function (function template) [edit]
removeremove_if	removes elements satisfying specific criteria (function template) [edit]
remove_copyremove_copy_if	copies a range of elements omitting those that satisfy specific criteria (function template) [edit]
replacereplace_if	replaces all values satisfying specific criteria with another value (function template) [edit]
replace_copyreplace_copy_if	copies a range, replacing elements satisfying specific criteria with another value (function template) [edit]
swap_ranges	swaps two ranges of elements (function template) [edit]
reverse	reverses the order of elements in a range (function template) [edit]
reverse_copy	creates a copy of a range that is reversed (function template) [edit]
rotate	rotates the order of elements in a range (function template) [edit]
rotate_copy	copies and rotate a range of elements (function template) [edit]
shuffle	randomly re-orders elements in a range (function template) [edit]
unique	removes consecutive duplicate elements in a range (function template) [edit]
unique_copy	creates a copy of some range of elements that contains no consecutive duplicates (function template) [edit]
Partitioning operations
Defined in namespace `std::experimental::ranges`
is_partitioned	determines if the range is partitioned by the given predicate (function template) [edit]
partition	divides a range of elements into two groups (function template) [edit]
partition_copy	copies a range dividing the elements into two groups (function template) [edit]
stable_partition	divides elements into two groups while preserving their relative order (function template) [edit]
partition_point	locates the partition point of a partitioned range (function template) [edit]
Sorting operations
Defined in namespace `std::experimental::ranges`
is_sorted	checks whether a range is sorted into ascending order (function template) [edit]
is_sorted_until	finds the largest sorted subrange (function template) [edit]
sort	sorts a range into ascending order (function template) [edit]
partial_sort	sorts the first N elements of a range (function template) [edit]
partial_sort_copy	copies and partially sorts a range of elements (function template) [edit]
stable_sort	sorts a range of elements while preserving order between equal elements (function template) [edit]
nth_element	partially sorts the given range making sure that it is partitioned by the given element (function template) [edit]
Binary search operations (on sorted ranges)
Defined in namespace `std::experimental::ranges`
lower_bound	returns an iterator to the first element not less than the given value (function template) [edit]
upper_bound	returns an iterator to the first element greater than a certain value (function template) [edit]
binary_search	determines if an element exists in a certain range (function template) [edit]
equal_range	returns range of elements matching a specific key (function template) [edit]
Set operations (on sorted ranges)
Defined in namespace `std::experimental::ranges`
merge	merges two sorted ranges (function template) [edit]
inplace_merge	merges two ordered ranges in-place (function template) [edit]
includes	returns true if one set is a subset of another (function template) [edit]
set_difference	computes the difference between two sets (function template) [edit]
set_intersection	computes the intersection of two sets (function template) [edit]
set_symmetric_difference	computes the symmetric difference between two sets (function template) [edit]
set_union	computes the union of two sets (function template) [edit]
Heap operations
Defined in namespace `std::experimental::ranges`
is_heap	checks if the given range is a max heap (function template) [edit]
is_heap_until	finds the largest subrange that is a max heap (function template) [edit]
make_heap	creates a max heap out of a range of elements (function template) [edit]
push_heap	adds an element to a max heap (function template) [edit]
pop_heap	removes the largest element from a max heap (function template) [edit]
sort_heap	turns a max heap into a range of elements sorted in ascending order (function template) [edit]
Minimum/maximum operations
Defined in namespace `std::experimental::ranges`
max	returns the greater of the given values (function template) [edit]
max_element	returns the largest element in a range (function template) [edit]
min	returns the smaller of the given values (function template) [edit]
min_element	returns the smallest element in a range (function template) [edit]
minmax	returns the smaller and larger of two elements (function template) [edit]
minmax_element	returns the smallest and the largest elements in a range (function template) [edit]
Permutation operations
Defined in namespace `std::experimental::ranges`
is_permutation	determines if a sequence is a permutation of another sequence (function template) [edit]
next_permutation	generates the next greater lexicographic permutation of a range of elements (function template) [edit]
prev_permutation	generates the next smaller lexicographic permutation of a range of elements (function template) [edit]

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

Technical Specification
Filesystem library (filesystem TS)
Library fundamentals (library fundamentals TS)
Library fundamentals 2 (library fundamentals TS v2)
Library fundamentals 3 (library fundamentals TS v3)
Extensions for parallelism (parallelism TS)
Extensions for parallelism 2 (parallelism TS v2)
Extensions for concurrency (concurrency TS)
Extensions for concurrency 2 (concurrency TS v2)
Concepts (concepts TS)
Ranges (ranges TS)
Reflection (reflection TS)
Mathematical special functions (special functions TR)
Experimental Non-TS
Pattern Matching
Linear Algebra
std::execution
Contracts
2D Graphics

@@ Line 2: / Line 2: @@
 {{cpp/experimental/ranges/navbar}}
-The C++ Extensions for Ranges, ISO/IEC TS 21425:XXXX, specifies one modification to the core language and defines new components for the C++ standard library listed on this page.
+The C++ Extensions for Ranges, ISO/IEC TS 21425:2017, specifies one modification to the core language and defines new components for the C++ standard library listed on this page.
-The Ranges TS is based on the C++14 standard as modified by the [[cpp/language/constraints|Concepts TS]].
+The Ranges TS is based on the C++14 standard as modified by the {{rlp|constraints|Concepts TS}}.
-==== Core language changes ====
+{{fmbox|class=noprint|style=font-size: 0.8em|text='''Merged into ISO C++''' The functionality described on this page was merged into the mainline ISO C++ standard as of 10/2018; see [[cpp/ranges|the ranges library]], [[cpp/algorithm/ranges|the constrained algorithms library]], and [[cpp/concepts|the core concepts library]] {{mark since c++20}}}}
-The Ranges TS modifies the specification of [[cpp/language/range-for|the range-based {{c|for}} loop]] to permit differently typed begin and end iterators. This change permits the use of sentinels and is also present in C++17.
-==== Concepts ====
+====Core language changes====
+The Ranges TS modifies the specification of [[cpp/language/range-for|the range-based {{c|for}} loop]] to permit differently typed begin and end iterators. This change permits the use of sentinels and is also present in C++17.
+====Concepts====
 {{dsc begin}}
-{{dsc header | experimental/ranges/concepts}}
+{{dsc h2|Core language concepts}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc header|experimental/ranges/concepts}}
-{{dsc h2 | Core language concepts}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Same | Specifies that a type is the same as another type}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Same}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/DerivedFrom | Specifies that a type is derived from another type}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc DerivedFrom}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/ConvertibleTo | Specifies that a type is implicitly convertible to another type}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc ConvertibleTo}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/CommonReference| Specifies that two types share a common reference type}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc CommonReference}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Common | Specifies that two types share a common type}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Common}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Integral | Specifies that a type is an integral type}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Integral}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/SignedIntegral | Specifies that a type is a integral type that is signed}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc SignedIntegral}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/UnsignedIntegral | Specifies that a type is an integral type that is not signed}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc UnsignedIntegral}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Assignable | Specifies that a type is assignable from another type}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Assignable}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Swappable | Specifies that a type can be swapped or that two types can be swapped with each other}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Swappable}}
-{{dsc h2 | Comparison concepts}}
+{{dsc h2|Comparison concepts}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Boolean | Specifies that a type can be used in Boolean contexts}}
+{{dsc header|experimental/ranges/concepts}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/WeaklyEqualityComparable| title=WeaklyEqualityComparable |Specifies that two types can be compared for equality using operators {{c|1===}} and {{c|1=!=}}  }}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/EqualityComparable | title=EqualityComparable |Specifies that operator {{c|1===}} is an equivalence relation }}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Boolean}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/StrictTotallyOrdered | specifies that the comparison operators on the type yield a total order}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc WeaklyEqualityComparableWith}}
-{{dsc h2 | Object concepts}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc EqualityComparable}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Destructible| Specifies that an object of the type can be destroyed and have its address taken with unary {{c|&}} }}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc StrictTotallyOrdered}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Constructible| Specifies that a variable of the type can be constructed from or bound to a set of argument types }}
+{{dsc h2|Object concepts}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/DefaultConstructible| Specifies that an object of a type can be default constructed }}
+{{dsc header|experimental/ranges/concepts}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/MoveConstructible|Specifies that an object of a type can be move constructed}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/CopyConstructible|Specifies that an object of a type can be copy constructed and move constructed  }}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Destructible}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Movable|Specifies that an object of a type can be moved and swapped}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Constructible}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Copyable|Specifies that an object of a type can be copied, moved, and swapped }}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc DefaultConstructible}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Semiregular| Specifies that an object of a type can be copied, moved, swapped, and default constructed}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc MoveConstructible}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Regular| Specifies that a type is regular, that is, it is both {{rconcept|Semiregular}} and {{rconcept|EqualityComparable}} }}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc CopyConstructible}}
-{{dsc h2 | Callable concepts}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Movable}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Invocable|title=Invocable<br/>RegularInvocable |Specifies that a callable type can be invoked with a given set of argument types }}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Copyable}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Predicate| Specifies that a callable type is a Boolean predicate }}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Semiregular}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/Relation| Specifies that a callable type is a binary relation }}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Regular}}
-{{dsc rconcept | cpp/experimental/ranges/concepts/StrictWeakOrder| Specifies that a {{rconcept|Relation}} imposes a strict weak ordering }}
+{{dsc h2|Callable concepts}}
+{{dsc header|experimental/ranges/concepts}}
+{{dsc namespace|std::experimental::ranges}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Invocable}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Predicate}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc Relation}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc StrictWeakOrder}}
+{{dsc h2|Random number generator concept}}
+{{dsc header|experimental/ranges/random}}
+{{dsc namespace|std::experimental::ranges}}
+{{dsc inc|cpp/experimental/ranges/concepts/dsc UniformRandomNumberGenerator}}
 {{dsc end}}
-==== General utilities ====
+====General utilities====
 {{dsc begin}}
-{{dsc h2 | Utility components}}
+{{dsc h2|Utility components}}
-{{dsc header | experimental/ranges/utility}}
+{{dsc header|experimental/ranges/utility}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc custpt   | cpp/experimental/ranges/utility/swap | Swaps the value of two objects}}
+{{dsc inc|cpp/experimental/ranges/utility/dsc swap}}
-{{dsc tfun     | cpp/experimental/ranges/utility/exchange | replaces the argument with a new value and returns its previous value }}
+{{dsc inc|cpp/experimental/ranges/utility/dsc exchange}}
-{{dsc h2 | Function objects }}
+{{dsc h2|Function objects}}
-{{dsc header | experimental/ranges/functional}}
+{{dsc header|experimental/ranges/functional}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc tfun     | cpp/experimental/ranges/functional/invoke | Invokes a {{concept|Callable}} object with the given arguments}}
+{{dsc inc|cpp/experimental/ranges/functional/dsc invoke}}
-{{dsc tclass   | cpp/experimental/ranges/functional/equal_to|function object implementing {{c|1=x == y}} }}
+{{dsc inc|cpp/experimental/ranges/functional/dsc equal_to}}
-{{dsc tclass   | cpp/experimental/ranges/functional/not_equal_to|function object implementing {{c|1=x != y}}}}
+{{dsc inc|cpp/experimental/ranges/functional/dsc not_equal_to}}
-{{dsc tclass   | cpp/experimental/ranges/functional/greater|function object implementing {{c|x > y}}}}
+{{dsc inc|cpp/experimental/ranges/functional/dsc greater}}
-{{dsc tclass   | cpp/experimental/ranges/functional/less|function object implementing {{c|x < y}}}}
+{{dsc inc|cpp/experimental/ranges/functional/dsc less}}
-{{dsc tclass   | cpp/experimental/ranges/functional/greater_equal|function object implementing {{c|1=x >= y}}}}
+{{dsc inc|cpp/experimental/ranges/functional/dsc greater_equal}}
-{{dsc tclass   | cpp/experimental/ranges/functional/less_equal|function object implementing {{c|1=x <= y}}}}
+{{dsc inc|cpp/experimental/ranges/functional/dsc less_equal}}
-{{dsc class   | cpp/experimental/ranges/functional/identity|function object that returns its argument unchanged}}
+{{dsc inc|cpp/experimental/ranges/functional/dsc identity}}
-{{dsc h2 | Metaprogramming and type traits }}
+{{dsc h2|Metaprogramming and type traits}}
-{{dsc header | type_traits}}
+{{dsc header|experimental/ranges/type_traits}}
-{{dsc namespace | std }}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc tclass   | cpp/experimental/ranges/type_traits/is_swappable|title=is_swappable_with<br/>is_swappable<br/>is_nothrow_swappable_with<br/>is_nothrow_swappable|checks if objects of a type can be swapped with objects of same or different type }}
+{{dsc inc|cpp/experimental/ranges/type_traits/dsc is_swappable}}
-{{dsc tclass   | cpp/experimental/ranges/type_traits/common_reference|title=basic_common_reference<br/>common_reference}}
+{{dsc inc|cpp/experimental/ranges/type_traits/dsc common_reference}}
-{{dsc tclass   | cpp/experimental/ranges/type_traits/common_type}}
+{{dsc inc|cpp/experimental/ranges/type_traits/dsc common_type}}
-{{dsc h2 | Tagged pairs and tuples}}
+{{dsc h2|Tagged pairs and tuples}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc header|experimental/ranges/utility}}
-{{dsc header | experimental/ranges/utility}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc rconcept | cpp/experimental/ranges/utility/TagSpecifier | }}
+{{dsc inc|cpp/experimental/ranges/utility/dsc TagSpecifier}}
-{{dsc rconcept | cpp/experimental/ranges/utility/TaggedType| }}
+{{dsc inc|cpp/experimental/ranges/utility/dsc TaggedType}}
-{{dsc tclass   | cpp/experimental/ranges/utility/tagged | }}
+{{dsc inc|cpp/experimental/ranges/utility/dsc tagged}}
-{{dsc talias   | cpp/experimental/ranges/utility/tagged_pair| }}
+{{dsc inc|cpp/experimental/ranges/utility/dsc tagged_pair}}
-{{dsc tfun     | cpp/experimental/ranges/utility/make_tagged_pair| }}
+{{dsc inc|cpp/experimental/ranges/utility/dsc make_tagged_pair}}
-{{dsc header | experimental/ranges/tuple}}
+{{dsc header|experimental/ranges/tuple}}
-{{dsc talias   | cpp/experimental/ranges/utility/tagged_tuple| }}
+{{dsc inc|cpp/experimental/ranges/utility/dsc tagged_tuple}}
-{{dsc tfun     | cpp/experimental/ranges/utility/make_tagged_tuple| }}
+{{dsc inc|cpp/experimental/ranges/utility/dsc make_tagged_tuple}}
-{{dsc header | experimental/ranges/algorithm}}
+{{dsc header|experimental/ranges/algorithm}}
 {{dsc namespace|std::experimental::ranges::tag}}
-{{dsc class | cpp/experimental/ranges/algorithm/tags | title=in<br>in1<br>in2<br>out<br>out1<br>out2<br>fun<br>min<br>max<br>begin<br>end| Tag specifiers for use with {{lc|ranges::tagged}}}}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc tags}}
 {{dsc end}}
-==== Iterators ====
+====Iterators====
 {{dsc begin}}
-{{dsc header | experimental/ranges/iterator}}
+{{dsc header|experimental/ranges/iterator}}
-{{dsc h2 | Iterator concepts}} <!--- no actual wording that says it lives in <.../iterator>...or which namespaces they live in --->
+{{dsc h2|Iterator-related concepts}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/Readable| }}
+{{dsc h3|Iterator concepts}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/Writable| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc Readable}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/WeaklyIncrementable| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc Writable}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/Incrementable| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc WeaklyIncrementable}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/Iterator| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc Incrementable}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/Sentinel| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc Iterator}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/SizedSentinel| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc Sentinel}}
-{{dsc tvar     | cpp/experimental/ranges/iterator/disable_sized_sentinel| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc SizedSentinel}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/InputIterator| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc InputIterator}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/OutputIterator| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc OutputIterator}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/ForwardIterator| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc ForwardIterator}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/BidirectionalIterator| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc BidirectionalIterator}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/RandomAccessIterator| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc RandomAccessIterator}}
-{{dsc h3 | Indirect callable concepts }}
+{{dsc h3|Indirect callable concepts}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/IndirectInvocable|title= IndirectInvocable<br/>IndirectRegularInvocable }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc IndirectUnaryInvocable}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/IndirectPredicate| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc IndirectUnaryPredicate}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/IndirectRelation| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc IndirectRelation}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/IndirectStrictWeakOrder| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc IndirectStrictWeakOrder}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/indirect_result_of}}
+{{dsc h3|Common algorithm requirements}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/projected}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc IndirectlyMovable}}
-{{dsc h3 | Common algorithm requirements}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc IndirectlyMovableStorable}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/IndirectlyMovable| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc IndirectlyCopyable}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/IndirectlyMovableStorable| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc IndirectlyCopyableStorable}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/IndirectlyCopyable| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc IndirectlySwappable}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/IndirectlyCopyableStorable| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc IndirectlyComparable}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/IndirectlySwappable| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc Permutable}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/IndirectlyComparable| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc Mergeable}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/Permutable| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc Sortable}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/Mergeable| }}
+{{dsc h3|Concept utilities}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/Sortable| }}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc indirect_result_of}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc projected}}
+{{dsc h2|Iterator primitives}}
+{{dsc h3|Iterator utilities}}
+{{dsc namespace|std::experimental::ranges}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc iter_move}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc iter_swap}}
+{{dsc h3|Iterator traits}}
+{{dsc namespace|std::experimental::ranges}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc difference_type}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc value_type}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc iterator_category}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc iterator_traits}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc reference_t}}
+{{dsc h3|Iterator category tags}}
+{{dsc namespace|std::experimental::ranges}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc iterator_tags}}
+{{dsc h3|{{lc|std::iterator_traits}} specializations}}
+{{dsc namespace|std}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc std_iter_traits}}
+{{dsc h3|Iterator operations}}
+{{dsc namespace|std::experimental::ranges}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc advance}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc distance}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc next}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc prev}}
+{{dsc h2|Iterator adaptors}}
+{{dsc namespace|std::experimental::ranges}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc reverse_iterator}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc back_insert_iterator}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc front_insert_iterator}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc insert_iterator}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc move_iterator}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc move_sentinel}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc common_iterator}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc counted_iterator}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc default_sentinel}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc dangling}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc safe_iterator_t}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc unreachable}}
+{{dsc h2|Stream iterators}}
+{{dsc namespace|std::experimental::ranges}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc istream_iterator}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc ostream_iterator}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc istreambuf_iterator}}
+{{dsc inc|cpp/experimental/ranges/iterator/dsc ostreambuf_iterator}}
+{{dsc end}}
-{{dsc h2 | Iterator primitives }}
+====Ranges====
-{{dsc h3 | Iterator utilities}}
+{{dsc begin}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc header|experimental/ranges/range}}
-{{dsc custpt   | cpp/experimental/ranges/iterator/iter_move}}
+{{dsc h2|Range concepts}}
-{{dsc custpt   | cpp/experimental/ranges/iterator/iter_swap}}
+{{dsc inc|cpp/experimental/ranges/range/dsc Range}}
-{{dsc h3 | Iterator traits}}
+{{dsc inc|cpp/experimental/ranges/range/dsc SizedRange}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc inc|cpp/experimental/ranges/range/dsc View}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/difference_type}}
+{{dsc inc|cpp/experimental/ranges/range/dsc BoundedRange}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/value_type}}
+{{dsc inc|cpp/experimental/ranges/range/dsc InputRange}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/iterator_category}}
+{{dsc inc|cpp/experimental/ranges/range/dsc OutputRange}}
-{{dsc talias   | cpp/experimental/ranges/iterator/iterator_traits}}
+{{dsc inc|cpp/experimental/ranges/range/dsc ForwardRange}}
-{{dsc talias   | cpp/experimental/ranges/iterator/reference_t}}
+{{dsc inc|cpp/experimental/ranges/range/dsc BidirectionalRange}}
-{{dsc talias   | cpp/experimental/ranges/iterator/rvalue_reference_t}}
+{{dsc inc|cpp/experimental/ranges/range/dsc RandomAccessRange}}
-{{dsc talias   | cpp/experimental/ranges/iterator/iter_common_reference_t}}
+{{dsc h2|Range access}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/is_indirectly_movable|title= is_indirectly_movable<br/>is_nothrow_indirectly_movable}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/is_indirectly_swappable|title= is_indirectly_swappable<br/>is_nothrow_indirectly_swappable}}
+{{dsc inc|cpp/experimental/ranges/range/dsc begin}}
-{{dsc h3 | Iterator category tags }}
+{{dsc inc|cpp/experimental/ranges/range/dsc end}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc inc|cpp/experimental/ranges/range/dsc rbegin}}
-{{dsc class | cpp/experimental/ranges/iterator/iterator_tags | title=input_iterator_tag<br>output_iterator_tag<br>forward_iterator_tag<br>bidirectional_iterator_tag<br>random_access_iterator_tag| empty class types used to indicate iterator categories}}
+{{dsc inc|cpp/experimental/ranges/range/dsc rend}}
-{{dsc h3 | {{lc|std::iterator_traits}} specializations}}
+{{dsc h2|Range primitives}}
-{{dsc namespace |std}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc ptclass | cpp/experimental/ranges/iterator/std_iter_traits|title=std::iterator_traits{{small|<InputIterator>}}<br/>std::iterator_traits{{small|<OutputIterator>}}|Specializes {{lc|std::iterator_traits}} for ranges TS iterators}}
+{{dsc inc|cpp/experimental/ranges/range/dsc size}}
-{{dsc h3 | Iterator operations}}
+{{dsc inc|cpp/experimental/ranges/range/dsc empty}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc inc|cpp/experimental/ranges/range/dsc data}}
-{{dsc tfun     | cpp/experimental/ranges/iterator/advance }}
+{{dsc inc|cpp/experimental/ranges/range/dsc iterator_t}}
-{{dsc tfun     | cpp/experimental/ranges/iterator/distance }}
-{{dsc tfun     | cpp/experimental/ranges/iterator/next }}
-{{dsc tfun     | cpp/experimental/ranges/iterator/prev }}
-{{dsc h2 | Iterator adaptors}}
-{{dsc namespace |std::experimental::ranges}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/reverse_iterator}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/back_insert_iterator}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/front_insert_iterator}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/insert_iterator}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/move_iterator}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/move_sentinel}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/common_iterator}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/counted_iterator}}
-{{dsc class    | cpp/experimental/ranges/iterator/default_sentinel}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/dangling}}
-{{dsc talias   | cpp/experimental/ranges/iterator/safe_iterator_t}}
-{{dsc class    | cpp/experimental/ranges/iterator/unreachable}}
-{{dsc h2 | Stream iterators}}
-{{dsc namespace |std::experimental::ranges}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/istream_iterator}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/ostream_iterator}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/istreambuf_iterator}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/ostreambuf_iterator}}
-{{dsc h2 | Range concepts}}
-{{dsc namespace |std::experimental::ranges}}
-{{dsc talias   | cpp/experimental/ranges/iterator/iterator_t}}
-{{dsc talias   | cpp/experimental/ranges/iterator/sentinel_t}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/Range | }}
-{{dsc rconcept | cpp/experimental/ranges/iterator/SizedRange | }}
-{{dsc tvar     | cpp/experimental/ranges/iterator/disable_sized_range}}
-{{dsc class    | cpp/experimental/ranges/iterator/view_base}}
-{{dsc tclass   | cpp/experimental/ranges/iterator/enable_view}}
-{{dsc rconcept | cpp/experimental/ranges/iterator/View| }}
-{{dsc rconcept | cpp/experimental/ranges/iterator/BoundedRange | }}
-{{dsc rconcept | cpp/experimental/ranges/iterator/InputRange | }}
-{{dsc rconcept | cpp/experimental/ranges/iterator/OutputRange | }}
-{{dsc rconcept | cpp/experimental/ranges/iterator/ForwardRange | }}
-{{dsc rconcept | cpp/experimental/ranges/iterator/BidirectionalRange | }}
-{{dsc rconcept | cpp/experimental/ranges/iterator/RandomAccessRange | }}
-{{dsc h2 | Range access }}
-{{dsc namespace |std::experimental::ranges}}
-{{dsc custpt   | cpp/experimental/ranges/iterator/begin | }}
-{{dsc custpt   | cpp/experimental/ranges/iterator/end | }}
-{{dsc custpt   | cpp/experimental/ranges/iterator/cbegin | }}
-{{dsc custpt   | cpp/experimental/ranges/iterator/cend | }}
-{{dsc custpt   | cpp/experimental/ranges/iterator/rbegin | }}
-{{dsc custpt   | cpp/experimental/ranges/iterator/rend | }}
-{{dsc custpt   | cpp/experimental/ranges/iterator/crbegin | }}
-{{dsc custpt   | cpp/experimental/ranges/iterator/crend | }}
-{{dsc h2 | Range primitives }}
-{{dsc namespace |std::experimental::ranges}}
-{{dsc tfun     | cpp/experimental/ranges/iterator/distance | }}
-{{dsc custpt   | cpp/experimental/ranges/iterator/size | }}
-{{dsc custpt   | cpp/experimental/ranges/iterator/empty| }}
-{{dsc custpt   | cpp/experimental/ranges/iterator/data | }}
-{{dsc custpt   | cpp/experimental/ranges/iterator/cdata | }}
 {{dsc end}}
-==== Algorithms ====
+====Algorithms====
 {{dsc begin}}
-{{dsc header | experimental/ranges/algorithm}}
+{{dsc header|experimental/ranges/algorithm}}
-{{dsc h2 | Non-modifying sequence operations}}
+{{dsc h2|Non-modifying sequence operations}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/all_any_none_of | title=all_of<br>any_of<br>none_of | checks if a predicate is {{c|true}} for all, any or none of the elements in a range }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc all_any_none_of}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/for_each | applies a function to a range of elements}}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc for_each}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/count | title=count<br>count_if | returns the number of elements satisfying specific criteria }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc count}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/mismatch | finds the first position where two ranges differ }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc mismatch}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/equal | determines if two sets of elements are the same }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc equal}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/find | title=find<br>find_if<br>find_if_not | finds the first element satisfying specific criteria}}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc lexicographical_compare}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/find_end | finds the last sequence of elements in a certain range }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc find}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/find_first_of | searches for any one of a set of elements }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc find_end}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/adjacent_find | finds the first two adjacent items that are equal (or satisfy a given predicate) }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc find_first_of}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/search | searches for a range of elements }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc adjacent_find}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/search_n | searches for a number consecutive copies of an element in a range }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc search}}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc search_n}}
-{{dsc h2 | Modifying sequence operations}}
+{{dsc h2|Modifying sequence operations}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/copy | copies a range of elements to a new location | title=copy<br>copy_if }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc copy}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/copy_n | copies a number of elements to a new location  }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc copy_n}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/copy_backward | copies a range of elements in backwards order }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc copy_backward}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/move | moves a range of elements to a new location  }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc move}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/move_backward | moves a range of elements to a new location in backwards order}}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc move_backward}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/fill | assigns a range of elements a certain value }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc fill}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/fill_n | assigns a value to a number of elements }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc fill_n}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/transform | applies a function to a range of elements }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc transform}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/generate | saves the result of a function in a range }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc generate}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/generate_n | saves the result of N applications of a function }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc generate_n}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/remove | title=remove<br>remove_if | removes elements satisfying specific criteria }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc remove}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/remove_copy | title=remove_copy<br>remove_copy_if | copies a range of elements omitting those that satisfy specific criteria }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc remove_copy}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/replace | title=replace<br>replace_if| replaces all values satisfying specific criteria with another value }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc replace}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/replace_copy | title=replace_copy<br>replace_copy_if | copies a range, replacing elements satisfying specific criteria with another value }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc replace_copy}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/swap_ranges | swaps two ranges of elements }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc swap_ranges}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/reverse | reverses the order of elements in a range }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc reverse}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/reverse_copy | creates a copy of a range that is reversed }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc reverse_copy}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/rotate | rotates the order of elements in a range }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc rotate}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/rotate_copy | copies and rotate a range of elements }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc rotate_copy}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/shuffle | randomly re-orders elements in a range }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc shuffle}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/unique | removes consecutive duplicate elements in a range }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc unique}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/unique_copy | creates a copy of some range of elements that contains no consecutive duplicates }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc unique_copy}}
-{{dsc h2 | Partitioning operations}}
+{{dsc h2|Partitioning operations}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/is_partitioned | determines if the range is partitioned by the given predicate  }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc is_partitioned}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/partition | divides a range of elements into two groups }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc partition}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/partition_copy | copies a range dividing the elements into two groups }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc partition_copy}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/stable_partition | divides elements into two groups while preserving their relative order }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc stable_partition}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/partition_point | locates the partition point of a partitioned range }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc partition_point}}
-{{dsc h2 | Sorting operations}}
+{{dsc h2|Sorting operations}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/is_sorted | checks whether a range is sorted into ascending order }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc is_sorted}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/is_sorted_until | finds the largest sorted subrange }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc is_sorted_until}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/sort | sorts a range into ascending order }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc sort}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/partial_sort | sorts the first N elements of a range }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc partial_sort}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/partial_sort_copy | copies and partially sorts a range of elements }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc partial_sort_copy}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/stable_sort | sorts a range of elements while preserving order between equal elements }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc stable_sort}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/nth_element | partially sorts the given range making sure that it is partitioned by the given element }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc nth_element}}
-{{dsc h2 | Binary search operations (on sorted ranges)}}
+{{dsc h2|Binary search operations (on sorted ranges)}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/lower_bound | returns an iterator to the first element ''not less'' than the given value}}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc lower_bound}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/upper_bound | returns an iterator to the first element ''greater'' than a certain value}}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc upper_bound}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/binary_search | determines if an element exists in a certain range }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc binary_search}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/equal_range | returns range of elements matching a specific key}}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc equal_range}}
-{{dsc h2 | Set operations (on sorted ranges)}}
+{{dsc h2|Set operations (on sorted ranges)}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/merge | merges two sorted ranges }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc merge}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/inplace_merge | merges two ordered ranges in-place }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc inplace_merge}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/includes | returns true if one set is a subset of another }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc includes}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/set_difference | computes the difference between two sets }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc set_difference}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/set_intersection | computes the intersection of two sets }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc set_intersection}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/set_symmetric_difference | computes the symmetric difference between two sets }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc set_symmetric_difference}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/set_union | computes the union of two sets }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc set_union}}
-{{dsc h2 | Heap operations}}
+{{dsc h2|Heap operations}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/is_heap | checks if the given range is a max heap}}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc is_heap}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/is_heap_until | finds the largest subrange that is a max heap }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc is_heap_until}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/make_heap | creates a max heap out of a range of elements }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc make_heap}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/push_heap | adds an element to a max heap }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc push_heap}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/pop_heap | removes the largest element from a max heap }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc pop_heap}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/sort_heap | turns a max heap into a range of elements sorted in ascending order }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc sort_heap}}
-{{dsc h2 | Minimum/maximum operations}}
+{{dsc h2|Minimum/maximum operations}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/max | returns the greater of the given values }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc max}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/max_element | returns the largest element in a range }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc max_element}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/min | returns the smaller of the given values }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc min}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/min_element | returns the smallest element in a range }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc min_element}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/minmax | returns the smaller and larger of two elements }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc minmax}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/minmax_element | returns the smallest and the largest elements in a range }}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc minmax_element}}
-{{dsc tfun | cpp/experimental/ranges/algorithm/lexicographical_compare | returns true if one range is lexicographically less than another }}
-{{dsc tfun | cpp/experimental/ranges/algorithm/is_permutation | determines if a sequence is a permutation of another sequence }}
-{{dsc tfun | cpp/experimental/ranges/algorithm/next_permutation | generates the next greater lexicographic permutation of a range of elements }}
-{{dsc tfun | cpp/experimental/ranges/algorithm/prev_permutation | generates the next smaller lexicographic permutation of a range of elements }}
-{{dsc end}}
-==== Random number generator concept====
+{{dsc h2|Permutation operations}}
-{{dsc begin}}
+{{dsc namespace|std::experimental::ranges}}
-{{dsc header|experimental/ranges/random}}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc is_permutation}}
-{{dsc namespace |std::experimental::ranges}}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc next_permutation}}
-{{dsc rconcept|cpp/experimental/ranges/random/UniformRandomNumberGenerator}}
+{{dsc inc|cpp/experimental/ranges/algorithm/dsc prev_permutation}}
 {{dsc end}}
+{{langlinks|ru|zh}}

cppreference.com

Namespaces

Variants

Views

Actions

Difference between revisions of "cpp/experimental/ranges"

Latest revision as of 10:56, 28 November 2023

Contents

[edit] Core language changes

[edit] Concepts

Core language concepts

Comparison concepts

Object concepts

Callable concepts

Random number generator concept

[edit] General utilities

Utility components

Function objects

Metaprogramming and type traits

Tagged pairs and tuples

[edit] Iterators

Iterator-related concepts

Iterator concepts

Indirect callable concepts

Common algorithm requirements

Concept utilities

Iterator primitives

Iterator utilities

Iterator traits

Iterator category tags

std::iterator_traits specializations

Iterator operations

Iterator adaptors

Stream iterators

[edit] Ranges

Range concepts

Range access

Range primitives

[edit] Algorithms

Non-modifying sequence operations

Modifying sequence operations

Partitioning operations

Sorting operations

Binary search operations (on sorted ranges)

Set operations (on sorted ranges)

Heap operations

Minimum/maximum operations

Permutation operations

Navigation

Toolbox