Linux Manuals session 3

std::experimental::ranges::SignedIntegral – std::experimental::ranges::SignedIntegral Synopsis Defined in header <experimental/ranges/concepts> template < class T > (ranges TS) concept bool SignedIntegral = Integral<T> && std::is_signed<T>::value; The concept SignedIntegral<T> is satisfied if and only if T is an integral type and std::is_signed<T>::value is true. There need not be any subsumption relationship between SignedIntegral<T> and std::is_signed<T>::value. Notes SignedIntegral<T> may be…

std::experimental::ranges::Sentinel – std::experimental::ranges::Sentinel Synopsis Defined in header <experimental/ranges/iterator> template < class S, class I > concept bool Sentinel = (ranges TS) Semiregular<S> && Iterator<I> && WeaklyEqualityComparableWith<S, I>; The Sentinel concept specifies the relationship between an Iterator type and a Semiregular type whose values denote a range. Let s and i be values of type S…

std::experimental::ranges::Semiregular – std::experimental::ranges::Semiregular Synopsis Defined in header <experimental/ranges/concepts> template <class T> (ranges TS) concept bool Semiregular = Copyable<T> && DefaultConstructible<T>; The Semiregular concept specifies that a type is both copyable and default constructible. It is satisfied by types that behave similarly to built-in types like int, except that they need not support comparison with ==.

std::experimental::ranges::Same – std::experimental::ranges::Same Synopsis Defined in header <experimental/ranges/concepts> template < class T, class U > (ranges TS) concept bool Same = std::is_same<T, U>::value; // see below The concept Same<T, U> is satisfied if and only if T and U denote the same type. Despite being specified using it, there need not be any subsumption relationship…

std::experimental::ranges::Relation – std::experimental::ranges::Relation Synopsis Defined in header<experimental / ranges / concepts> template <class R, class T, class U> concept bool Relation = Predicate<R, T, T> && Predicate<R, U, U> && CommonReference< const std::remove_reference_t<T> &, const std::remove_reference_t<U> &> && Predicate<R, (1)(ranges TS) ranges::common_reference_t< const std::remove_reference_t<T> &, const std::remove_reference_t<U> &>, ranges::common_reference_t< const std::remove_reference_t<T> &, const std::remove_reference_t<U> &>>…

std::experimental::ranges::Regular – std::experimental::ranges::Regular Synopsis Defined in header <experimental/ranges/concepts> template <class T> (ranges TS) concept bool Regular = Semiregular<T> && EqualityComparable<T>; The Regular concept specifies that a type is regular, that is, it is copyable, default constructible, and equality comparable. It is satisfied by types that behave similarly to built-in types like int, and that are…

std::experimental::ranges::Readable – std::experimental::ranges::Readable Synopsis Defined in header<experimental / ranges / iterator> template <class In> concept bool Readable = requires { typename ranges::value_type_t<In>; typename ranges::reference_t<In>; (ranges TS) typename ranges::rvalue_reference_t<In>; } && CommonReference<ranges::reference_t<In> &&, ranges::value_type_t<In> &> && CommonReference<ranges::reference_t<In> &&, ranges::rvalue_reference_t<In> &&> && CommonReference<ranges::rvalue_reference_t<In> &&, const ranges::value_type_t<In> &>; The concept Readable is satisfied by types that are readable…

std::experimental::ranges::Range – std::experimental::ranges::Range Synopsis Defined in header <experimental/ranges/range> template < class T > concept bool Range = requires(T&& t) { (ranges TS) ranges::begin(t); /* not necessarily equality-preserving (see below) */ ranges::end(t); }; Given an lvalue t of type std::remove_reference_t<T>, Range<T> is satisfied only if * [ranges::begin(t), ranges::end(t)) denotes a range; and * both ranges::begin(t) and…

std::experimental::ranges::RandomAccessRange – std::experimental::ranges::RandomAccessRange Synopsis Defined in header <experimental/ranges/range> template <class T> concept bool RandomAccessRange = (ranges TS) BidirectionalRange<T> && RandomAccessIterator<ranges::iterator_t<T>>;  This section is incomplete  Reason: add description and extra caveats

std::experimental::ranges::RandomAccessIterator – std::experimental::ranges::RandomAccessIterator Synopsis Defined in header<experimental / ranges / iterator> template <class I> concept bool RandomAccessIterator = BidirectionalIterator<I> && DerivedFrom<ranges::iterator_category_t<I>, ranges::random_access_iterator_tag> && StrictTotallyOrdered<I> && SizedSentinel<I, I> && requires(I i, const I j, const ranges::difference_type_t<I> n) { { i += n } -> Same<I> &; (ranges TS) { j + n } -> Same<I> &&;…

std::experimental::ranges::Predicate – std::experimental::ranges::Predicate Synopsis Defined in header <experimental/ranges/concepts> template < class F, class… Args > concept bool Predicate = (ranges TS) RegularInvocable<F, Args…> && Boolean<std::result_of_t<F&&(Args&&…)>>; The concept Predicate<F, Args…> specifies that F is a predicate that accepts arguments whose types and value categories are encoded by Args…, i.e., it can be invoked with these arguments…

std::experimental::ranges::Permutable – std::experimental::ranges::Permutable Synopsis template <class I> concept bool Permutable = ForwardIterator<I> && (ranges TS) IndirectlyMovableStorable<I, I> && IndirectlySwappable<I, I>; The Permutable concept specifies the common requirements of algorithms that reorder elements in place by moving or swapping them (for example, ranges::rotate).

std::experimental::ranges::OutputRange – std::experimental::ranges::OutputRange Synopsis Defined in header <experimental/ranges/range> template <class R, class T> concept bool OutputRange = (ranges TS) Range<R> && OutputIterator<ranges::iterator_t<R>, T>;  This section is incomplete  Reason: add description and extra caveats

std::experimental::ranges::OutputIterator – std::experimental::ranges::OutputIterator Synopsis Defined in header <experimental/ranges/iterator> template <class I, class T> concept bool OutputIterator = Iterator<I> && Writable<I, T> && (ranges TS) requires(I i, T&& t) { *i++ = std::forward<T>(t); // not required to be equality preserving }; The OutputIterator concept is a refinement of Iterator, adding the requirement that it can be…

std::experimental::ranges::MoveConstructible – std::experimental::ranges::MoveConstructible Synopsis Defined in header <experimental/ranges/concepts> template < class T > concept bool MoveConstructible = (ranges TS) Constructible<T, T> && ConvertibleTo<T, T>; The concept MoveConstructible is satisfied if T is a reference type, or if it is an object type where an object of that type can constructed from an rvalue of that…

std::experimental::ranges::Movable – std::experimental::ranges::Movable Synopsis Defined in header <experimental/ranges/concepts> template < class T > concept bool Movable = std::is_object<T>::value && (ranges TS) MoveConstructible<T> && Assignable<T&, T> && Swappable<T>; The concept Movable<T> specifies that T is an object type that can moved (that is, it can be move constructed, move assigned, and lvalues of type T can…

std::experimental::ranges::Mergeable – std::experimental::ranges::Mergeable Synopsis template < class I1, class I2, class Out, class R = ranges::less<>, class P1 = ranges::identity, class P2 = ranges::identity > concept bool Mergeable = InputIterator<I1> && InputIterator<I2> && (ranges TS) WeaklyIncrementable<Out> && IndirectlyCopyable<I1, Out> && IndirectlyCopyable<I2, Out> && IndirectStrictWeakOrder<R, ranges::projected<I1, P1>, ranges::projected<I2, P2>>; The Mergeable concept specifies the common requirements…

std::experimental::ranges::Iterator – std::experimental::ranges::Iterator Synopsis Defined in header <experimental/ranges/iterator> template <class I> concept bool Iterator = requires(I i) { (ranges TS) { *i } -> auto&&; // Requires: i is dereferenceable } && WeaklyIncrementable<I>; The Iterator concept forms the basis of the iterator concept taxonomy; every iterator satisfies the Iterator requirements. Equality preservation An expression is…

std::experimental::ranges::Invocable,std::experimental::ranges::RegularInvocable – std::experimental::ranges::Invocable,std::experimental::ranges::RegularInvocable Synopsis Defined in header <experimental/ranges/concepts> template < class F, class… Args > concept bool Invocable = requires(F&& f, Args&&… args) { (ranges TS) ranges::invoke(std::forward<F>(f), std::forward<Args>(args)…); /* not required to be equality preserving */ }; template < class F, class… Args > (ranges TS) concept bool RegularInvocable = Invocable<F, Args…>; The Invocable concept…

std::experimental::ranges::Integral – std::experimental::ranges::Integral Synopsis Defined in header <experimental/ranges/concepts> template < class T > (ranges TS) concept bool Integral = std::is_integral<T>::value; The concept Integral<T> is satisfied if and only if T is an integral type. There need not be any subsumption relationship between Integral<T> and std::is_integral<T>::value. See also is_integral checks if a type is an integral…