| Home | Libraries | People | FAQ | More

##### fold

###### Description

For a sequence `Seq`, initial state, and binary function object or function pointer `f`, fold repeatedly applies binary `f` to each element of `Seq` and the previous state.

###### Synopsis

    template<
        typename Sequence,
        typename State,
        typename F
        >
    typename result_of::fold<Sequence, State, F>::type fold(
        Sequence& seq, State const& initial_state, F const& f);

Table 1.33. Parameters

Parameter | Requirement | Description
--- | --- | ---
`seq` | A model of Forward Sequence,`f(e,s)` must be a valid expression for each element `e` in `seq`, and current state `s` | Operation's argument
`initial_state` | Any type | Initial state
`f` | ``boost::result_of`<F(E,S)>::type` is the return type of `f(e,s)` for each element `e` of type `E` in `seq`, and current state `s` of type `S` | Operation's argument

###### Expression Semantics

    fold(seq, initial_state, f);

Return type: Any type

Semantics: Equivalent to `f(eN ....f(e2,f(e1,initial_state)))` where `e1 ...eN` are the elements of `seq`.

###### Complexity

Linear, exactly ``result_of::size`<Sequence>::value` applications of `f`.

###### Header

    #include <boost/fusion/algorithm/iteration/fold.hpp>
    #include <boost/fusion/include/fold.hpp>

###### Example

    struct make_string
    {
        typedef std::string result_type;

        template<typename T>
        std::string operator()(const T& t, const std::string& str) const
        {
            return str + boost::lexical_cast<std::string>(t);
        }
    };
    ...
    const vector<int,int> vec(1,2);
    assert(fold(vec,std::string(""), make_string()) == "12");