Concepts

Description

Concept-checking classes and utilities.

Classes
struct	ranges::concepts::InsertableRange
struct	ranges::v3::concepts::Assignable
struct	ranges::v3::concepts::BidirectionalIterator
struct	ranges::v3::concepts::BidirectionalRange
struct	ranges::v3::concepts::BoundedRange
struct	ranges::v3::concepts::Callable
struct	ranges::v3::concepts::CallablePredicate
struct	ranges::v3::concepts::CallableRelation
struct	ranges::v3::concepts::Common
struct	ranges::v3::concepts::CommonReference
struct	ranges::v3::concepts::Constructible
struct	ranges::v3::concepts::Container
struct	ranges::v3::concepts::ContainerLike_
	INTERNAL ONLY A type is ContainerLike_ if it is Range and the const-ness of its reference type is sensitive to the const-ness of the Container. More...
struct	ranges::v3::concepts::ConvertibleTo
struct	ranges::v3::concepts::Copyable
struct	ranges::v3::concepts::CopyConstructible
struct	ranges::v3::concepts::DefaultConstructible
struct	ranges::v3::concepts::DerivedFrom
struct	ranges::v3::concepts::Destructible
struct	ranges::v3::concepts::EqualityComparable
struct	ranges::v3::concepts::ErasableRange
struct	ranges::v3::concepts::ForwardIterator
struct	ranges::v3::concepts::ForwardRange
struct	ranges::v3::concepts::Function
struct	ranges::v3::concepts::Incrementable
struct	ranges::v3::concepts::IndirectlyCopyable
struct	ranges::v3::concepts::IndirectlyCopyableStorable
struct	ranges::v3::concepts::IndirectlyMovable
struct	ranges::v3::concepts::IndirectlyMovableStorable
struct	ranges::v3::concepts::IndirectlySwappable
struct	ranges::v3::concepts::InputIterator
struct	ranges::v3::concepts::InputRange
struct	ranges::v3::concepts::Integral
struct	ranges::v3::concepts::Iterator
struct	ranges::v3::concepts::LvalueContainerLike
struct	ranges::v3::concepts::models< Concept, Ts >
struct	ranges::v3::concepts::models< Concept(Args...), Ts... >
struct	ranges::v3::concepts::most_refined< Concepts, Ts >
struct	ranges::v3::concepts::Movable
struct	ranges::v3::concepts::MoveConstructible
struct	ranges::v3::concepts::OutputRange
struct	ranges::v3::concepts::Predicate
struct	ranges::v3::concepts::RandomAccessIterator
struct	ranges::v3::concepts::RandomAccessRange
struct	ranges::v3::concepts::Range
	Range concepts below. More...
struct	ranges::v3::concepts::Readable
struct	ranges::v3::concepts::refines< Concepts >
struct	ranges::v3::concepts::Regular
struct	ranges::v3::concepts::RegularFunction
struct	ranges::v3::concepts::Relation
struct	ranges::v3::concepts::Reservable
struct	ranges::v3::concepts::ReserveAndAssignable
struct	ranges::v3::concepts::Same
struct	ranges::v3::concepts::Same::same< Ts >
struct	ranges::v3::concepts::Same::same< T, Us... >
struct	ranges::v3::concepts::SemiContainer
struct	ranges::v3::concepts::SemiRegular
struct	ranges::v3::concepts::SignedIntegral
struct	ranges::v3::concepts::SizedRange
struct	ranges::v3::concepts::SizedSentinel
struct	ranges::v3::concepts::Swappable
struct	ranges::v3::concepts::TotallyOrdered
struct	ranges::v3::concepts::UniformRandomNumberGenerator
struct	ranges::v3::concepts::UnsignedIntegral
struct	ranges::v3::concepts::View
	View concepts below. More...
struct	ranges::v3::concepts::WeaklyEqualityComparable
struct	ranges::v3::concepts::WeaklyIncrementable
struct	ranges::v3::concepts::WeaklyOrdered
struct	ranges::v3::concepts::Writable
struct	ranges::v3::difference_type< T, Enable >
struct	ranges::v3::difference_type< T * >
struct	ranges::v3::difference_type< T const >
struct	ranges::v3::difference_type< T, meta::void_< typename T::difference_type > >
struct	ranges::v3::disable_sized_range< T >
struct	ranges::v3::disable_sized_sentinel< S, I >
struct	ranges::v3::is_view< T, Enable >
struct	ranges::v3::is_view< std::initializer_list< T > >
struct	ranges::v3::is_view< std::multiset< Key, Compare, Alloc > >
struct	ranges::v3::is_view< std::set< Key, Compare, Alloc > >
struct	ranges::v3::is_view< std::unordered_multiset< Key, Hash, Pred, Alloc > >
struct	ranges::v3::is_view< std::unordered_set< Key, Hash, Pred, Alloc > >
struct	ranges::v3::iterator_category< T, typename >
struct	ranges::v3::iterator_category< T * >
struct	ranges::v3::iterator_category< T const >
struct	ranges::v3::iterator_category< T const volatile >
struct	ranges::v3::iterator_category< T volatile >
struct	ranges::v3::iterator_category< T, meta::void_< typename T::iterator_category > >
struct	ranges::v3::size_type< T >
struct	ranges::v3::value_type< T, Enable >
struct	ranges::v3::value_type< T * >
struct	ranges::v3::value_type< T const >
struct	ranges::v3::value_type< T const volatile >
struct	ranges::v3::value_type< T volatile >
struct	ranges::v3::value_type< T, meta::if_< std::is_array< T > > >
struct	ranges::v3::value_type< T, meta::if_< std::is_base_of< std::ios_base, T > > >
struct	ranges::v3::value_type< T, meta::void_< typename T::element_type > >
struct	ranges::v3::value_type< T, meta::void_< typename T::value_type > >

Macros
#define	CONCEPT_ASSERT(...)   static_assert((__VA_ARGS__), "Concept check failed: " #__VA_ARGS__)
#define	CONCEPT_REQUIRES(...)
#define	CONCEPT_REQUIRES_(...)

Typedefs
using	ranges::v3::concepts::_1 = std::integral_constant< int, 0 >
using	ranges::v3::concepts::_2 = std::integral_constant< int, 1 >
using	ranges::v3::concepts::_3 = std::integral_constant< int, 2 >
using	ranges::v3::concepts::_4 = std::integral_constant< int, 3 >
using	ranges::v3::concepts::_5 = std::integral_constant< int, 4 >
using	ranges::v3::concepts::_6 = std::integral_constant< int, 5 >
using	ranges::v3::concepts::_7 = std::integral_constant< int, 6 >
using	ranges::v3::concepts::_8 = std::integral_constant< int, 7 >
using	ranges::v3::concepts::_9 = std::integral_constant< int, 8 >
template<typename T , typename U >
using	ranges::v3::Assignable = concepts::models< concepts::Assignable, T, U >
template<typename I1 , typename I2 , typename C = equal_to, typename P1 = ident, typename P2 = ident>
using	ranges::v3::AsymmetricallyComparable = meta::strict_and< InputIterator< I1 >, InputIterator< I2 >, IndirectCallablePredicate< C, projected< I1, P1 >, projected< I2, P2 >>>
using	ranges::v3::concepts::refines< Concepts >::base_concepts_t = meta::list< Concepts... >
template<typename I >
using	ranges::v3::BidirectionalIterator = concepts::models< concepts::BidirectionalIterator, I >
template<typename T >
using	ranges::v3::BidirectionalRange = concepts::models< concepts::BidirectionalRange, T >
template<typename T >
using	ranges::v3::BidirectionalView = concepts::models< concepts::BidirectionalView, T >
template<typename I , typename V2 , typename C = ordered_less, typename P = ident>
using	ranges::v3::BinarySearchable = meta::strict_and< ForwardIterator< I >, IndirectCallableRelation< C, projected< I, P >, V2 const * >>
template<typename T >
using	ranges::v3::bounded_range_concept = concepts::most_refined< meta::list< concepts::BoundedRange, concepts::Range >, T >
template<typename T >
using	ranges::v3::bounded_range_concept_t = meta::_t< bounded_range_concept< T >>
template<typename T >
using	ranges::v3::bounded_view_concept = concepts::most_refined< meta::list< concepts::BoundedView, concepts::View >, T >
template<typename T >
using	ranges::v3::bounded_view_concept_t = meta::_t< bounded_view_concept< T >>
template<typename T >
using	ranges::v3::BoundedRange = concepts::models< concepts::BoundedRange, T >
template<typename T >
using	ranges::v3::BoundedView = concepts::models< concepts::BoundedView, T >
template<typename Fun , typename... Args>
using	ranges::v3::Callable = concepts::models< concepts::Callable, Fun, Args... >
template<typename Fun , typename... Args>
using	ranges::v3::CallablePredicate = concepts::models< concepts::CallablePredicate, Fun, Args... >
template<typename Fun , typename T , typename U = T>
using	ranges::v3::CallableRelation = concepts::models< concepts::CallableRelation, Fun, T, U >
template<typename T , typename U , typename... Rest>
using	ranges::v3::Common = meta::or_< meta::strict_and< std::is_void< T >, std::is_void< U >, std::is_void< Rest >... >, concepts::models< concepts::Common, T, U, Rest... >>
template<typename T , typename U , typename... Rest>
using	ranges::v3::CommonReference = meta::or_< meta::strict_and< std::is_void< T >, std::is_void< U >, std::is_void< Rest >... >, concepts::models< concepts::CommonReference, T, U, Rest... >>
template<typename I1 , typename I2 , typename C = equal_to, typename P1 = ident, typename P2 = ident>
using	ranges::v3::Comparable = meta::strict_and< AsymmetricallyComparable< I1, I2, C, P1, P2 >, IndirectCallableRelation< C, projected< I1, P1 >, projected< I2, P2 >>>
template<typename T , typename... Args>
using	ranges::v3::Constructible = concepts::models< concepts::Constructible, T, Args... >
template<typename T >
using	ranges::v3::Container = concepts::models< concepts::Container, T >
template<typename T >
using	ranges::v3::ContainerLike_ = concepts::models< concepts::ContainerLike_, T >
	INTERNAL ONLY.
template<typename T , typename U >
using	ranges::v3::ConvertibleTo = concepts::models< concepts::ConvertibleTo, T, U >
template<typename T >
using	ranges::v3::Copyable = concepts::models< concepts::Copyable, T >
template<typename T >
using	ranges::v3::CopyConstructible = concepts::models< concepts::CopyConstructible, T >
template<typename T >
using	ranges::v3::DefaultConstructible = concepts::models< concepts::DefaultConstructible, T >
template<typename T , typename U >
using	ranges::v3::DerivedFrom = concepts::models< concepts::DerivedFrom, T, U >
template<typename T >
using	ranges::v3::Destructible = concepts::models< concepts::Destructible, T >
template<typename T , typename U = T>
using	ranges::v3::EqualityComparable = concepts::models< concepts::EqualityComparable, T, U >
template<typename Rng , typename... Rest>
using	ranges::v3::ErasableRange = concepts::models< concepts::ErasableRange, Rng, Rest... >
template<typename I , typename T >
using	ranges::v3::ExclusivelyWritable_ = meta::invoke< detail::exclusively_writable_< I >, T >
template<typename T , typename U >
using	ranges::v3::ExplicitlyConvertibleTo = concepts::models< concepts::ExplicitlyConvertibleTo, T, U >
template<typename I >
using	ranges::v3::ForwardIterator = concepts::models< concepts::ForwardIterator, I >
template<typename T >
using	ranges::v3::ForwardRange = concepts::models< concepts::ForwardRange, T >
template<typename T >
using	ranges::v3::ForwardView = concepts::models< concepts::ForwardView, T >
template<typename Fun , typename... Args>
using	ranges::v3::Function = concepts::models< concepts::Function, Fun, Args... >
template<typename T , typename U >
using	ranges::v3::ImplicitlyConvertibleTo = concepts::models< concepts::ImplicitlyConvertibleTo, T, U >
template<typename T >
using	ranges::v3::Incrementable = concepts::models< concepts::Incrementable, T >
template<typename C , typename... Is>
using	ranges::v3::IndirectCallable = IndirectFunction< function_type< C >, Is... >
template<typename C , typename... Is>
using	ranges::v3::IndirectCallablePredicate = IndirectPredicate< function_type< C >, Is... >
template<typename C , typename I0 , typename I1 = I0>
using	ranges::v3::IndirectCallableRelation = IndirectRelation< function_type< C >, I0, I1 >
template<typename C , typename... Is>
using	ranges::v3::IndirectFunction = meta::and_< meta::strict_and< Readable< Is >... >, meta::lazy::invoke< detail::iter_map_reduce_fn_< meta::bind_front< meta::quote< Function >, C >, meta::quote< meta::strict_and >>, Is... >, meta::lazy::invoke< detail::iter_map_reduce_fn_< meta::bind_front< meta::quote< concepts::Function::result_t >, C >, meta::quote< CommonReference >>, Is... > >
template<typename I , typename O >
using	ranges::v3::IndirectlyCopyable = concepts::models< concepts::IndirectlyCopyable, I, O >
template<typename I , typename O >
using	ranges::v3::IndirectlyCopyableStorable = concepts::models< concepts::IndirectlyCopyableStorable, I, O >
template<typename I , typename O >
using	ranges::v3::IndirectlyMovable = concepts::models< concepts::IndirectlyMovable, I, O >
template<typename I , typename O >
using	ranges::v3::IndirectlyMovableStorable = concepts::models< concepts::IndirectlyMovableStorable, I, O >
template<typename I1 , typename I2 >
using	ranges::v3::IndirectlySwappable = concepts::models< concepts::IndirectlySwappable, I1, I2 >
template<typename C , typename... Is>
using	ranges::v3::IndirectPredicate = meta::and_< meta::strict_and< Readable< Is >... >, meta::lazy::invoke< detail::iter_map_reduce_fn_< meta::bind_front< meta::quote< Predicate >, C >, meta::quote< meta::strict_and >>, Is... >>
template<typename C , typename I0 , typename I1 = I0>
using	ranges::v3::IndirectRelation = meta::and_< meta::strict_and< Readable< I0 >, Readable< I1 >>, meta::lazy::invoke< detail::iter_map_reduce_fn_< meta::bind_front< meta::quote< Relation >, C >, meta::quote< meta::strict_and >>, I0, I1 >>
template<typename I >
using	ranges::v3::InputIterator = concepts::models< concepts::InputIterator, I >
template<typename T >
using	ranges::v3::InputRange = concepts::models< concepts::InputRange, T >
template<typename T >
using	ranges::v3::InputView = concepts::models< concepts::InputView, T >
template<typename Rng , typename... Rest>
using	ranges::InsertableRange = concepts::models< concepts::InsertableRange, Rng, Rest... >
template<typename T >
using	ranges::v3::Integral = concepts::models< concepts::Integral, T >
template<typename I , typename C = ordered_less, typename P = ident>
using	ranges::v3::IsHeapable = meta::strict_and< RandomAccessIterator< I >, IndirectCallableRelation< C, projected< I, P >>>
template<typename I , typename C , typename P = ident>
using	ranges::v3::IsPartitionedable = meta::strict_and< InputIterator< I >, IndirectCallablePredicate< C, projected< I, P >>>
template<typename I1 , typename I2 , typename C = equal_to, typename P1 = ident, typename P2 = ident>
using	ranges::v3::IsPermutationable = meta::strict_and< ForwardIterator< I1 >, ForwardIterator< I2 >, Comparable< I1, I2, C, P1, P2 >>
template<typename I >
using	ranges::v3::Iterator = concepts::models< concepts::Iterator, I >
template<typename T >
using	ranges::v3::iterator_concept = concepts::most_refined< meta::list< concepts::RandomAccessIterator, concepts::BidirectionalIterator, concepts::ForwardIterator, concepts::InputIterator >, T >
template<typename T >
using	ranges::v3::iterator_concept_t = meta::_t< iterator_concept< T >>
template<typename I , typename S >
using	ranges::v3::IteratorRange = Sentinel< S, I >
template<typename T >
using	ranges::v3::LvalueContainerLike = concepts::models< concepts::LvalueContainerLike, T >
template<typename I0 , typename I1 , typename Out , typename C = ordered_less, typename P0 = ident, typename P1 = ident>
using	ranges::v3::Mergeable = meta::strict_and< InputIterator< I0 >, InputIterator< I1 >, WeaklyIncrementable< Out >, IndirectCallableRelation< C, projected< I0, P0 >, projected< I1, P1 >>, IndirectlyCopyable< I0, Out >, IndirectlyCopyable< I1, Out >>
template<typename I1 , typename I2 , typename C = equal_to, typename P1 = ident, typename P2 = ident>
using	ranges::v3::Mismatchable = meta::strict_and< InputIterator< I1 >, InputIterator< I2 >, IndirectCallablePredicate< C, projected< I1, P1 >, projected< I2, P2 >>>
template<typename Concepts , typename... Ts>
using	ranges::v3::concepts::most_refined_t = meta::_t< most_refined< Concepts, Ts... >>
template<typename T >
using	ranges::v3::Movable = concepts::models< concepts::Movable, T >
template<typename T >
using	ranges::v3::MoveConstructible = concepts::models< concepts::MoveConstructible, T >
template<typename I0 , typename I1 , typename Out , typename C = ordered_less, typename P0 = ident, typename P1 = ident>
using	ranges::v3::MoveMergeable = meta::strict_and< InputIterator< I0 >, InputIterator< I1 >, WeaklyIncrementable< Out >, IndirectCallableRelation< C, projected< I0, P0 >, projected< I1, P1 >>, IndirectlyMovable< I0, Out >, IndirectlyMovable< I1, Out >>
template<typename Out , typename T >
using	ranges::v3::OutputIterator = concepts::models< concepts::OutputIterator, Out, T >
template<typename T , typename V >
using	ranges::v3::OutputRange = concepts::models< concepts::OutputRange, T, V >
template<typename T , typename V >
using	ranges::v3::OutputView = concepts::models< concepts::OutputView, T, V >
template<typename I , typename O , typename C = ordered_less, typename PI = ident, typename PO = ident>
using	ranges::v3::PartialSortCopyConcept = meta::strict_and< InputIterator< I >, RandomAccessIterator< O >, IndirectlyCopyable< I, O >, IndirectCallableRelation< C, projected< I, PI >, projected< O, PO >>, Sortable< O, C, PO >>
template<typename I , typename C , typename P = ident>
using	ranges::v3::Partitionable = meta::strict_and< ForwardIterator< I >, Permutable< I >, IndirectCallablePredicate< C, projected< I, P >>>
template<typename I , typename O0 , typename O1 , typename C , typename P = ident>
using	ranges::v3::PartitionCopyable = meta::strict_and< InputIterator< I >, WeaklyIncrementable< O0 >, WeaklyIncrementable< O1 >, IndirectlyCopyable< I, O0 >, IndirectlyCopyable< I, O1 >, IndirectCallablePredicate< C, projected< I, P >>>
template<typename I , typename V = concepts::Readable::value_t<I>>
using	ranges::v3::Permutable = meta::strict_and< ForwardIterator< I >, IndirectlySwappable< I, I >, IndirectlyMovableStorable< I, I >>
template<typename Fun , typename... Args>
using	ranges::v3::Predicate = concepts::models< concepts::Predicate, Fun, Args... >
template<typename I , typename Proj >
using	ranges::v3::projected = meta::if_c< IndirectCallable< Proj, I >::value, detail::projected_< I, Proj >>
template<typename I >
using	ranges::v3::RandomAccessIterator = concepts::models< concepts::RandomAccessIterator, I >
template<typename T >
using	ranges::v3::RandomAccessRange = concepts::models< concepts::RandomAccessRange, T >
template<typename C >
using	ranges::v3::RandomAccessReservable = meta::strict_and< Reservable< C >, RandomAccessRange< C >>
template<typename T >
using	ranges::v3::RandomAccessView = concepts::models< concepts::RandomAccessView, T >
template<typename T >
using	ranges::v3::Range = concepts::models< concepts::Range, T >
template<typename T >
using	ranges::v3::range_concept = concepts::most_refined< meta::list< concepts::RandomAccessRange, concepts::BidirectionalRange, concepts::ForwardRange, concepts::InputRange >, T >
template<typename T >
using	ranges::v3::range_concept_t = meta::_t< range_concept< T >>
template<typename T >
using	ranges::v3::Readable = concepts::models< concepts::Readable, T >
template<typename T , typename U , typename... Rest>
using	ranges::v3::concepts::CommonReference::reference_t = common_reference_t< T, U, Rest... >
template<typename T >
using	ranges::v3::Regular = concepts::models< concepts::Regular, T >
template<typename Fun , typename... Args>
using	ranges::v3::RegularCallable = concepts::models< concepts::RegularCallable, Fun, Args... >
template<typename Fun , typename... Args>
using	ranges::v3::RegularFunction = concepts::models< concepts::RegularFunction, Fun, Args... >
template<typename Fun , typename T , typename U = T>
using	ranges::v3::Relation = concepts::models< concepts::Relation, Fun, T, U >
template<typename I , typename T , typename P = ident>
using	ranges::v3::Removable = meta::strict_and< ForwardIterator< I >, IndirectCallableRelation< equal_to, projected< I, P >, T const * >, Permutable< I >>
template<typename I , typename C , typename P = ident>
using	ranges::v3::RemovableIf = meta::strict_and< ForwardIterator< I >, IndirectCallablePredicate< C, projected< I, P >>, Permutable< I >>
template<typename I , typename O , typename T , typename P = ident>
using	ranges::v3::RemoveCopyable = meta::strict_and< InputIterator< I >, WeaklyIncrementable< O >, IndirectCallableRelation< equal_to, projected< I, P >, T const * >, IndirectlyCopyable< I, O >>
template<typename I , typename O , typename C , typename P = ident>
using	ranges::v3::RemoveCopyableIf = meta::strict_and< InputIterator< I >, WeaklyIncrementable< O >, IndirectCallablePredicate< C, projected< I, P >>, IndirectlyCopyable< I, O >>
template<typename I , typename T0 , typename T1 , typename P = ident>
using	ranges::v3::Replaceable = meta::strict_and< InputIterator< I >, IndirectCallableRelation< equal_to, projected< I, P >, T0 const * >, Writable< I, T1 const & >>
template<typename I , typename O , typename T0 , typename T1 , typename P = ident>
using	ranges::v3::ReplaceCopyable = meta::strict_and< InputIterator< I >, OutputIterator< O, T1 const & >, IndirectlyCopyable< I, O >, IndirectCallableRelation< equal_to, projected< I, P >, T0 const * >>
template<typename I , typename O , typename C , typename T , typename P = ident>
using	ranges::v3::ReplaceCopyIfable = meta::strict_and< InputIterator< I >, OutputIterator< O, T const & >, IndirectlyCopyable< I, O >, IndirectCallablePredicate< C, projected< I, P >>>
template<typename I , typename C , typename T , typename P = ident>
using	ranges::v3::ReplaceIfable = meta::strict_and< InputIterator< I >, IndirectCallablePredicate< C, projected< I, P >>, Writable< I, T const & >>
template<typename C >
using	ranges::v3::Reservable = concepts::models< concepts::Reservable, C >
template<typename C , typename I >
using	ranges::v3::ReserveAndAssignable = concepts::models< concepts::ReserveAndAssignable, C, I >
template<typename Fun , typename... Args>
using	ranges::v3::concepts::Function::result_t = decltype(val< Fun >()(val< Args >()...))
template<typename I , typename O >
using	ranges::v3::ReverseCopyable = meta::strict_and< BidirectionalIterator< I >, WeaklyIncrementable< O >, IndirectlyCopyable< I, O >>
template<typename... Ts>
using	ranges::v3::Same = concepts::Same::same_t< Ts... >
template<typename... Ts>
using	ranges::v3::concepts::Same::same_t = meta::_t< same< Ts... >>
template<typename I1 , typename I2 , typename C = equal_to, typename P1 = ident, typename P2 = ident>
using	ranges::v3::Searchable = meta::strict_and< ForwardIterator< I1 >, ForwardIterator< I2 >, Comparable< I1, I2, C, P1, P2 >>
template<typename T >
using	ranges::v3::SemiContainer = concepts::models< concepts::SemiContainer, T >
template<typename T >
using	ranges::v3::SemiRegular = concepts::models< concepts::SemiRegular, T >
template<typename S , typename I >
using	ranges::v3::Sentinel = concepts::models< concepts::Sentinel, S, I >
template<typename T >
using	ranges::v3::SignedIntegral = concepts::models< concepts::SignedIntegral, T >
template<typename I >
using	ranges::v3::SinglePass = meta::strict_and< Iterator< I >, meta::not_< ForwardIterator< I >>>
template<typename T >
using	ranges::v3::sized_range_concept = concepts::most_refined< meta::list< concepts::SizedRange, concepts::Range >, T >
template<typename T >
using	ranges::v3::sized_range_concept_t = meta::_t< sized_range_concept< T >>
template<typename S , typename I >
using	ranges::v3::sized_sentinel_concept = concepts::most_refined< meta::list< concepts::SizedSentinel, concepts::Sentinel >, S, I >
template<typename S , typename I >
using	ranges::v3::sized_sentinel_concept_t = meta::_t< sized_sentinel_concept< S, I >>
template<typename T >
using	ranges::v3::sized_view_concept = concepts::most_refined< meta::list< concepts::SizedView, concepts::View >, T >
template<typename T >
using	ranges::v3::sized_view_concept_t = meta::_t< sized_view_concept< T >>
template<typename I , typename S >
using	ranges::v3::SizedIteratorRange = SizedSentinel< S, I >
template<typename T >
using	ranges::v3::SizedRange = concepts::models< concepts::SizedRange, T >
template<typename S , typename I >
using	ranges::v3::SizedSentinel = concepts::models< concepts::SizedSentinel, S, I >
template<typename T >
using	ranges::v3::SizedView = concepts::models< concepts::SizedView, T >
template<typename I , typename C = ordered_less, typename P = ident>
using	ranges::v3::Sortable = meta::strict_and< ForwardIterator< I >, IndirectCallableRelation< C, projected< I, P >, projected< I, P >>, Permutable< I >>
template<typename I , typename C , typename P = ident>
using	ranges::v3::StablePartitionable = meta::strict_and< ForwardIterator< I >, Permutable< I >, IndirectCallablePredicate< C, projected< I, P >>>
template<typename T , typename U = T>
using	ranges::v3::Swappable = concepts::models< concepts::Swappable, T, U >
template<typename T , typename U = T>
using	ranges::v3::TotallyOrdered = concepts::models< concepts::TotallyOrdered, T, U >
template<typename I , typename O , typename F , typename P = ident, typename V = iterator_common_reference_t<I>, typename X = concepts::Callable::result_t<P, V>, typename Y = concepts::Callable::result_t<F, X>>
using	ranges::v3::Transformable1 = meta::strict_and< InputIterator< I >, WeaklyIncrementable< O >, IndirectCallable< F, projected< I, P >>, Writable< O, Y && >>
template<typename I0 , typename I1 , typename O , typename F , typename P0 = ident, typename P1 = ident, typename V0 = iterator_common_reference_t<I0>, typename X0 = concepts::Callable::result_t<P0, V0>, typename V1 = iterator_common_reference_t<I1>, typename X1 = concepts::Callable::result_t<P1, V1>, typename Y = concepts::Callable::result_t<F, X0, X1>>
using	ranges::v3::Transformable2 = meta::strict_and< InputIterator< I0 >, InputIterator< I1 >, WeaklyIncrementable< O >, IndirectCallable< F, projected< I0, P0 >, projected< I1, P1 >>, Writable< O, Y && >>
template<typename Gen >
using	ranges::v3::UniformRandomNumberGenerator = concepts::models< concepts::UniformRandomNumberGenerator, Gen >
template<typename I , typename O , typename C = equal_to, typename P = ident>
using	ranges::v3::UniqueCopyable = meta::strict_and< InputIterator< I >, IndirectCallableRelation< C, projected< I, P >>, WeaklyIncrementable< O >, IndirectlyCopyable< I, O >, meta::strict_or< ForwardIterator< I >, ForwardIterator< O >, IndirectlyCopyableStorable< I, O >>>
template<typename T >
using	ranges::v3::UnsignedIntegral = concepts::models< concepts::UnsignedIntegral, T >
template<typename T >
using	ranges::v3::concepts::val_t = meta::if_< std::is_rvalue_reference< T >, T, T & >
template<typename T , typename U , typename... Rest>
using	ranges::v3::concepts::Common::value_t = common_type_t< T, U, Rest... >
template<typename T >
using	ranges::v3::View = concepts::models< concepts::View, T >
template<typename T >
using	ranges::v3::view_concept = concepts::most_refined< meta::list< concepts::View, concepts::Range >, T >
template<typename T >
using	ranges::v3::view_concept_t = meta::_t< view_concept< T >>
template<typename T , typename U >
using	ranges::v3::WeaklyEqualityComparable = concepts::models< concepts::WeaklyEqualityComparable, T, U >
template<typename T >
using	ranges::v3::WeaklyIncrementable = concepts::models< concepts::WeaklyIncrementable, T >
template<typename T , typename U = T>
using	ranges::v3::WeaklyOrdered = concepts::models< concepts::WeaklyOrdered, T, U >
template<typename Out , typename T >
using	ranges::v3::Writable = concepts::models< concepts::Writable, Out, T >

Functions
template<typename T , typename U >
auto	ranges::v3::concepts::convertible_to (U &&u) -> decltype(concepts::returns_< int >(static_cast< T >((U &&) u)))
template<typename T , typename U >
auto	ranges::v3::concepts::has_type (U &&) -> meta::if_< std::is_same< T, U >, int >
template<typename Concept , typename... Ts>
auto	ranges::v3::concepts::model_of (Ts &&...) -> meta::if_c< concepts::models< Concept, Ts... >::value, int >
template<typename Concept , typename... Ts>
auto	ranges::v3::concepts::model_of () -> meta::if_c< concepts::models< Concept, Ts... >::value, int >
template<typename... Ts>
void	ranges::v3::concepts::refines< Concepts >::requires_ (Ts &&...)
template<typename... Ts>
auto	ranges::v3::concepts::Same::requires_ (Ts &&...) -> decltype( concepts::valid_expr( concepts::is_true(same_t< Ts... >
template<typename T , typename U >
auto	ranges::v3::concepts::DerivedFrom::requires_ (T &&, U &&) -> decltype( concepts::valid_expr( concepts::is_true(std::is_base_of< U, T >
template<typename T , typename U , typename C = reference_t<T, U>>
auto	ranges::v3::concepts::CommonReference::requires_ (T &&, U &&) -> decltype( concepts::valid_expr( concepts::model_of< Same, C, reference_t< U, T >>(), C(val< T >()), C(val< U >()) ))
template<typename T , typename U , typename... Rest, typename CommonReference_ = CommonReference, typename C = reference_t<T, U>>
auto	ranges::v3::concepts::CommonReference::requires_ (T &&, U &&, Rest &&...) -> decltype( concepts::valid_expr( concepts::model_of< CommonReference_, T, U >(), concepts::model_of< CommonReference_, C, Rest... >() ))
template<typename T , typename U , meta::if_< std::is_same< uncvref_t< T >, uncvref_t< U >>, int > = 0>
auto	ranges::v3::concepts::Common::requires_ (T &&, U &&) -> void
template<typename T , typename U , meta::if_c<!std::is_same< uncvref_t< T >, uncvref_t< U >>::value, int > = 0, typename C = value_t<T, U>, typename R = CommonReference::reference_t<T const &, U const &>>
auto	ranges::v3::concepts::Common::requires_ (T &&, U &&) -> decltype( concepts::valid_expr( concepts::model_of< Same, C, value_t< U, T >>(), C(val< T && >()), C(val< U && >()), concepts::model_of< CommonReference, T const &, U const & >(), concepts::model_of< CommonReference, C &, R && >() ))
template<typename T , typename U , typename... Rest, typename Common_ = Common, typename C = value_t<T, U>>
auto	ranges::v3::concepts::Common::requires_ (T &&, U &&, Rest &&...) -> decltype( concepts::valid_expr( concepts::model_of< Common_, T, U >(), concepts::model_of< Common_, C, Rest... >() ))
template<typename T >
auto	ranges::v3::concepts::Integral::requires_ (T &&) -> decltype( concepts::valid_expr( concepts::is_true(std::is_integral< T >
template<typename T >
auto	ranges::v3::concepts::SignedIntegral::requires_ (T &&) -> decltype( concepts::valid_expr( concepts::is_true(std::is_signed< T >
template<typename T >
auto	ranges::v3::concepts::UnsignedIntegral::requires_ (T &&) -> decltype( concepts::valid_expr( concepts::is_true(std::is_unsigned< T >
template<typename T , typename U >
auto	ranges::v3::concepts::Assignable::requires_ (T &&t, U &&u) -> decltype( concepts::valid_expr( concepts::has_type< T & >(static_cast< T && >(t)=static_cast< U && >(u)) ))
template<typename T >
auto	ranges::v3::concepts::Swappable::requires_ (T &&) -> decltype( concepts::valid_expr( ((void) swap(std::declval< T >(), std::declval< T >()), 42) ))
template<typename T , typename U >
auto	ranges::v3::concepts::Swappable::requires_ (T &&, U &&) -> decltype( concepts::valid_expr( ((void) swap(std::declval< T >(), std::declval< U >()), 42), ((void) swap(std::declval< U >(), std::declval< T >()), 42) ))
template<typename T , typename U >
auto	ranges::v3::concepts::WeaklyEqualityComparable::requires_ (T &&t, U &&u) -> decltype( concepts::valid_expr( concepts::convertible_to< bool >(t==u), concepts::convertible_to< bool >(t!=u), concepts::convertible_to< bool >(u==t), concepts::convertible_to< bool >(u!=t) ))
template<typename T >
auto	ranges::v3::concepts::EqualityComparable::requires_ (T &&t) -> decltype( concepts::valid_expr( concepts::convertible_to< bool >(t==t), concepts::convertible_to< bool >(t!=t) ))
template<typename T , typename U , meta::if_< std::is_same< T, U >, int > = 0>
auto	ranges::v3::concepts::EqualityComparable::requires_ (T &&, U &&) -> decltype( concepts::valid_expr( concepts::model_of< EqualityComparable, T >() ))
template<typename T , typename U , meta::if_c<!std::is_same< T, U >::value, int > = 0, typename C = CommonReference::reference_t<T const &, U const &>>
auto	ranges::v3::concepts::EqualityComparable::requires_ (T &&, U &&) -> decltype( concepts::valid_expr( concepts::model_of< EqualityComparable, T >(), concepts::model_of< EqualityComparable, U >(), concepts::model_of< WeaklyEqualityComparable, T, U >(), concepts::model_of< CommonReference, T const &, U const & >(), concepts::model_of< EqualityComparable, C >() ))
template<typename T >
auto	ranges::v3::concepts::WeaklyOrdered::requires_ (T &&t) -> decltype( concepts::valid_expr( concepts::convertible_to< bool >(t< t), concepts::convertible_to< bool >(t > t), concepts::convertible_to< bool >(t<=t), concepts::convertible_to< bool >(t >=t) ))
template<typename T , typename U , typename C = CommonReference::reference_t<T const &, U const &>>
auto	ranges::v3::concepts::WeaklyOrdered::requires_ (T &&t, U &&u) -> decltype( concepts::valid_expr( concepts::model_of< WeaklyOrdered, T >(), concepts::model_of< WeaklyOrdered, U >(), concepts::model_of< CommonReference, T const &, U const & >(), concepts::model_of< WeaklyOrdered, C >(), concepts::convertible_to< bool >(t< u), concepts::convertible_to< bool >(u< t), concepts::convertible_to< bool >(t > u), concepts::convertible_to< bool >(u > t), concepts::convertible_to< bool >(t<=u), concepts::convertible_to< bool >(u<=t), concepts::convertible_to< bool >(t >=u), concepts::convertible_to< bool >(u >=t) ))
template<typename T >
void	ranges::v3::concepts::TotallyOrdered::requires_ (T &&)
template<typename T , typename U >
auto	ranges::v3::concepts::TotallyOrdered::requires_ (T &&, U &&) -> decltype( concepts::valid_expr( concepts::model_of< TotallyOrdered >(val< T >()), concepts::model_of< TotallyOrdered >(val< U >()) ))
template<typename T , meta::if_< std::is_object< T >, int > = 0>
auto	ranges::v3::concepts::Destructible::requires_ (T &&t, T *const p=nullptr) -> decltype( concepts::valid_expr( ((void) t.~T(), 42), concepts::is_true(std::is_nothrow_destructible< T >()), concepts::has_type< T * >(&t), concepts::has_type< const T * >(&std::declval< const T & >()), ((void) delete p, 42), ((void) delete[] p, 42) ))
template<typename T , typename... Args, meta::if_c<!std::is_reference< T >::value, int > = 0>
auto	ranges::v3::concepts::Constructible::requires_ (T &&, meta::id_t< Args > &&...) -> decltype( concepts::valid_expr( concepts::model_of< ConstructibleObject, T, Args... >() ))
template<typename T , std::size_t N = 42, meta::if_c<!detail::avoid_empty_braces< T >::value, int > = 0>
auto	ranges::v3::concepts::DefaultConstructible::requires_ (T &&) -> decltype( concepts::valid_expr( new T[N]
template<typename T , typename UnCvT = meta::_t<std::remove_cv<T>>>
auto	ranges::v3::concepts::MoveConstructible::requires_ (T &&) -> decltype( concepts::valid_expr( concepts::model_of< Constructible, T, UnCvT && >(), concepts::model_of< ImplicitlyConvertibleTo, UnCvT &&, T >() ))
template<typename T , typename UnCvT = meta::_t<std::remove_cv<T>>>
auto	ranges::v3::concepts::CopyConstructible::requires_ (T &&) -> decltype( concepts::valid_expr( concepts::model_of< Constructible, T, UnCvT const & >(), concepts::model_of< ImplicitlyConvertibleTo, UnCvT const &, T >(), concepts::model_of< Constructible, T, UnCvT & >(), concepts::model_of< ImplicitlyConvertibleTo, UnCvT &, T >(), concepts::model_of< Constructible, T, UnCvT const && >(), concepts::model_of< ImplicitlyConvertibleTo, UnCvT const &&, T >() ))
template<typename T >
auto	ranges::v3::concepts::Movable::requires_ (T &&) -> decltype( concepts::valid_expr( concepts::model_of< Assignable, T &, T && >(), concepts::model_of< Swappable, T & >() ))
template<typename T >
auto	ranges::v3::concepts::Copyable::requires_ (T &&) -> decltype( concepts::valid_expr( concepts::model_of< Assignable, T &, T const & >(), concepts::model_of< Assignable, T &, T & >(), concepts::model_of< Assignable, T &, T const && >() ))
template<typename Fun , typename... Args>
auto	ranges::v3::concepts::Function::requires_ (Fun &&fun, Args &&...args) -> decltype( concepts::valid_expr( concepts::model_of< CopyConstructible, uncvref_t< Fun >>(), ((void) val< Fun >()(val< Args >()...), 42) ))
template<typename Fun , typename... Args>
auto	ranges::v3::concepts::Predicate::requires_ (Fun &&fun, Args &&...args) -> decltype( concepts::valid_expr( concepts::convertible_to< bool >(val< Fun >()(val< Args >()...)) ))
template<typename Fun , typename T >
auto	ranges::v3::concepts::Relation::requires_ (Fun &&, T &&) -> decltype( concepts::valid_expr( concepts::model_of< Predicate >(val< Fun >(), val< T >(), val< T >()) ))
template<typename Fun , typename T , typename U , meta::if_< std::is_same< T, U >, int > = 0>
auto	ranges::v3::concepts::Relation::requires_ (Fun &&, T &&, T &&) -> decltype( concepts::valid_expr( concepts::model_of< Predicate >(val< Fun >(), val< T >(), val< U >()) ))
template<typename Fun , typename T , typename U , meta::if_c<!std::is_same< T, U >::value, int > = 0, typename C = CommonReference::reference_t<T const &, U const &>>
auto	ranges::v3::concepts::Relation::requires_ (Fun &&, T &&, U &&) -> decltype( concepts::valid_expr( concepts::model_of< Relation, Fun, T, T >(), concepts::model_of< Relation, Fun, U, U >(), concepts::model_of< CommonReference, T const &, U const & >(), concepts::model_of< Relation, Fun, C, C >(), concepts::model_of< Predicate, Fun, T, U >(), concepts::model_of< Predicate, Fun, U, T >() ))
template<typename Ret , typename T >
Ret	ranges::v3::concepts::returns_ (T const &)
template<typename T >
val_t< T >	ranges::v3::concepts::val ()

Macro Definition Documentation

#define CONCEPT_REQUIRES

(

...

)

#include <range/v3/utility/concepts.hpp>

Value:

template<                                                                       \
        int CONCEPT_PP_CAT(_concept_requires_, __LINE__) = 42,                      \
        typename std::enable_if<                                                    \
            (CONCEPT_PP_CAT(_concept_requires_, __LINE__) == 43) || (__VA_ARGS__),  \
            int                                                                     \
        >::type = 0>                                                                \

#define CONCEPT_REQUIRES_

(

...

)

#include <range/v3/utility/concepts.hpp>

Value:

int CONCEPT_PP_CAT(_concept_requires_, __LINE__) = 42,                          \
    typename std::enable_if<                                                        \
        (CONCEPT_PP_CAT(_concept_requires_, __LINE__) == 43) || (__VA_ARGS__),      \
        int                                                                         \
    >::type = 0                                                                     \