brigand::lazy Namespace Reference

Classes
struct	count_if
struct	count_if< S< Ts... >, Pred >
struct	count_if< S<>, Pred >
struct	filter
struct	filter< L< Ts... >, Pred >
struct	find
struct	find< Sequence< Ls... >, bind< F, _1 > >
struct	find< Sequence< Ls... >, Pred >
struct	inherit_linearly
struct	inherit_linearly< Types, Node< Ts... >, Root >
struct	join
struct	join< L< Ts... > >
struct	lookup
struct	pop_front
struct	push_front
struct	remove
struct	remove< L< Ts... >, T >
struct	remove_if
struct	remove_if< L< Ts... >, Pred >
struct	replace_if
struct	replace_if< S< Ts... >, Predicate, NewType >
struct	transform
struct	wrap
struct	wrap< A< T... >, B >

Typedefs
template<typename... Ts>
using	append = detail::append_impl< Ts... >
template<typename L , typename I >
using	split_at = ::brigand::detail::call_split_at_impl< L, I >
template<typename L >
using	reverse = typename detail::reverse_impl< L >
template<typename Sequence , typename Predicate = detail::non_null>
using	reverse_find = ::brigand::lazy::reverse<::brigand::find< brigand::reverse< Sequence >, Predicate > >
template<typename Sequence >
using	flatten = typename detail::flatten_impl< Sequence >
template<class Sequence , class State , class Functor >
using	fold = typename detail::fold_impl< Functor, State, Sequence >
template<class Sequence , class State , class Functor >
using	reverse_fold = typename detail::reverse_fold_impl< Functor, State, Sequence >
template<typename Sequence , typename OldType , typename NewType >
using	replace = replace_if< Sequence, std::is_same< _1, pin< OldType > >, NewType >
template<typename TList , typename TDelim >
using	split = detail::split_helper< TList, TDelim >
template<template< class > class F, class N , class T >
using	repeat = typename detail::repeat_impl< F, N::value, T >

Typedef Documentation

append

template<typename... Ts>

using brigand::lazy::append = typedef detail::append_impl<Ts...>

flatten

template<typename Sequence >

using brigand::lazy::flatten = typedef typename detail::flatten_impl<Sequence>

fold

template<class Sequence , class State , class Functor >

using brigand::lazy::fold = typedef typename detail::fold_impl<Functor, State, Sequence>

repeat

template<template< class > class F, class N , class T >

using brigand::lazy::repeat = typedef typename detail::repeat_impl<F, N::value, T>

replace

template<typename Sequence , typename OldType , typename NewType >

using brigand::lazy::replace = typedef replace_if<Sequence, std::is_same<_1, pin<OldType> >, NewType>

reverse

template<typename L >

using brigand::lazy::reverse = typedef typename detail::reverse_impl<L>

reverse_find

template<typename Sequence , typename Predicate = detail::non_null>

using brigand::lazy::reverse_find = typedef ::brigand::lazy::reverse<::brigand::find<brigand::reverse<Sequence>, Predicate> >

reverse_fold

template<class Sequence , class State , class Functor >

using brigand::lazy::reverse_fold = typedef typename detail::reverse_fold_impl<Functor, State, Sequence>

split

template<typename TList , typename TDelim >

using brigand::lazy::split = typedef detail::split_helper<TList, TDelim>

split_at

template<typename L , typename I >

using brigand::lazy::split_at = typedef ::brigand::detail::call_split_at_impl<L, I>