Extensions for ranges
From cppreference.com
                    
                                        
                    < cpp | experimental
                    
                                                            
                    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 Ranges TS is based on the C++14 standard as modified by the Concepts TS.
| Contents | 
[edit] Core language changes
The Ranges TS modifies the specification of the range-based for loop to permit differently typed begin and end iterators. This change permits the use of sentinels and is also present in C++17.
[edit] Concepts
| Core language concepts | |
| Defined in header  <experimental/ranges/concepts> | |
| Defined in  namespace  std::experimental::ranges | |
| specifies that a type is the same as another type (concept) | |
| specifies that a type is derived from another type (concept) | |
| specifies that a type is implicitly convertible to another type (concept) | |
| specifies that two types share a common reference type (concept) | |
| specifies that two types share a common type (concept) | |
| specifies that a type is an integral type (concept) | |
| specifies that a type is a integral type that is signed (concept) | |
| specifies that a type is an integral type that is not signed (concept) | |
| specifies that a type is assignable from another type (concept) | |
| specifies that a type can be swapped or that two types can be swapped with each other (concept) | |
| Comparison concepts | |
| Defined in header  <experimental/ranges/concepts> | |
| Defined in  namespace  std::experimental::ranges | |
| specifies that a type can be used in Boolean contexts (concept) | |
| specifies that two types can be compared for equality using operators == and != (concept) | |
| specifies that operator == is an equivalence relation (concept) | |
| specifies that the comparison operators on the type yield a total order (concept) | |
| Object concepts | |
| Defined in header  <experimental/ranges/concepts> | |
| Defined in  namespace  std::experimental::ranges | |
| specifies that an object of the type can be destroyed and have its address taken with unary & (concept) | |
| specifies that a variable of the type can be constructed from or bound to a set of argument types (concept) | |
| specifies that an object of a type can be default constructed (concept) | |
| specifies that an object of a type can be move constructed (concept) | |
| specifies that an object of a type can be copy constructed and move constructed (concept) | |
| specifies that an object of a type can be moved and swapped (concept) | |
| specifies that an object of a type can be copied, moved, and swapped (concept) | |
| specifies that an object of a type can be copied, moved, swapped, and default constructed (concept) | |
| specifies that a type is regular, that is, it is both SemiregularandEqualityComparable(concept) | |
| Callable concepts | |
| Defined in header  <experimental/ranges/concepts> | |
| Defined in  namespace  std::experimental::ranges | |
| specifies that a callable type can be invoked with a given set of argument types (concept) | |
| specifies that a callable type is a Boolean predicate (concept) | |
| specifies that a callable type is a binary relation (concept) | |
| specifies that a Relationimposes a strict weak ordering(concept) | |
| Random number generator concept | |
| Defined in header  <experimental/ranges/random> | |
| Defined in  namespace  std::experimental::ranges | |
| specifies that a type qualifies as a uniform random number generator (concept) | |
[edit] General utilities
| Utility components | |
| Defined in header  <experimental/ranges/utility> | |
| Defined in  namespace  std::experimental::ranges | |
| swaps the value of two objects (customization point object) | |
| replaces the argument with a new value and returns its previous value (function template) | |
| Function objects | |
| Defined in header  <experimental/ranges/functional> | |
| Defined in  namespace  std::experimental::ranges | |
| invokes a Callableobject with the given arguments(function template) | |
| function object implementing x == y (class template) | |
| function object implementing x != y (class template) | |
| function object implementing x > y (class template) | |
| function object implementing x < y (class template) | |
| function object implementing x >= y (class template) | |
| function object implementing x <= y (class template) | |
| function object that returns its argument unchanged (class) | |
| Metaprogramming and type traits | |
| Defined in header  <type_traits> | |
| Defined in  namespace  std | |
| checks if objects of a type can be swapped with objects of same or different type (class template) | |
| determine the common reference type of a set of types (class template) | |
| determine the common type of a set of types (class template) | |
| Tagged pairs and tuples | |
| Defined in  namespace  std::experimental::ranges | |
| Defined in header  <experimental/ranges/utility> | |
| specifies that a type is a tag specifier (concept) | |
| specifies that a type represents a tag specifier and its element type (concept) | |
| augument a tuple-like type with named accessors (class template) | |
| alias template for a tagged std::pair (alias template) | |
| convenience function for creating a tagged_pair(function template) | |
| Defined in header  <experimental/ranges/tuple> | |
| alias template for a tagged std::tuple (alias template) | |
| convenience function for creating a tagged_tuple(function template) | |
| Defined in header  <experimental/ranges/algorithm> | |
| Defined in  namespace  std::experimental::ranges::tag | |
| tag specifiers for use with ranges::tagged (class) | |
[edit] Iterators
| Defined in header  <experimental/ranges/iterator> | |
| Iterator and range concepts | |
| Defined in  namespace  std::experimental::ranges | |
| Iterator concepts | |
| specifies that a type is readable by applying operator *(concept) | |
| specifies that a value can be written to an iterator's referenced object (concept) | |
| specifies that a type can be incremented with pre- and post-increment operators (concept) | |
| specifies that the increment operation on a WeaklyIncrementabletype is equality-preserving and that the type isEqualityComparable(concept) | |
| specifies that objects of a type can be incremented and dereferenced (concept) | |
| specifies that objects of a type is a sentinel for an Iteratortype(concept) | |
| specifies that the -operator can be applied to an iterator and a sentinel to calculate their difference in constant time(concept) | |
| 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) | |
| 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) | |
| specifies that an InputIteratoris a forward iterator, supporting equality comparison and multi-pass(concept) | |
| specifies that a ForwardIteratoris a bidirectional interator, supporting movement backwards(concept) | |
| specifies that a BidirectionalIteratoris a random-access interator, supporting advancement in constant time and subscripting(concept) | |
| Indirect callable concepts | |
| specifies that a callable type can be invoked with the result of dereferencing some Readabletypes(concept) | |
| specifies that a callable object, when invoked with the result of dereferencing some Readabletypes, satisfiesPredicate(concept) | |
| specifies that a callable object, when invoked with the result of dereferencing some Readabletypes, satisfiesRelation(concept) | |
| specifies that a callable object, when invoked with the result of dereferencing some Readabletypes, satisfiesStrictWeakOrder(concept) | |
| Common algorithm requirements | |
| specifies that values may be moved from a Readabletype to aWritabletype(concept) | |
| specifies that values may be moved from a Readabletype to aWritabletype and that the move may be performed via an intermediate object(concept) | |
| specifies that values may be copied from a Readabletype to aWritabletype(concept) | |
| specifies that values may be copied from a Readabletype to aWritabletype and that the copy may be performed via an intermediate object(concept) | |
| specifies that the values referenced by two Readabletypes can be swapped(concept) | |
| specifies that the values referenced by two Readabletypes can be compared(concept) | |
| specifies the common requirements of algorithms that reorder elements in place (concept) | |
| specifies the requirements of algorithms that merge sorted sequences into an output sequence by copying elements (concept) | |
| specifies the common requirements of algorithms that permute sequences into ordered sequences (concept) | |
| Range concepts | |
| specifies that a type is a range, that is, it provides a beginiterator and anendsentinel(concept) | |
| specifies that a range knows its size in constant time (concept) | |
| specifies that a range is a view, that is, it has constant time copy/move/assignment (concept) | |
| specifies that a range has identical iterator and sentinel types (concept) | |
| specifies a range whose iterator type satisfies InputIterator(concept) | |
| specifies a range whose iterator type satisfies OutputIterator(concept) | |
| specifies a range whose iterator type satisfies ForwardIterator(concept) | |
| specifies a range whose iterator type satisfies BidirectionalIterator(concept) | |
| specifies a range whose iterator type satisfies RandomAccessIterator(concept) | |
| Concept utilities | |
| compute the result of invoking a callable object on the result of dereferencing some set of Readabletypes(class template) | |
| helper template for specifying the constraints on algorithms that accept projections (class template) | |
| provides a mechanism to declare that an iterator-sentinel pair does not satisfy SizedSentinel(variable template) | |
| Provide a mechanism to declare that a range does not meet SizedRange(variable template) | |
| empty base class to signify that a class is a view (class) | |
| helper trait to differentiate views from other ranges (class template) | |
| Iterator primitives | |
| Iterator utilities | |
| Defined in  namespace  std::experimental::ranges | |
| casts the result of dereferencing an object to its associated rvalue reference type (customization point object) | |
| swap the values referenced by two dereferenceable objects (customization point object) | |
| Iterator traits | |
| Defined in  namespace  std::experimental::ranges | |
| obtains the difference type of a WeaklyIncrementabletype(class template) | |
| obtains the value type of a Readabletype(class template) | |
| obtains the iterator category of an input iterator type (class template) | |
| compatibility traits class that collects an iterator’s associated types (alias template) | |
| obtains a dereferenceable object's reference type (alias template) | |
| obtains a dereferenceable object's rvalue reference type (alias template) | |
| compute the common reference type of a Readableobject's reference type and an lvalue reference to its value type(alias template) | |
| tests whether two types satisfy IndirectlyMovable(class template) | |
| tests whether two types satisfy IndirectlySwappable(class template) | |
| Iterator category tags | |
| Defined in  namespace  std::experimental::ranges | |
| empty class types used to indicate iterator categories (class) | |
| std::iterator_traits specializations | |
| Defined in  namespace  std | |
| specializes std::iterator_traits for ranges TS iterators (class template specialization) | |
| Iterator operations | |
| Defined in  namespace  std::experimental::ranges | |
| advances an iterator by given distance (function template) | |
| returns the distance between an iterator and a sentinel, or between the beginning and the end of a range (function template) | |
| increment an iterator (function template) | |
| decrement an iterator (function template) | |
| Iterator adaptors | |
| Defined in  namespace  std::experimental::ranges | |
| iterator adaptor for reverse-order traversal (class template) | |
| iterator adaptor for insertion at the end of a container (class template) | |
| iterator adaptor for insertion at the front of a container (class template) | |
| iterator adaptor for insertion into a container (class template) | |
| iterator adaptor which dereferences to an rvalue reference (class template) | |
| sentinel adaptor for use with move_iterator(class template) | |
| adapt an iterator-sentinel pair into a common iterator type for use with legacy algorithms (class template) | |
| iterator adaptor that keeps track of its distance from its starting position (class template) | |
| empty sentinel type for use with iterator types that know the bound of their range (class) | |
| wrapper for a possibly dangling iterator (class template) | |
| alias template that wraps the iterator type of an rvalue range with dangling(alias template) | |
| sentinel type used with any iterator to denote an infinite range (class) | |
| Stream iterators | |
| Defined in  namespace  std::experimental::ranges | |
| input iterator that reads from std::basic_istream (class template) | |
| output iterator that writes to std::basic_ostream (class template) | |
| input iterator that reads from std::basic_streambuf (class template) | |
| output iterator that writes to std::basic_streambuf (class template) | |
| Range access | |
| Defined in  namespace  std::experimental::ranges | |
| returns an iterator to the beginning of a range (customization point object) | |
| returns an iterator to the end of a range (customization point object) | |
| returns a reverse iterator to a range (customization point object) | |
| returns a reverse end iterator to a range (customization point object) | |
| Range primitives | |
| Defined in  namespace  std::experimental::ranges | |
| obtains the iterator type of a range (alias template) | |
| obtains the sentinel type of a range (alias template) | |
| returns the distance between an iterator and a sentinel, or between the beginning and the end of a range (function template) | |
| obtains the size of a range whose size can be calculated in constant time (customization point object) | |
| checks whether a range is empty (customization point object) | |
| obtains a pointer to the beginning of a contiguous range (customization point object) | |
[edit] Algorithms
| Defined in header  <experimental/ranges/algorithm> | |
| Non-modifying sequence operations | |
| Defined in  namespace  std::experimental::ranges | |
| checks if a predicate is true for all, any or none of the elements in a range (function template) | |
| applies a function to a range of elements (function template) | |
| returns the number of elements satisfying specific criteria (function template) | |
| finds the first position where two ranges differ (function template) | |
| determines if two sets of elements are the same (function template) | |
| finds the first element satisfying specific criteria (function template) | |
| finds the last sequence of elements in a certain range (function template) | |
| searches for any one of a set of elements (function template) | |
| finds the first two adjacent items that are equal (or satisfy a given predicate) (function template) | |
| searches for a range of elements (function template) | |
| searches for a number consecutive copies of an element in a range (function template) | |
| Modifying sequence operations | |
| Defined in  namespace  std::experimental::ranges | |
| copies a range of elements to a new location (function template) | |
| copies a number of elements to a new location (function template) | |
| copies a range of elements in backwards order (function template) | |
| moves a range of elements to a new location (function template) | |
| moves a range of elements to a new location in backwards order (function template) | |
| assigns a range of elements a certain value (function template) | |
| assigns a value to a number of elements (function template) | |
| applies a function to a range of elements (function template) | |
| saves the result of a function in a range (function template) | |
| saves the result of N applications of a function (function template) | |
| removes elements satisfying specific criteria (function template) | |
| copies a range of elements omitting those that satisfy specific criteria (function template) | |
| replaces all values satisfying specific criteria with another value (function template) | |
| copies a range, replacing elements satisfying specific criteria with another value (function template) | |
| swaps two ranges of elements (function template) | |
| reverses the order of elements in a range (function template) | |
| creates a copy of a range that is reversed (function template) | |
| rotates the order of elements in a range (function template) | |
| copies and rotate a range of elements (function template) | |
| randomly re-orders elements in a range (function template) | |
| removes consecutive duplicate elements in a range (function template) | |
| creates a copy of some range of elements that contains no consecutive duplicates (function template) | |
| Partitioning operations | |
| Defined in  namespace  std::experimental::ranges | |
| determines if the range is partitioned by the given predicate (function template) | |
| divides a range of elements into two groups (function template) | |
| copies a range dividing the elements into two groups (function template) | |
| divides elements into two groups while preserving their relative order (function template) | |
| locates the partition point of a partitioned range (function template) | |
| Sorting operations | |
| Defined in  namespace  std::experimental::ranges | |
| checks whether a range is sorted into ascending order (function template) | |
| finds the largest sorted subrange (function template) | |
| sorts a range into ascending order (function template) | |
| sorts the first N elements of a range (function template) | |
| copies and partially sorts a range of elements (function template) | |
| sorts a range of elements while preserving order between equal elements (function template) | |
| partially sorts the given range making sure that it is partitioned by the given element (function template) | |
| Binary search operations (on sorted ranges) | |
| Defined in  namespace  std::experimental::ranges | |
| returns an iterator to the first element not less than the given value (function template) | |
| returns an iterator to the first element greater than a certain value (function template) | |
| determines if an element exists in a certain range (function template) | |
| returns range of elements matching a specific key (function template) | |
| Set operations (on sorted ranges) | |
| Defined in  namespace  std::experimental::ranges | |
| merges two sorted ranges (function template) | |
| merges two ordered ranges in-place (function template) | |
| returns true if one set is a subset of another (function template) | |
| computes the difference between two sets (function template) | |
| computes the intersection of two sets (function template) | |
| computes the symmetric difference between two sets (function template) | |
| computes the union of two sets (function template) | |
| Heap operations | |
| Defined in  namespace  std::experimental::ranges | |
| checks if the given range is a max heap (function template) | |
| finds the largest subrange that is a max heap (function template) | |
| creates a max heap out of a range of elements (function template) | |
| adds an element to a max heap (function template) | |
| removes the largest element from a max heap (function template) | |
| turns a max heap into a range of elements sorted in ascending order (function template) | |
| Minimum/maximum operations | |
| Defined in  namespace  std::experimental::ranges | |
| returns the greater of the given values (function template) | |
| returns the largest element in a range (function template) | |
| returns the smaller of the given values (function template) | |
| returns the smallest element in a range (function template) | |
| returns the smaller and larger of two elements (function template) | |
| returns the smallest and the largest elements in a range (function template) | |
| returns true if one range is lexicographically less than another (function template) | |
| determines if a sequence is a permutation of another sequence (function template) | |
| generates the next greater lexicographic permutation of a range of elements (function template) | |
| generates the next smaller lexicographic permutation of a range of elements (function template) | |


