Linux Manuals session 3

std::experimental::ranges::input_iterator_tag, – std::experimental::ranges::input_iterator_tag, Synopsis             std::experimental::ranges::forward_iterator_tag,          std::experimental::ranges::bidirectional_iterator_tag,          std::experimental::ranges::random_access_iterator_tag Defined in header<experimental / ranges / iterator> struct input_iterator_tag { }; struct output_iterator_tag { }; struct forward_iterator_tag : public input_iterator_tag { }; struct bidirectional_iterator_tag : public forward_iterator_tag { }; struct random_access_iterator_tag : public bidirectional_iterator_tag { }; Defines the category of an iterator. Each tag is an empty type…

std::experimental::ranges::indirect_result_of – std::experimental::ranges::indirect_result_of Synopsis Defined in header<experimental / ranges / iterator> template <class> struct indirect_result_of { }; template <class F, class… Is> (ranges TS) requires Invocable<F, ranges::reference_t<Is>…> struct indirect_result_of<F(Is…)> : std::result_of<F(ranges::reference_t<Is> &&…)> { };

std::experimental::ranges::identity – std::experimental::ranges::identity Synopsis Defined in header <experimental/ranges/functional> struct identity; (ranges TS) ranges::identity is a function object type whose operator() returns its argument unchanged. It is used as the default projection for all Ranges TS algorithms. Member types Member type Definition is_transparent /* unspecified */ Member functions            returns the argument unchanged operator() (public member function)…

std::experimental::ranges::greater_equal – std::experimental::ranges::greater_equal Synopsis Defined in header<experimental / ranges / functional> template <class T = void> requires StrictTotallyOrdered<T> || Same<T, void> ||(ranges TS) /* < on two const T lvalues invokes a built-in operator comparing pointers */ struct greater_equal; template <> (ranges TS) struct greater_equal<void>; Function object for performing comparisons. The primary template invokes operator<…

std::experimental::ranges::greater – std::experimental::ranges::greater Synopsis Defined in header<experimental / ranges / functional> template <class T = void> requires StrictTotallyOrdered<T> || Same<T, void> ||(ranges TS) /* < on two const T lvalues invokes a built-in operator comparing pointers */ struct greater; template <> (ranges TS) struct greater<void>; Function object for performing comparisons. The primary template invokes operator<…

std::experimental::ranges::for_each – std::experimental::ranges::for_each Synopsis Defined in header <experimental/ranges/algorithm> template< InputIterator I, Sentinel<I> S, class Proj = ranges::identity, IndirectUnaryInvocable<projected<I, Proj>> Fun > (1) (ranges TS) ranges::tagged_pair<tag::in(I), tag::fun(Fun)> for_each(I first, S last, Fun f, Proj proj = Proj{}); template< InputRange R, class Proj = ranges::identity, IndirectUnaryInvocable<projected<ranges::iterator_t<R>, Proj>> Fun > (2) (ranges TS) ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>), tag::fun(Fun)> for_each(R&& r, Fun…

std::experimental::ranges::find_first_of – std::experimental::ranges::find_first_of Synopsis Defined in header <experimental/ranges/algorithm> template< InputIterator I1, Sentinel<I1> S1, ForwardIterator I2, Sentinel<I2> S2, class Proj1 = ranges::identity, class Proj2 = ranges::identity, IndirectRelation<projected<I1, Proj1>, (1) (ranges TS) projected<I2, Proj2>> Pred = ranges::equal_to<> > I1 find_first_of(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred{}, Proj1 proj1 = Proj1{}, Proj2 proj2…

std::experimental::ranges::find_end – std::experimental::ranges::find_end Synopsis Defined in header <experimental/ranges/algorithm> template< ForwardIterator I1, Sentinel<I1> S1, ForwardIterator I2, Sentinel<I2> S2, class Proj = ranges::identity, IndirectRelation<I2, projected<I1, Proj>> Pred = ranges::equal_to<> > (1) (ranges TS) I1 find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred{}, Proj proj = Proj{}); template< ForwardRange R1, ForwardRange R2, class Proj…

std::experimental::ranges::find,std::experimental::ranges::find_if,std::experimental::ranges::find_if_not – std::experimental::ranges::find,std::experimental::ranges::find_if,std::experimental::ranges::find_if_not Synopsis Defined in header<experimental / ranges / algorithm> template <InputIterator I, Sentinel<I> S, class T, class Proj = ranges::identity> requires IndirectRelation < ranges::equal_to<>, projected<I, Proj>, const T * > (1)(ranges TS) I find(I first, S last, const T &value, Proj proj = Proj{}); template <InputRange R, class T, class Proj = ranges::identity>…

std::experimental::ranges::find,std::experimental::ranges::find_if, – std::experimental::ranges::find,std::experimental::ranges::find_if, Synopsis Defined in header <experimental/ranges/algorithm> template< InputIterator I, Sentinel<I> S, class T, class Proj = ranges::identity > requires IndirectRelation<ranges::equal_to<>, projected<I, Proj>,    (1) (ranges TS) const T*> I find(I first, S last, const T &value, Proj proj = Proj{}); template <InputRange R, class T, class Proj = ranges::identity> requires IndirectRelation<ranges::equal_to<>, projected<ranges::iterator_t<R>, Proj>, const T*>                    (2) (ranges TS)…

std::experimental::ranges::exchange – std::experimental::ranges::exchange Synopsis Defined in header <experimental/ranges/utility> template< MoveConstructible T, class U = T > requires Assignable<T&, U> (ranges TS) constexpr T exchange(T& obj, U&& new_val) noexcept(/* see below */); Replaces the value of obj with new_value and returns the old value of obj, as if by T old_value = std::move(obj); obj = std::forward<U>(new_value);…

std::experimental::ranges::equal_to – std::experimental::ranges::equal_to Synopsis Defined in header<experimental / ranges / functional> template <class T = void> requires EqualityComparable<T> || Same<T, void> ||(ranges TS) /* == on two const T lvalues invokes a built-in operator comparing pointers */ struct equal_to; template <> (ranges TS) struct equal_to<void>; Function object for performing comparisons. The primary template invokes operator…

std::experimental::ranges::equal – std::experimental::ranges::equal Synopsis Defined in header<experimental / ranges / algorithm> template <InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2, class Pred = ranges::equal_to<>, class Proj1 = ranges::identity, class Proj2 = ranges::identity> (1)(ranges TS) requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2> bool equal(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred{}, Proj1 proj1…

std::experimental::ranges::distance – std::experimental::ranges::distance Synopsis Defined in header<experimental / ranges / iterator> namespace { (ranges TS) constexpr /* unspecified */ distance = /* unspecified */; (customization point object) } Call signature template <Iterator I, Sentinel<I> S> (1) constexpr ranges::difference_type_t<I> distance(I first, S last); template <Range R> (2) constexpr ranges::difference_type_t<ranges::iterator_t<R>> distance(R &&r); template <SizedRange R> (3) constexpr…

std::experimental::ranges::difference_type – std::experimental::ranges::difference_type Synopsis Defined in header<experimental / ranges / iterator> template <class I> (1) struct difference_type { }; template <class T> (2) struct difference_type<T *>; template <class T> (3) struct difference_type<const T> : difference_type<std::decay_t<T>> { }; template <class T> requires requires { typename T::difference_type; } (4) struct difference_type<T>; template <class T> requires !requires {…

std::experimental::ranges::dangling,std::experimental::ranges::safe_iterator_t – std::experimental::ranges::dangling,std::experimental::ranges::safe_iterator_t Synopsis Defined in header<experimental / ranges / iterator> template <CopyConstructible T> class dangling { public: dangling() requires DefaultConstructible<T>(); (ranges TS) dangling(T t); T get_unsafe() const; }; template <Range R> using safe_iterator_t = std::conditional_t < std::is_lvalue_reference<R>::value, (ranges TS) ranges::iterator_t<R>, ranges::dangling<ranges::iterator_t<R>>; The class template dangling is a simple wrapper around an object to indicate…

std::experimental::ranges::count,std::experimental::ranges::count_if – std::experimental::ranges::count,std::experimental::ranges::count_if Synopsis Defined in header<experimental / ranges / algorithm> template <InputIterator I, Sentinel<I> S, class T, class Proj = ranges::identity> requires IndirectRelation < ranges::equal_to<>, projected<I, Proj>, const T * > (1)(ranges TS) ranges::difference_type_t<I> count(I first, S last, const T &value, Proj proj = Proj{}); template <InputRange R, class T, class Proj = ranges::identity>…

std::experimental::ranges::copy,std::experimental::ranges::copy_if – std::experimental::ranges::copy,std::experimental::ranges::copy_if Synopsis Defined in header<experimental / ranges / algorithm> template <InputIterator I, Sentinel<I> S, WeaklyIncrementable O> requires IndirectlyCopyable<I, O>(1) (ranges TS) ranges::tagged_pair<tag::in(I), tag::out(O)> copy(I first, S last, O result); template <InputRange R, WeaklyIncrementable O> requires IndirectlyCopyable<ranges::iterator_t<R>, O>(2) (ranges TS) ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>), tag::out(O)> copy(R &&r, O result); template <InputIterator I, Sentinel<I> S, WeaklyIncrementable O, class…

std::experimental::ranges::common_type – std::experimental::ranges::common_type Synopsis Defined in header<experimental / ranges / type_traits> template <class… T> (ranges TS) struct common_type; Determines the common type among all types T…, that is the type all T… can be implicitly converted to. If such a type exists (as determined according to the rules below), the member type names that type….

std::experimental::ranges::common_reference – std::experimental::ranges::common_reference Synopsis Defined in header<experimental / ranges / type_traits> template <class… T> (ranges TS) struct common_reference; Determines the common reference type of the types T…, that is, the type to which all the types in T… can be converted or bound. If such a type exists (as determined according to the rules below),…