Concepts

Description

Concept-checking classes and utilities.

Classes
struct	ranges::concepts::InsertableRange
struct	ranges::v3::concepts::Assignable
struct	ranges::v3::concepts::Common
struct	ranges::v3::concepts::CommonReference
struct	ranges::v3::concepts::Constructible
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::Integral
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::refines< Concepts >
struct	ranges::v3::concepts::Regular
struct	ranges::v3::concepts::Same
struct	ranges::v3::concepts::Same::same< Ts >
struct	ranges::v3::concepts::Same::same< T, Us... >
struct	ranges::v3::concepts::SemiRegular
struct	ranges::v3::concepts::SignedIntegral
struct	ranges::v3::concepts::Swappable
struct	ranges::v3::concepts::TotallyOrdered
struct	ranges::v3::concepts::UnsignedIntegral
struct	ranges::v3::concepts::WeaklyEqualityComparable
struct	ranges::v3::concepts::WeaklyOrdered
struct	ranges::v3::difference_type< T >
struct	ranges::v3::difference_type< detail::projected_< I, Proj > >
struct	ranges::v3::difference_type< T const >
struct	ranges::v3::disable_sized_sentinel< S, I >
struct	ranges::v3::enable_view< T >
struct	ranges::v3::iterator_category< T >
struct	ranges::v3::iterator_category< T const >
struct	ranges::v3::size_type< T >
struct	ranges::v3::value_type< T >
struct	ranges::v3::value_type< T const >

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 >, IndirectPredicate< 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 >, IndirectRelation< 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 T , typename U , typename... Rest>
using	ranges::v3::Common = concepts::models< concepts::Common, T, U, Rest... >
template<typename T , typename U , typename... Rest>
using	ranges::v3::CommonReference = 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 >, IndirectRelation< 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 I >
using	ranges::v3::ContiguousIterator = concepts::models< concepts::ContiguousIterator, I >
template<typename Rng >
using	ranges::v3::ContiguousRange = concepts::models< concepts::ContiguousRange, Rng >
template<typename T >
using	ranges::v3::ContiguousView = concepts::models< concepts::ContiguousView, T >
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 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::IndirectInvocable = meta::and_< detail::common_result_indirect_invocable_< C, Is... >, CopyConstructible< C > >
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_< detail::indirect_invocable_< Predicate, C, Is... >, CopyConstructible< C > >
template<typename C , typename ... Is>
using	ranges::v3::IndirectRegularInvocable = IndirectInvocable< C, Is... >
template<typename C , typename I0 , typename I1 = I0>
using	ranges::v3::IndirectRelation = meta::and_< detail::indirect_invocable_< Relation, C, I0, I1 >, CopyConstructible< C > >
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 Fun , typename... Args>
using	ranges::v3::Invocable = concepts::models< concepts::Invocable, Fun, Args... >
template<typename T >
using	ranges::v3::is_view = View< T >
template<typename I , typename C = ordered_less, typename P = ident>
using	ranges::v3::IsHeapable = meta::strict_and< RandomAccessIterator< I >, IndirectRelation< C, projected< I, P > >>
template<typename I , typename C , typename P = ident>
using	ranges::v3::IsPartitionedable = meta::strict_and< InputIterator< I >, IndirectPredicate< 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::ContiguousIterator, 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 >, IndirectRelation< 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 >, IndirectPredicate< 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 C , typename ... Is>
using	ranges::v3::MoveIndirectInvocable = meta::and_< detail::common_result_indirect_invocable_< C, Is... >, MoveConstructible< C > >
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 >, IndirectRelation< 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 >, IndirectRelation< 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 >, IndirectPredicate< 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 >, IndirectPredicate< 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< IndirectRegularInvocable< 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::ContiguousRange, 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::RegularInvocable = concepts::models< concepts::RegularInvocable, 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 >, IndirectRelation< 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 >, IndirectPredicate< 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 >, IndirectRelation< 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 >, IndirectPredicate< 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 >, IndirectRelation< 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 >, IndirectRelation< 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 >, IndirectPredicate< C, projected< I, P > >>
template<typename I , typename C , typename T , typename P = ident>
using	ranges::v3::ReplaceIfable = meta::strict_and< InputIterator< I >, IndirectPredicate< 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 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 >, IndirectRelation< 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 >, IndirectPredicate< 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>
using	ranges::v3::Transformable1 = meta::strict_and< InputIterator< I >, WeaklyIncrementable< O >, CopyConstructible< F >, Writable< O, indirect_result_of_t< F &(projected< I, P >)> >>
template<typename I0 , typename I1 , typename O , typename F , typename P0 = ident, typename P1 = ident>
using	ranges::v3::Transformable2 = meta::strict_and< InputIterator< I0 >, InputIterator< I1 >, WeaklyIncrementable< O >, CopyConstructible< F >, Writable< O, indirect_result_of_t< F &(projected< I0, P0 >, projected< I1, P1 >)> >>
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 >, IndirectRelation< 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 , 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
	ranges::v3::concepts::Assignable::concepts::has_type ((T &&) t=(U &&) u)))
	ranges::v3::concepts::DerivedFrom::concepts::is_true (std::is_convertible< meta::_t< std::remove_cv< T >> *, meta::_t< std::remove_cv< U >> *>{})))
	ranges::v3::concepts::Common::concepts::model_of ()
	ranges::v3::concepts::Assignable::concepts::model_of ()
	ranges::v3::concepts::EqualityComparable::concepts::model_of ()))
	ranges::v3::concepts::Movable::concepts::model_of ()
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_ ()
template<typename ... Ts>
auto	ranges::v3::concepts::Same::requires_ () -> decltype(concepts::valid_expr(concepts::is_true(same_t< Ts... >
template<typename T , typename U >
auto	ranges::v3::concepts::DerivedFrom::requires_ () -> decltype(concepts::valid_expr(concepts::is_true(std::is_base_of< U, T >
template<typename T , typename U >
auto	ranges::v3::concepts::CommonReference::requires_ () -> decltype(concepts::valid_expr(concepts::model_of< Same, reference_t< T, U >, reference_t< U, T >>(), concepts::model_of< ConvertibleTo, T, reference_t< T, U >>(), concepts::model_of< ConvertibleTo, U, reference_t< T, U >>()))
template<typename T , typename U , typename... Rest, typename CommonReference_ = CommonReference>
auto	ranges::v3::concepts::CommonReference::requires_ () -> decltype(concepts::valid_expr(concepts::model_of< CommonReference_, T, U >(), concepts::model_of< CommonReference_, reference_t< T, U >, Rest... >()))
template<typename T , typename U >
auto	ranges::v3::concepts::Common::requires_ () -> decltype(concepts::valid_expr(concepts::is_true(std::is_same< uncvref_t< T >, uncvref_t< U >>
template<typename T , typename U , typename... Rest, typename Common_ = Common>
auto	ranges::v3::concepts::Common::requires_ () -> decltype(concepts::valid_expr(concepts::model_of< Common_, T, U >(), concepts::model_of< Common_, value_t< T, U >, Rest... >()))
template<typename T >
auto	ranges::v3::concepts::Integral::requires_ () -> decltype(concepts::valid_expr(concepts::is_true(std::is_integral< T >
template<typename T >
auto	ranges::v3::concepts::SignedIntegral::requires_ () -> decltype(concepts::valid_expr(concepts::is_true(std::is_signed< T >
template<typename T >
auto	ranges::v3::concepts::UnsignedIntegral::requires_ () -> decltype(concepts::valid_expr(concepts::is_false(std::is_signed< T >
template<typename T , typename U >
auto	ranges::v3::concepts::Assignable::requires_ (T &&t, U &&u) -> decltype(concepts::valid_expr(concepts::is_true(std::is_lvalue_reference< T >
template<typename T >
auto	ranges::v3::concepts::Swappable::requires_ (T &&t) -> decltype(concepts::valid_expr(((void) ranges::swap((T &&) t,(T &&) t), 42)))
template<typename T , typename U >
auto	ranges::v3::concepts::Swappable::requires_ (T &&t, U &&u) -> decltype(concepts::valid_expr(concepts::model_of< Swappable, T >(), concepts::model_of< Swappable, U >(), concepts::model_of< CommonReference, detail::as_cref_t< T >, detail::as_cref_t< U >>(),((void) ranges::swap((T &&) t,(U &&) u), 42),((void) ranges::swap((U &&) u,(T &&) t), 42)))
template<typename T , typename U >
auto	ranges::v3::concepts::WeaklyEqualityComparable::requires_ (detail::as_cref_t< T > t, detail::as_cref_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_ (detail::as_cref_t< T > t) -> decltype(concepts::valid_expr(concepts::convertible_to< bool >(t==t), concepts::convertible_to< bool >(t !=t)))
template<typename T , typename U >
auto	ranges::v3::concepts::EqualityComparable::requires_ () -> decltype(concepts::valid_expr(concepts::is_true(std::is_same< T, U >
template<typename T , typename U , typename C = common_reference_t<detail::as_cref_t<T>, detail::as_cref_t<U>>>
auto	ranges::v3::concepts::EqualityComparable::requires_ () -> decltype(concepts::valid_expr(concepts::is_false(std::is_same< T, U >
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 = common_reference_t<detail::as_cref_t<T>, detail::as_cref_t<U>>>
auto	ranges::v3::concepts::WeaklyOrdered::requires_ (detail::as_cref_t< T > t, detail::as_cref_t< U > u) -> decltype(concepts::valid_expr(concepts::model_of< WeaklyOrdered, T >(), concepts::model_of< WeaklyOrdered, U >(), concepts::model_of< CommonReference, detail::as_cref_t< T >, detail::as_cref_t< U >>(), 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_ ()
template<typename T , typename U >
auto	ranges::v3::concepts::TotallyOrdered::requires_ () -> decltype(concepts::valid_expr(concepts::model_of< TotallyOrdered, T >(), concepts::model_of< TotallyOrdered, U >()))
template<typename T >
auto	ranges::v3::concepts::Destructible::requires_ () -> decltype(concepts::valid_expr(concepts::is_true(std::is_nothrow_destructible< T >())))
template<typename T , typename... Args>
auto	ranges::v3::concepts::Constructible::requires_ () -> decltype(concepts::valid_expr(concepts::is_true(std::is_constructible< T, Args... >
template<typename T >
void	ranges::v3::concepts::DefaultConstructible::requires_ ()
template<typename T >
auto	ranges::v3::concepts::MoveConstructible::requires_ () -> decltype(concepts::valid_expr(concepts::model_of< Constructible, T, T >(), concepts::model_of< ConvertibleTo, T, T >()))
template<typename T >
auto	ranges::v3::concepts::CopyConstructible::requires_ () -> decltype(concepts::valid_expr(concepts::model_of< Constructible, T, T &>(), concepts::model_of< Constructible, T, T const &>(), concepts::model_of< Constructible, T, T const >(), concepts::model_of< ConvertibleTo, T &, T >(), concepts::model_of< ConvertibleTo, T const &, T >(), concepts::model_of< ConvertibleTo, T const, T >()))
template<typename T >
auto	ranges::v3::concepts::Movable::requires_ () -> decltype(concepts::valid_expr(concepts::is_true(std::is_object< T >
template<typename T >
auto	ranges::v3::concepts::Copyable::requires_ () -> 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 Ret , typename T >
Ret	ranges::v3::concepts::returns_ (T const &)

Macro Definition Documentation

CONCEPT_REQUIRES

#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>                                                                \

CONCEPT_REQUIRES_

#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                                                                     \