Protect a callable so that it can be safely used in a bind expression without accidentally becoming a "nested" bind.
More...
|
template<typename I , typename T , typename Op = plus, typename P = ident, typename V = iterator_value_t<I>, typename X = concepts::Callable::result_t<P, V>, typename Y = concepts::Callable::result_t<Op, T, X>> |
using | Accumulateable = meta::strict_and< InputIterator< I >, Callable< P, V >, Callable< Op, T, X >, Assignable< T &, Y >> |
|
template<typename D > |
using | adaptor_cursor_t = adaptor_cursor< detail::adapted_iterator_t< D >, detail::begin_adaptor_t< D >> |
|
template<typename D > |
using | adaptor_sentinel_t = meta::if_< meta::and_< Same< detail::adapted_iterator_t< D >, detail::adapted_sentinel_t< D >>, Same< detail::begin_adaptor_t< D >, detail::end_adaptor_t< D >>>, adaptor_cursor< detail::adapted_iterator_t< D >, detail::begin_adaptor_t< D >>, adaptor_sentinel< detail::adapted_sentinel_t< D >, detail::end_adaptor_t< D >>> |
|
template<typename I , typename O , typename BOp = minus, typename P = ident, typename V = iterator_value_t<I>, typename X = concepts::Callable::result_t<P, V>, typename Y = concepts::Callable::result_t<BOp, X, X>> |
using | AdjacentDifferentiable = meta::strict_and< InputIterator< I >, OutputIterator< O, X && >, OutputIterator< O, Y && >, Callable< P, V >, Callable< BOp, X, X >, CopyConstructible< uncvref_t< X >>, Movable< uncvref_t< X >>> |
|
template<typename Ref > |
using | any_bidirectional_view = any_view< Ref, category::bidirectional > |
|
template<typename Ref > |
using | any_forward_view = any_view< Ref, category::forward > |
|
template<typename Ref > |
using | any_input_view = any_view< Ref, category::input > |
|
template<typename Ref > |
using | any_random_access_view = any_view< Ref, category::random_access > |
|
template<typename T , typename U > |
using | Assignable = concepts::models< concepts::Assignable, T, U > |
|
template<typename I1 , typename I2 , typename C = equal_to, typename P1 = ident, typename P2 = ident> |
using | AsymmetricallyComparable = meta::strict_and< InputIterator< I1 >, InputIterator< I2 >, IndirectCallablePredicate< C, projected< I1, P1 >, projected< I2, P2 >>> |
|
template<typename Cont > |
using | back_insert_iterator = basic_iterator< detail::back_insert_cursor< Cont >> |
|
template<typename Derived > |
using | base_range_t = meta::_t< range_access::base_range< Derived >> |
|
template<typename T > |
using | BidirectionalIncrementable = concepts::models< concepts::BidirectionalIncrementable, T > |
|
template<typename I > |
using | BidirectionalIterator = concepts::models< concepts::BidirectionalIterator, I > |
|
template<typename T > |
using | BidirectionalRange = concepts::models< concepts::BidirectionalRange, T > |
|
template<typename T > |
using | BidirectionalView = concepts::models< concepts::BidirectionalView, T > |
|
template<typename I , typename V2 , typename C = ordered_less, typename P = ident> |
using | BinarySearchable = meta::strict_and< ForwardIterator< I >, IndirectCallableRelation< C, projected< I, P >, V2 const * >> |
|
template<typename T > |
using | bind_element_t = meta::_t< bind_element< T >> |
|
template<typename T > |
using | bounded_range_concept = concepts::most_refined< meta::list< concepts::BoundedRange, concepts::Range >, T > |
|
template<typename T > |
using | bounded_range_concept_t = meta::_t< bounded_range_concept< T >> |
|
template<typename T > |
using | bounded_view_concept = concepts::most_refined< meta::list< concepts::BoundedView, concepts::View >, T > |
|
template<typename T > |
using | bounded_view_concept_t = meta::_t< bounded_view_concept< T >> |
|
template<typename T > |
using | BoundedRange = concepts::models< concepts::BoundedRange, T > |
|
template<typename T > |
using | BoundedView = concepts::models< concepts::BoundedView, T > |
|
template<typename Fun , typename... Args> |
using | Callable = concepts::models< concepts::Callable, Fun, Args... > |
|
template<typename Fun , typename... Args> |
using | CallablePredicate = concepts::models< concepts::CallablePredicate, Fun, Args... > |
|
template<typename Fun , typename T , typename U = T> |
using | CallableRelation = concepts::models< concepts::CallableRelation, Fun, T, U > |
|
template<typename T , typename U , typename... Rest> |
using | 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 I , typename S > |
using | common_iterator = meta::if_< std::is_same< I, S >, I, basic_iterator< detail::common_cursor< I, S >>> |
|
template<typename... Ts> |
using | common_reference_t = meta::_t< common_reference< Ts... >> |
|
template<typename... Ts> |
using | common_type_t = meta::_t< common_type< Ts... >> |
|
template<typename T , typename U , typename... Rest> |
using | 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 | Comparable = meta::strict_and< AsymmetricallyComparable< I1, I2, C, P1, P2 >, IndirectCallableRelation< C, projected< I1, P1 >, projected< I2, P2 >>> |
|
template<typename T , typename... Args> |
using | Constructible = concepts::models< concepts::Constructible, T, Args... > |
|
template<typename T > |
using | Container = concepts::models< concepts::Container, T > |
|
template<typename T > |
using | ContainerLike_ = concepts::models< concepts::ContainerLike_, T > |
| INTERNAL ONLY.
|
|
template<typename T , typename U > |
using | ConvertibleTo = concepts::models< concepts::ConvertibleTo, T, U > |
|
template<typename T > |
using | Copyable = concepts::models< concepts::Copyable, T > |
|
template<typename T > |
using | CopyConstructible = concepts::models< concepts::CopyConstructible, T > |
|
template<typename I , typename D = meta::_t<difference_type<I>>> |
using | counted_iterator = basic_iterator< detail::counted_cursor< I, D >, default_end_cursor > |
|
using | default_sentinel = basic_sentinel< default_end_cursor > |
|
template<typename T > |
using | DefaultConstructible = concepts::models< concepts::DefaultConstructible, T > |
|
template<typename T , typename U > |
using | DerivedFrom = concepts::models< concepts::DerivedFrom, T, U > |
|
template<typename T > |
using | Destructible = concepts::models< concepts::Destructible, T > |
|
template<typename T , typename U = T> |
using | EqualityComparable = concepts::models< concepts::EqualityComparable, T, U > |
|
template<typename Rng , typename... Rest> |
using | ErasableRange = concepts::models< concepts::ErasableRange, Rng, Rest... > |
|
template<typename I , typename T > |
using | ExclusivelyWritable_ = meta::invoke< detail::exclusively_writable_< I >, T > |
|
template<typename T , typename U > |
using | ExplicitlyConvertibleTo = concepts::models< concepts::ExplicitlyConvertibleTo, T, U > |
|
template<typename I > |
using | ForwardIterator = concepts::models< concepts::ForwardIterator, I > |
|
template<typename T > |
using | ForwardRange = concepts::models< concepts::ForwardRange, T > |
|
template<typename T > |
using | ForwardView = concepts::models< concepts::ForwardView, T > |
|
template<typename Cont > |
using | front_insert_iterator = basic_iterator< detail::front_insert_cursor< Cont >> |
|
template<typename Fun , typename... Args> |
using | Function = concepts::models< concepts::Function, Fun, Args... > |
|
template<typename T > |
using | function_type = decltype(as_function(std::declval< T >())) |
|
template<typename T , typename U > |
using | ImplicitlyConvertibleTo = concepts::models< concepts::ImplicitlyConvertibleTo, T, U > |
|
template<typename T > |
using | Incrementable = concepts::models< concepts::Incrementable, T > |
|
template<typename T > |
using | incrementable_concept = concepts::most_refined< meta::list< concepts::RandomAccessIncrementable, concepts::BidirectionalIncrementable, concepts::Incrementable, concepts::WeaklyIncrementable >, T > |
|
template<typename T > |
using | incrementable_concept_t = meta::_t< incrementable_concept< T >> |
|
template<typename C , typename... Is> |
using | IndirectCallable = IndirectFunction< function_type< C >, Is... > |
|
template<typename C , typename... Is> |
using | IndirectCallablePredicate = IndirectPredicate< function_type< C >, Is... > |
|
template<typename C , typename I0 , typename I1 = I0> |
using | IndirectCallableRelation = IndirectRelation< function_type< C >, I0, I1 > |
|
template<typename C , typename... Is> |
using | 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 | IndirectlyCopyable = concepts::models< concepts::IndirectlyCopyable, I, O > |
|
template<typename I , typename O > |
using | IndirectlyCopyableStorable = concepts::models< concepts::IndirectlyCopyableStorable, I, O > |
|
template<typename I , typename O > |
using | IndirectlyMovable = concepts::models< concepts::IndirectlyMovable, I, O > |
|
template<typename I , typename O > |
using | IndirectlyMovableStorable = concepts::models< concepts::IndirectlyMovableStorable, I, O > |
|
template<typename I1 , typename I2 > |
using | IndirectlySwappable = concepts::models< concepts::IndirectlySwappable, I1, I2 > |
|
template<typename C , typename... Is> |
using | 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 | 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 I1 , typename I2 , typename T , typename BOp1 = plus, typename BOp2 = multiplies, typename P1 = ident, typename P2 = ident, typename V1 = iterator_value_t<I1>, typename V2 = iterator_value_t<I2>, typename X1 = concepts::Callable::result_t<P1, V1>, typename X2 = concepts::Callable::result_t<P2, V2>, typename Y2 = concepts::Callable::result_t<BOp2, X1, X2>, typename Y1 = concepts::Callable::result_t<BOp1, T, Y2>> |
using | InnerProductable = meta::strict_and< InputIterator< I1 >, InputIterator< I2 >, Callable< P1, V1 >, Callable< P2, V2 >, Callable< BOp2, X1, X2 >, Callable< BOp1, T, Y2 >, Assignable< T &, Y2 >> |
|
template<typename I > |
using | InputIterator = concepts::models< concepts::InputIterator, I > |
|
template<typename T > |
using | InputRange = concepts::models< concepts::InputRange, T > |
|
template<typename T > |
using | InputView = concepts::models< concepts::InputView, T > |
|
template<typename T > |
using | Integral = concepts::models< concepts::Integral, T > |
|
template<typename Rng > |
using | is_finite = meta::bool_< range_cardinality< Rng >::value >=finite > |
|
template<typename Rng > |
using | is_infinite = meta::bool_< range_cardinality< Rng >::value==infinite > |
|
template<typename T > |
using | is_reference_wrapper_t = meta::_t< is_reference_wrapper< T >> |
|
template<typename I , typename C = ordered_less, typename P = ident> |
using | IsHeapable = meta::strict_and< RandomAccessIterator< I >, IndirectCallableRelation< C, projected< I, P >>> |
|
template<typename I , typename C , typename P = ident> |
using | 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 | IsPermutationable = meta::strict_and< ForwardIterator< I1 >, ForwardIterator< I2 >, Comparable< I1, I2, C, P1, P2 >> |
|
template<typename I > |
using | Iterator = concepts::models< concepts::Iterator, I > |
|
template<typename I > |
using | iterator_category_t = concepts::InputIterator::category_t< I > |
|
template<typename I > |
using | iterator_common_reference = meta::defer< iterator_common_reference_t, I > |
|
template<typename I > |
using | iterator_common_reference_t = concepts::Readable::common_reference_t< I > |
|
template<typename T > |
using | iterator_concept = concepts::most_refined< meta::list< concepts::RandomAccessIterator, concepts::BidirectionalIterator, concepts::ForwardIterator, concepts::InputIterator >, T > |
|
template<typename T > |
using | iterator_concept_t = meta::_t< iterator_concept< T >> |
|
template<typename I > |
using | iterator_difference = meta::defer< iterator_difference_t, I > |
|
template<typename I > |
using | iterator_difference_t = concepts::WeaklyIncrementable::difference_t< I > |
|
template<typename I > |
using | iterator_reference = meta::defer< iterator_reference_t, I > |
|
template<typename I > |
using | iterator_reference_t = concepts::Readable::reference_t< I > |
|
template<typename I > |
using | iterator_rvalue_reference = meta::defer< iterator_rvalue_reference_t, I > |
|
template<typename I > |
using | iterator_rvalue_reference_t = concepts::Readable::rvalue_reference_t< I > |
|
template<typename I > |
using | iterator_size = meta::defer< iterator_size_t, I > |
|
template<typename I > |
using | iterator_size_t = meta::_t< std::make_unsigned< iterator_difference_t< I >>> |
|
template<typename I > |
using | iterator_value = meta::defer< iterator_value_t, I > |
|
template<typename I > |
using | iterator_value_t = concepts::Readable::value_t< I > |
|
template<typename I , typename S > |
using | IteratorRange = Sentinel< S, I > |
|
template<typename Rng > |
using | keys_range_view = transform_view< Rng, detail::get_first > |
|
template<typename T > |
using | LvalueContainerLike = concepts::models< concepts::LvalueContainerLike, T > |
|
template<typename I0 , typename I1 , typename Out , typename C = ordered_less, typename P0 = ident, typename P1 = ident> |
using | 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 | Mismatchable = meta::strict_and< InputIterator< I1 >, InputIterator< I2 >, IndirectCallablePredicate< C, projected< I1, P1 >, projected< I2, P2 >>> |
|
template<typename T > |
using | Movable = concepts::models< concepts::Movable, T > |
|
template<typename I > |
using | move_into_iterator = basic_iterator< detail::move_into_cursor< I >, default_end_cursor > |
|
template<typename I > |
using | move_iterator = basic_iterator< detail::move_cursor< I >, default_end_cursor > |
|
template<typename T > |
using | MoveConstructible = concepts::models< concepts::MoveConstructible, T > |
|
template<typename I0 , typename I1 , typename Out , typename C = ordered_less, typename P0 = ident, typename P1 = ident> |
using | 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 | OutputIterator = concepts::models< concepts::OutputIterator, Out, T > |
|
template<typename T , typename V > |
using | OutputRange = concepts::models< concepts::OutputRange, T, V > |
|
template<typename T , typename V > |
using | OutputView = concepts::models< concepts::OutputView, T, V > |
|
template<typename I , typename O , typename C = ordered_less, typename PI = ident, typename PO = ident> |
using | 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 O , typename BOp = plus, typename P = ident, typename V = iterator_value_t<I>, typename X = concepts::Callable::result_t<P, V>, typename Y = concepts::Callable::result_t<BOp, X, X>> |
using | PartialSummable = meta::strict_and< InputIterator< I >, OutputIterator< O, X && >, Callable< P, V >, CopyConstructible< uncvref_t< X >>, Callable< BOp, X, X >, Assignable< uncvref_t< X > &, Y >> |
|
template<typename I , typename C , typename P = ident> |
using | 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 | 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 | Permutable = meta::strict_and< ForwardIterator< I >, IndirectlySwappable< I, I >, IndirectlyMovableStorable< I, I >> |
|
template<typename Fun , typename... Args> |
using | Predicate = concepts::models< concepts::Predicate, Fun, Args... > |
|
template<typename I , typename Proj > |
using | projected = meta::if_< IndirectCallable< Proj, I >, detail::projected_readable< I, Proj >> |
|
template<typename T > |
using | RandomAccessIncrementable = concepts::models< concepts::RandomAccessIncrementable, T > |
|
template<typename I > |
using | RandomAccessIterator = concepts::models< concepts::RandomAccessIterator, I > |
|
template<typename T > |
using | RandomAccessRange = concepts::models< concepts::RandomAccessRange, T > |
|
template<typename C > |
using | RandomAccessReservable = meta::strict_and< Reservable< C >, RandomAccessRange< C >> |
|
template<typename T > |
using | RandomAccessView = concepts::models< concepts::RandomAccessView, T > |
|
template<typename T > |
using | Range = concepts::models< concepts::Range, T > |
|
template<typename Rng > |
using | range_category = meta::defer< range_category_t, Rng > |
|
template<typename Rng > |
using | range_category_t = concepts::InputRange::category_t< Rng > |
|
template<typename Rng > |
using | range_common_iterator_t = common_iterator< range_iterator_t< Rng >, range_sentinel_t< Rng >> |
|
template<typename Rng > |
using | range_common_reference = meta::defer< range_common_reference_t, Rng > |
|
template<typename Rng > |
using | range_common_reference_t = concepts::InputRange::common_reference_t< Rng > |
|
template<typename T > |
using | range_concept = concepts::most_refined< meta::list< concepts::RandomAccessRange, concepts::BidirectionalRange, concepts::ForwardRange, concepts::InputRange >, T > |
|
template<typename T > |
using | range_concept_t = meta::_t< range_concept< T >> |
|
template<typename Rng > |
using | range_difference = meta::defer< range_difference_t, Rng > |
|
template<typename Rng > |
using | range_difference_t = concepts::Range::difference_t< Rng > |
|
template<typename Rng > |
using | range_iterator = meta::defer< range_iterator_t, Rng > |
|
template<typename Rng > |
using | range_iterator_t = concepts::Range::iterator_t< Rng > |
|
template<typename Rng > |
using | range_reference = meta::defer< range_reference_t, Rng > |
|
template<typename Rng > |
using | range_reference_t = concepts::InputRange::reference_t< Rng > |
|
template<typename Rng > |
using | range_rvalue_reference = meta::defer< range_rvalue_reference_t, Rng > |
|
template<typename Rng > |
using | range_rvalue_reference_t = concepts::InputRange::rvalue_reference_t< Rng > |
|
template<typename Rng > |
using | range_safe_iterator_t = decltype(ranges::safe_begin(std::declval< Rng >())) |
|
template<typename Rng > |
using | range_safe_sentinel_t = decltype(ranges::safe_end(std::declval< Rng >())) |
|
template<typename Rng > |
using | range_sentinel = meta::defer< range_sentinel_t, Rng > |
|
template<typename Rng > |
using | range_sentinel_t = concepts::Range::sentinel_t< Rng > |
|
template<typename Rng > |
using | range_size = meta::defer< range_size_t, Rng > |
|
template<typename Rng > |
using | range_size_t = meta::_t< std::make_unsigned< range_difference_t< Rng >>> |
|
template<typename Rng > |
using | range_value = meta::defer< range_value_t, Rng > |
|
template<typename Rng > |
using | range_value_t = concepts::InputRange::value_t< Rng > |
|
template<typename T > |
using | Readable = concepts::models< concepts::Readable, T > |
|
template<typename T > |
using | ref_t = decltype(ref(std::declval< T >())) |
|
template<typename T > |
using | reference_of_t = meta::_t< reference_of< T >> |
|
template<typename T > |
using | Regular = concepts::models< concepts::Regular, T > |
|
template<typename Fun , typename... Args> |
using | RegularCallable = concepts::models< concepts::RegularCallable, Fun, Args... > |
|
template<typename Fun , typename... Args> |
using | RegularFunction = concepts::models< concepts::RegularFunction, Fun, Args... > |
|
template<typename Fun , typename T , typename U = T> |
using | Relation = concepts::models< concepts::Relation, Fun, T, U > |
|
template<typename I , typename T , typename P = ident> |
using | 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 | RemovableIf = meta::strict_and< ForwardIterator< I >, IndirectCallablePredicate< C, projected< I, P >>, Permutable< I >> |
|
template<typename I , typename O , typename T , typename P = ident> |
using | 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 | RemoveCopyableIf = meta::strict_and< InputIterator< I >, WeaklyIncrementable< O >, IndirectCallablePredicate< C, projected< I, P >>, IndirectlyCopyable< I, O >> |
|
template<typename Rng , typename Pred , typename Val > |
using | replace_if_view = iter_transform_view< Rng, detail::replacer_if_fn< Pred, Val >> |
|
template<typename Rng , typename Val1 , typename Val2 > |
using | replace_view = iter_transform_view< Rng, detail::replacer_fn< Val1, Val2 >> |
|
template<typename I , typename T0 , typename T1 , typename P = ident> |
using | 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 | 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 | 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 | ReplaceIfable = meta::strict_and< InputIterator< I >, IndirectCallablePredicate< C, projected< I, P >>, Writable< I, T const & >> |
|
template<typename C > |
using | Reservable = concepts::models< concepts::Reservable, C > |
|
template<typename C , typename I > |
using | ReserveAndAssignable = concepts::models< concepts::ReserveAndAssignable, C, I > |
|
template<typename Sig > |
using | result_of_t = meta::_t< std::result_of< Sig >> |
|
template<typename I > |
using | reverse_iterator = basic_iterator< detail::reverse_cursor< I >, detail::reverse_cursor< I >> |
|
template<typename I , typename O > |
using | ReverseCopyable = meta::strict_and< BidirectionalIterator< I >, WeaklyIncrementable< O >, IndirectlyCopyable< I, O >> |
|
template<typename T > |
using | rref_t = decltype(rref(std::declval< T >())) |
|
template<typename T > |
using | rvalue_reference_wrapper = reference_wrapper< T, true > |
|
template<typename... Ts> |
using | Same = concepts::Same::same_t< Ts... > |
|
template<typename I1 , typename I2 , typename C = equal_to, typename P1 = ident, typename P2 = ident> |
using | Searchable = meta::strict_and< ForwardIterator< I1 >, ForwardIterator< I2 >, Comparable< I1, I2, C, P1, P2 >> |
|
template<typename I , typename V , typename C = equal_to, typename P = ident> |
using | Searchnable = meta::strict_and< ForwardIterator< I >, IndirectCallableRelation< C, projected< I, P >, V const * >> |
| ingroup group-concepts
|
|
template<typename T > |
using | SemiContainer = concepts::models< concepts::SemiContainer, T > |
|
template<typename T > |
using | SemiRegular = concepts::models< concepts::SemiRegular, T > |
|
template<typename T , bool IsConst = false> |
using | semiregular_ref_or_val_t = meta::if_< SemiRegular< T >, meta::if_c< IsConst, T, reference_wrapper< T > >, reference_wrapper< meta::if_c< IsConst, semiregular< T > const, semiregular< T >>>> |
|
template<typename T > |
using | semiregular_t = meta::if_< SemiRegular< T >, T, semiregular< T >> |
|
template<typename S , typename I > |
using | Sentinel = concepts::models< concepts::Sentinel, S, I > |
|
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 > |
using | set_difference_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_difference_cursor, detail::set_difference_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)> |
|
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 > |
using | set_intersection_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_intersection_cursor, detail::set_intersection_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)> |
|
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 > |
using | set_symmetric_difference_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_symmetric_difference_cursor, detail::set_symmetric_difference_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)> |
|
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 > |
using | set_union_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_union_cursor, detail::set_union_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)> |
|
template<typename T > |
using | SignedIntegral = concepts::models< concepts::SignedIntegral, T > |
|
template<typename I > |
using | SinglePass = meta::strict_and< Iterator< I >, meta::not_< ForwardIterator< I >>> |
|
template<typename T > |
using | sized_range_concept = concepts::most_refined< meta::list< concepts::SizedRange, concepts::Range >, T > |
|
template<typename T > |
using | sized_range_concept_t = meta::_t< sized_range_concept< T >> |
|
template<typename S , typename I > |
using | sized_sentinel_concept = concepts::most_refined< meta::list< concepts::SizedSentinel, concepts::Sentinel >, S, I > |
|
template<typename S , typename I > |
using | sized_sentinel_concept_t = meta::_t< sized_sentinel_concept< S, I >> |
|
template<typename T > |
using | sized_view_concept = concepts::most_refined< meta::list< concepts::SizedView, concepts::View >, T > |
|
template<typename T > |
using | sized_view_concept_t = meta::_t< sized_view_concept< T >> |
|
template<typename I , typename S > |
using | SizedIteratorRange = SizedSentinel< S, I > |
|
template<typename T > |
using | SizedRange = concepts::models< concepts::SizedRange, T > |
|
template<typename S , typename I > |
using | SizedSentinel = concepts::models< concepts::SizedSentinel, S, I > |
|
template<typename T > |
using | SizedView = concepts::models< concepts::SizedView, T > |
|
template<typename I , typename C = ordered_less, typename P = ident> |
using | 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 | StablePartitionable = meta::strict_and< ForwardIterator< I >, Permutable< I >, IndirectCallablePredicate< C, projected< I, P >>> |
|
template<typename T , typename U = T> |
using | Swappable = concepts::models< concepts::Swappable, T, U > |
|
template<typename F , typename S > |
using | tagged_pair = tagged< std::pair< detail::tag_elem< F >, detail::tag_elem< S >>, detail::tag_spec< F >, detail::tag_spec< S >> |
|
template<typename... Ts> |
using | tagged_tuple = tagged< std::tuple< detail::tag_elem< Ts >... >, detail::tag_spec< Ts >... > |
|
template<typename Rng > |
using | take_exactly_view = detail::take_exactly_view_< Rng > |
|
template<typename T , typename U = T> |
using | 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 | 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 | Transformable2 = meta::strict_and< InputIterator< I0 >, InputIterator< I1 >, WeaklyIncrementable< O >, IndirectCallable< F, projected< I0, P0 >, projected< I1, P1 >>, Writable< O, Y && >> |
|
template<typename Tup > |
using | tuple_indices_t = meta::make_index_sequence< std::tuple_size< typename std::remove_reference< Tup >::type >::value > |
|
template<typename T > |
using | uncvref_t = meta::_t< std::remove_cv< meta::_t< std::remove_reference< T >>>> |
|
template<typename Gen > |
using | UniformRandomNumberGenerator = concepts::models< concepts::UniformRandomNumberGenerator, Gen > |
|
template<typename Rng > |
using | unique_view = adjacent_filter_view< Rng, not_equal_to > |
|
template<typename I , typename O , typename C = equal_to, typename P = ident> |
using | 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 | UnsignedIntegral = concepts::models< concepts::UnsignedIntegral, T > |
|
template<typename T > |
using | unwrap_reference_t = decltype(unwrap_reference(std::declval< T >())) |
|
template<typename Rng > |
using | values_view = transform_view< Rng, detail::get_second > |
|
template<typename T > |
using | View = concepts::models< concepts::View, T > |
|
template<typename T > |
using | view_concept = concepts::most_refined< meta::list< concepts::View, concepts::Range >, T > |
|
template<typename T > |
using | view_concept_t = meta::_t< view_concept< T >> |
|
template<typename RangeFacade > |
using | view_facade_t = meta::_t< range_access::view_facade< RangeFacade >> |
|
template<typename T , typename U > |
using | WeaklyEqualityComparable = concepts::models< concepts::WeaklyEqualityComparable, T, U > |
|
template<typename T > |
using | WeaklyIncrementable = concepts::models< concepts::WeaklyIncrementable, T > |
|
template<typename T , typename U = T> |
using | WeaklyOrdered = concepts::models< concepts::WeaklyOrdered, T, U > |
|
template<typename Out , typename T > |
using | Writable = concepts::models< concepts::Writable, Out, T > |
|
|
template<typename T > |
constexpr T * | _nullptr_v () |
|
template<typename T > |
meta::if_c< std::is_reference< T >)||Copyable< T >), T > | any_cast (any &) |
|
template<typename T > |
meta::if_c< std::is_reference< T >)||Copyable< T >), T > | any_cast (any const &) |
|
template<typename T > |
meta::if_c< std::is_reference< T >)||Copyable< T >), T > | any_cast (any &&) |
|
template<typename T > |
T * | any_cast (any *) noexcept |
|
template<typename T > |
T const * | any_cast (any const *) noexcept |
|
template<typename T , typename U = meta::if_< std::is_lvalue_reference<T>, std::reference_wrapper<meta::_t<std::remove_reference<T>>>, T &&>> |
U | bind_forward (meta::_t< std::remove_reference< T >> &t) noexcept |
|
template<typename T > |
T && | bind_forward (meta::_t< std::remove_reference< T >> &&t) noexcept |
|
template<typename T > |
T & | get (meta::id_t< T > &value) |
|
template<typename T > |
T const & | get (meta::id_t< T > const &value) |
|
template<typename T > |
T && | get (meta::id_t< T > &&value) |
|
template<typename T > |
T & | get (meta::id_t< semiregular< T >> &t) |
|
template<typename T > |
T const & | get (meta::id_t< semiregular< T >> const &t) |
|
template<typename T > |
T && | get (meta::id_t< semiregular< T >> &&t) |
|
template<std::size_t N, typename I , typename S , int _concept_requires___LINE__ = 42> |
constexpr auto | get (sized_iterator_range< I, S > const &p) -> decltype(ranges::get< N >(static_cast< iterator_range< I, S > const & >(p))) |
| Tuple-like access for sized_iterator_range
|
|
template<std::size_t N, typename I , typename S , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(N==2), int >::type = 0> |
constexpr iterator_size_t< I > | get (sized_iterator_range< I, S > const &p) |
|
template<typename Tag , typename Element , detail::box_compress BC> |
Element & | get (box< Element, Tag, BC > &b) noexcept |
|
template<typename Tag , typename Element , detail::box_compress BC> |
constexpr Element const & | get (box< Element, Tag, BC > const &b) noexcept |
|
template<typename Tag , typename Element , detail::box_compress BC> |
Element && | get (box< Element, Tag, BC > &&b) noexcept |
|
template<std::size_t I, typename Element , detail::box_compress BC> |
Element & | get (box< Element, meta::size_t< I >, BC > &b) noexcept |
|
template<std::size_t I, typename Element , detail::box_compress BC> |
constexpr Element const & | get (box< Element, meta::size_t< I >, BC > const &b) noexcept |
|
template<std::size_t I, typename Element , detail::box_compress BC> |
Element && | get (box< Element, meta::size_t< I >, BC > &&b) noexcept |
|
template<typename Cont , typename P , typename I , typename S , typename C = common_iterator<I, S>, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(LvalueContainerLike< Cont >()&&Iterator< P >()&&Sentinel< S, I >()), int >::type = 0> |
auto | insert (Cont &&cont, P p, I i, S j) -> decltype(detail::insert_impl(std::forward< Cont >(cont), std::move(p), std::move(i), std::move(j), meta::strict_and< RandomAccessReservable< Cont >, SizedSentinel< S, I >> |
|
template<typename Cont , typename I , typename Rng , typename C = range_common_iterator_t<Rng>, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(LvalueContainerLike< Cont >()&&Iterator< I >()&&Range< Rng >()), int >::type = 0> |
auto | insert (Cont &&cont, I p, Rng &&rng) -> decltype(detail::insert_impl(std::forward< Cont >(cont), std::move(p), std::forward< Rng >(rng), meta::strict_and< RandomAccessReservable< Cont >, SizedRange< Rng >> |
|
template<typename Val > |
istream_range< Val > | istream (std::istream &sin) |
|
template<typename T > |
istream_range< T > | istream (std::istream &sin) |
|
template<typename I , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(Iterator< I >()), int >::type = 0> |
counted_iterator< I > | make_counted_iterator (I i, iterator_difference_t< I > n) |
|
template<typename V , typename I , typename D > |
counted_iterator< raw_storage_iterator< I, V >, detail::external_count< D > > | make_counted_raw_storage_iterator (I i, D &d) |
|
template<typename I > |
reverse_iterator< I > | make_reverse_iterator (I i) |
|
template<typename Tag1 , typename Tag2 , typename T1 , typename T2 , typename R = tagged_pair<Tag1(bind_element_t<T1>), Tag2(bind_element_t<T2>)>> |
constexpr R | make_tagged_pair (T1 &&t1, T2 &&t2) noexcept(std::is_nothrow_constructible< R, T1, T2 >::value) |
|
template<typename... Tags, typename... Ts> |
constexpr tagged_tuple< Tags(bind_element_t< Ts >)... > | make_tagged_tuple (Ts &&...ts) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) EqualityComparable< Ts, Us >()... >::value), int >::type = 0> |
bool | operator!= (common_tuple< Ts... > const &a, common_tuple< Us... > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) EqualityComparable< Ts, Us >()... >::value), int >::type = 0> |
bool | operator!= (std::tuple< Ts... > const &a, common_tuple< Us... > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) EqualityComparable< Ts, Us >()... >::value), int >::type = 0> |
bool | operator!= (common_tuple< Ts... > const &a, std::tuple< Us... > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(EqualityComparable< F1, F2 >()&&EqualityComparable< S1, S2 >()), int >::type = 0> |
bool | operator!= (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(EqualityComparable< F1, F2 >()&&EqualityComparable< S1, S2 >()), int >::type = 0> |
bool | operator!= (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(EqualityComparable< F1, F2 >()&&EqualityComparable< S1, S2 >()), int >::type = 0> |
bool | operator!= (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b) |
|
template<typename I , typename S , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(Sentinel< S, I >()), int >::type = 0> |
bool | operator!= (move_iterator< S > const &i, move_sentinel< S > const &s) |
|
template<typename I , typename S , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(Sentinel< S, I >()), int >::type = 0> |
bool | operator!= (move_sentinel< S > const &s, move_iterator< S > const &i) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0> |
bool | operator< (common_tuple< Ts... > const &a, std::tuple< Us... > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0> |
bool | operator< (common_tuple< Ts... > const &a, common_tuple< Us... > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0> |
bool | operator< (std::tuple< Ts... > const &a, common_tuple< Us... > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0> |
bool | operator< (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0> |
bool | operator< (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0> |
bool | operator< (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0> |
bool | operator<= (common_tuple< Ts... > const &a, common_tuple< Us... > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0> |
bool | operator<= (std::tuple< Ts... > const &a, common_tuple< Us... > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0> |
bool | operator<= (common_tuple< Ts... > const &a, std::tuple< Us... > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0> |
bool | operator<= (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0> |
bool | operator<= (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0> |
bool | operator<= (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) EqualityComparable< Ts, Us >()... >::value), int >::type = 0> |
bool | operator== (common_tuple< Ts... > const &a, std::tuple< Us... > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) EqualityComparable< Ts, Us >()... >::value), int >::type = 0> |
bool | operator== (std::tuple< Ts... > const &a, common_tuple< Us... > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) EqualityComparable< Ts, Us >()... >::value), int >::type = 0> |
bool | operator== (common_tuple< Ts... > const &a, common_tuple< Us... > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(EqualityComparable< F1, F2 >()&&EqualityComparable< S1, S2 >()), int >::type = 0> |
bool | operator== (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(EqualityComparable< F1, F2 >()&&EqualityComparable< S1, S2 >()), int >::type = 0> |
bool | operator== (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(EqualityComparable< F1, F2 >()&&EqualityComparable< S1, S2 >()), int >::type = 0> |
bool | operator== (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b) |
|
template<typename I , typename S , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(Sentinel< S, I >()), int >::type = 0> |
bool | operator== (move_iterator< I > const &i, move_sentinel< S > const &s) |
|
template<typename I , typename S , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(Sentinel< S, I >()), int >::type = 0> |
bool | operator== (move_sentinel< S > const &s, move_iterator< S > const &i) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0> |
bool | operator> (common_tuple< Ts... > const &a, std::tuple< Us... > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0> |
bool | operator> (std::tuple< Ts... > const &a, common_tuple< Us... > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0> |
bool | operator> (common_tuple< Ts... > const &a, common_tuple< Us... > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0> |
bool | operator> (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0> |
bool | operator> (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0> |
bool | operator> (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0> |
bool | operator>= (std::tuple< Ts... > const &a, common_tuple< Us... > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0> |
bool | operator>= (common_tuple< Ts... > const &a, std::tuple< Us... > const &b) |
|
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0> |
bool | operator>= (common_tuple< Ts... > const &a, common_tuple< Us... > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0> |
bool | operator>= (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0> |
bool | operator>= (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b) |
|
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0> |
bool | operator>= (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b) |
|
template<typename Arg , typename Pipe , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(!is_pipeable< Arg >()&&is_pipeable< Pipe >()), int >::type = 0> |
auto | operator| (Arg &&arg, Pipe pipe) -> decltype(pipeable_access::impl< Pipe >::pipe(std::forward< Arg >(arg), pipe)) |
|
template<typename Pipe0 , typename Pipe1 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(is_pipeable< Pipe0 >()&&is_pipeable< Pipe1 >()), int >::type = 0> |
auto | operator| (Pipe0 pipe0, Pipe1 pipe1) -> decltype(make_pipeable(detail::composed_pipe< Pipe0, Pipe1 > |
|
template<template< typename... > class ContT> |
detail::to_container_fn< meta::quote< ContT > > | to_ () |
| For initializing a container of the specified type with the elements of an Range.
|
|
template<template< typename... > class ContT, typename Rng , typename Cont = meta::invoke<meta::quote<ContT>, range_value_t<Rng>>, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(Range< Rng >()&&detail::ConvertibleToContainer< Rng, Cont >()), int >::type = 0> |
Cont | to_ (Rng &&rng) |
|
template<template< typename... > class ContT, typename T , typename Cont = meta::invoke<meta::quote<ContT>, T>, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(detail::ConvertibleToContainer< std::initializer_list< T >, Cont >()), int >::type = 0> |
Cont | to_ (std::initializer_list< T > list) |
|
template<typename Cont > |
detail::to_container_fn< meta::id< Cont > > | to_ () |
|
template<typename Cont , typename Rng , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(Range< Rng >()&&detail::ConvertibleToContainer< Rng, Cont >()), int >::type = 0> |
Cont | to_ (Rng &&rng) |
|
template<typename Cont , typename T , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(detail::ConvertibleToContainer< std::initializer_list< T >, Cont >()), int >::type = 0> |
Cont | to_ (std::initializer_list< T > list) |
|