mpl11/fwd_2list_8hpp_source.html

 #ifndef BOOST_MPL11_FWD_LIST_HPP

 #define BOOST_MPL11_FWD_LIST_HPP


 #include <boost/mpl11/detail/config.hpp>

 #include <boost/mpl11/detail/std_size_t.hpp>

 #include <boost/mpl11/fwd/core.hpp>

 #include <boost/mpl11/fwd/foldable.hpp>

 #include <boost/mpl11/fwd/functional.hpp>

 #include <boost/mpl11/fwd/integer.hpp>

 #include <boost/mpl11/fwd/logical.hpp>


 namespace boost { namespace mpl11 {

     struct List BOOST_MPL11_IF_DOXYGEN({ });


     template <typename ...xs>

     struct list;


     template <typename ...xs>

     BOOST_MPL11_DOXYGEN_ALIAS(list_, list<box<xs>...>);


     template <typename x, typename xs>

     struct cons;


     template <typename xs, typename x>

     BOOST_MPL11_DOXYGEN_ALIAS(snoc, foldr<lift<cons>, list<x>, xs>);


     template <typename f, typename x>

     struct iterate;


     template <typename x>

     struct repeat;


     template <typename n, typename xs>

     struct take;


     template <detail::std_size_t n, typename xs>

     BOOST_MPL11_DOXYGEN_ALIAS(take_c, take<size_t<n>, xs>);


     namespace list_detail {

         template <typename predicate> struct take_while_op;

         template <typename predicate> struct filter_op;

     }


     template <typename predicate, typename xs>

     BOOST_MPL11_DOXYGEN_ALIAS(take_while,

                     foldr<list_detail::take_while_op<predicate>, list<>, xs>);


     template <typename predicate, typename xs>

     BOOST_MPL11_DOXYGEN_ALIAS(take_until,

         take_while<compose<lift<not_>, predicate>, xs>);


     template <typename xs>

     BOOST_MPL11_DOXYGEN_ALIAS(reverse, foldl<flip<lift<cons>>, list<>, xs>);


     template <typename predicate, typename xs>

     BOOST_MPL11_DOXYGEN_ALIAS(filter,

                         foldr<list_detail::filter_op<predicate>, list<>, xs>);


     template <typename f, typename state, typename xs>

     struct scanl;


     template <typename f, typename ...lists>

     struct zip_with;


     template <typename ...lists>

     BOOST_MPL11_DOXYGEN_ALIAS(zip, zip_with<lift<list>, lists...>);


     template <typename ...lists>

     struct concat;


     template <typename xs, typename start, typename stop>

     struct slice;


     template <typename xs, detail::std_size_t start, detail::std_size_t stop>

     BOOST_MPL11_DOXYGEN_ALIAS(slice_c, slice<xs, size_t<start>, size_t<stop>>);


     template <typename predicate, typename xs>

     struct sort_by;


     template <typename xs>

     struct init;

 }} // end namespace boost::mpl11


 #endif // !BOOST_MPL11_FWD_LIST_HPP

boost::mpl11::filter
Returns a List containing only the elements satisfying predicate.
Definition: list.hpp:109

boost::mpl11::box
Boxes its argument.
Definition: core.hpp:46

boost::mpl11::take_while
Returns the longest prefix of a List in which all elements satisfy the predicate. ...
Definition: list.hpp:95

functional.hpp
Forward declares the Functional module.

boost::mpl11::take_c
Equivalent to take, xs>.
Definition: list.hpp:82

core.hpp
Forward declares the Core module.

boost::mpl11::cons
A List created by prepending an element to an Iterable.
Definition: list.hpp:56

boost::mpl11::take_until
Equivalent to take_while with a negated predicate.
Definition: list.hpp:100

boost::mpl11::zip
Equivalent to zip_with, lists...>.
Definition: list.hpp:140

boost::mpl11::lift
Lifts a metafunction.
Definition: functional.hpp:155

integer.hpp
Forward declares the Integer datatype.

boost::mpl11::init
Returns the elements before the last one of a non-empty list.
Definition: list.hpp:177

boost::mpl11::slice
Returns a subrange of a list.
Definition: list.hpp:160

boost::mpl11::iterate
Returns an infinite List of repeated applications of f to x.
Definition: list.hpp:64

config.hpp
Manages configurable options of the library and defines utility macros.

boost::mpl11::concat
Concatenate several lists.
Definition: list.hpp:149

boost::mpl11::scanl
scanl is similar to foldl, but returns a List of successive reduced values from the left...
Definition: list.hpp:116

boost::mpl11::sort_by
Returns a list sorted with the predicate.
Definition: list.hpp:168

logical.hpp
Forward declares logical metafunctions.

std_size_t.hpp
Defines boost::mpl11::detail::std_size_t.

boost::mpl11::reverse
Returns a List with its elements in reverse order.
Definition: list.hpp:104

boost::mpl11::list
A List containing the given elements.
Definition: list.hpp:48

boost::mpl11::repeat
Returns an infinite List containing copies of x.
Definition: list.hpp:68

boost::mpl11::size_t
Alias to integer_c; provided for convenience.
Definition: integer.hpp:122

boost::mpl11::foldr
Right-associative fold of a structure using a binary operation.
Definition: foldable.hpp:56

BOOST_MPL11_IF_DOXYGEN
#define BOOST_MPL11_IF_DOXYGEN(...)
Macro expanding to its argument(s) when generating the documentation with Doxygen and to nothing othe...
Definition: config.hpp:45

boost::mpl11::compose
Returns the composition of several metafunction classes.
Definition: functional.hpp:213

boost::mpl11::snoc
A List created by appending an element to an Iterable.
Definition: list.hpp:60

boost::mpl11::list_
Constructor equivalent to list, except it takes unboxed arguments.
Definition: list.hpp:52

BOOST_MPL11_DOXYGEN_ALIAS
#define BOOST_MPL11_DOXYGEN_ALIAS(NAME,...)
Macro expanding to a struct when generating the documentation and to an alias otherwise.
Definition: config.hpp:56

boost::mpl11::flip
Returns a metafunction class invoking f with its two first arguments in reverse order.
Definition: functional.hpp:47

boost::mpl11::slice_c
Equivalent to slice, size_t>.
Definition: list.hpp:164

boost::mpl11::foldl
Left-associative fold of a structure using a binary operation.
Definition: foldable.hpp:62

boost::mpl11::zip_with
Returns a list of applications of f to the elements of the zipped lists, in lockstep.
Definition: list.hpp:136

boost::mpl11::take
Returns the first n elements of a List.
Definition: list.hpp:78

foldable.hpp
Forward declares the Foldable typeclass.