| Home | Libraries | People | FAQ | More

##### fold

###### Description

For a sequence `seq`, initial state `initial_state`, and binary function object or function pointer `f`, fold returns the result of the repeated application of binary `f` to the result of the previous `f` invocation (`inital_state` if it is the first call) and each element of `seq`.

###### 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.37. Parameters

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

###### Expression Semantics

    fold(seq, initial_state, f);

Return type: Any type

Semantics: Equivalent to `f(... f(f(initial_state,e1),e2) ...eN)` 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 std::string& str, const T& t) const
        {
            return str + boost::lexical_cast<std::string>(t);
        }
    };
    ...
    const vector<int,int> vec(1,2);
    assert(fold(vec,std::string(""), make_string()) == "12");