mpl11/fwd_2foldable_8hpp_source.html

 #ifndef BOOST_MPL11_FWD_FOLDABLE_HPP

 #define BOOST_MPL11_FWD_FOLDABLE_HPP


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

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

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

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

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

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

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

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


 namespace boost { namespace mpl11 {

     template <typename Datatype, typename = true_>

     struct Foldable;


     template <typename f, typename state, typename structure>

     struct foldr;


     template <typename f, typename structure>

     struct foldr1;


     template <typename f, typename state, typename structure>

     struct foldl;


     template <typename f, typename structure>

     struct foldl1;


     template <typename predicate, typename structure>

     BOOST_MPL11_DOXYGEN_ALIAS(all, foldr<

         compose<lift<and_>, predicate>,

         true_,

         structure

     >);


     template <typename structure>

     BOOST_MPL11_DOXYGEN_ALIAS(all_of, all<lift<id>, structure>);


     template <typename predicate, typename structure>

     BOOST_MPL11_DOXYGEN_ALIAS(none,

         all<compose<lift<not_>, predicate>, structure>);


     template <typename structure>

     BOOST_MPL11_DOXYGEN_ALIAS(none_of, none<lift<id>, structure>);


     template <typename predicate, typename structure>

     BOOST_MPL11_DOXYGEN_ALIAS(any, not_<none<predicate, structure>>);


     template <typename structure>

     BOOST_MPL11_DOXYGEN_ALIAS(any_of, any<lift<id>, structure>);


     template <typename structure>

     BOOST_MPL11_DOXYGEN_ALIAS(sum,

         foldr<lift<plus>, zero<Integer>, structure>);


     template <typename structure>

     BOOST_MPL11_DOXYGEN_ALIAS(product,

         foldr<lift<mult>, one<Integer>, structure>);


     template <typename predicate, typename structure>

     BOOST_MPL11_DOXYGEN_ALIAS(maximum_by,

         foldr1<bind<lift<if_>, predicate, arg<2>, arg<1>>, structure>);


     template <typename structure>

     BOOST_MPL11_DOXYGEN_ALIAS(maximum, foldr1<lift<max>, structure>);


     template <typename predicate, typename structure>

     BOOST_MPL11_DOXYGEN_ALIAS(minimum_by,

         foldr1<bind<lift<if_>, predicate, arg<1>, arg<2>>, structure>);


     template <typename structure>

     BOOST_MPL11_DOXYGEN_ALIAS(minimum, foldr1<lift<min>, structure>);


     template <typename f, typename structure>

     BOOST_MPL11_DOXYGEN_ALIAS(unpack,

         apply<foldl<lift<partial>, f, structure>>);

 }} // end namespace boost::mpl11


 #endif // !BOOST_MPL11_FWD_FOLDABLE_HPP

boost::mpl11::sum
Compute the sum of the elements of a structure.
Definition: foldable.hpp:140

functional.hpp
Forward declares the Functional module.

boost::mpl11::minimum
Returns the least element of a non-empty structure.
Definition: foldable.hpp:169

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

boost::mpl11::maximum
Returns the largest element of a non-empty structure.
Definition: foldable.hpp:157

integer.hpp
Forward declares the Integer datatype.

boost::mpl11::bind
Invokes f with the result of invoking each fs... with the arguments.
Definition: functional.hpp:266

bool.hpp
Forwards to boost/mpl11/fwd/integer.hpp.

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

logical.hpp
Forward declares logical metafunctions.

boost::mpl11::zero
Additive identity for the given Datatype.
Definition: monoid.hpp:63

boost::mpl11::unpack
Invokes a metafunction class with the contents of a structure.
Definition: foldable.hpp:180

monoid.hpp
Forward declares the Monoid typeclass.

boost::mpl11::all_of
Equivalent to all, structure>.
Definition: foldable.hpp:113

boost::mpl11::arg
Returns the nth of its arguments.
Definition: functional.hpp:294

boost::mpl11::none_of
Equivalent to none, structure>.
Definition: foldable.hpp:125

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

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

boost::mpl11::any_of
Equivalent to any, structure>.
Definition: foldable.hpp:135

boost::mpl11::any
Returns whether any element of the structure satisfies the predicate.
Definition: foldable.hpp:131

boost::mpl11::maximum_by
The largest element of a non-empty structure with respect to the given predicate. ...
Definition: foldable.hpp:153

boost::mpl11::one
Multiplicative identity for the given Datatype.
Definition: ring.hpp:63

boost::mpl11::minimum_by
The least element of a non-empty structure with respect to the given predicate.
Definition: foldable.hpp:165

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::apply
Invokes a metafunction class with the given arguments.
Definition: functional.hpp:39

boost::mpl11::product
Compute the product of the elements of a structure.
Definition: foldable.hpp:145

boost::mpl11::all
Returns whether all the elements of the structure satisfy the predicate.
Definition: foldable.hpp:109

boost::mpl11::not_
Returns the logical negation (!) of its argument.
Definition: logical.hpp:55

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

orderable.hpp
Forward declares the Orderable typeclass.

boost::mpl11::foldr1
Variant of foldr that has no base case, and thus may only be applied to non-empty structures...
Definition: foldable.hpp:79

boost::mpl11::none
Returns whether none of the elements of the structure satisfy the predicate.
Definition: foldable.hpp:121

ring.hpp
Forward declares the Ring typeclass.