#include <boost/fusion/container/vector.hpp>
#include <boost/fusion/algorithm/iteration/fold.hpp>
#include <boost/fusion/adapted/boost_array.hpp>
#include <boost/array.hpp>

namespace fusion = boost::fusion;

template <typename Array, typename T>
struct inc_array_size;

template <size_t N, typename T2>
struct inc_array_size<boost::array<T2, N>, T2>
{
    typedef boost::array<T2, N+1> type;
};

struct seq_to_array
{
    template <typename Sig>
    struct result;

    template <typename This, typename State, typename T>
    struct result<This(State, T)>
        : inc_array_size<State const&, T const&>
    {};

    template <typename This, typename State, typename T>
    struct result<This(State &, T &)>
        : inc_array_size<
            typename boost::remove_const<State>::type
          , typename boost::remove_const<T>::type
        >
    {};

    template <typename State, typename T>
    typename inc_array_size<State, T>::type
    operator()(State const& s, T const & t) const
    {
        typename inc_array_size<State, T>::type res;

        this->assign(res, s, t, 0);

        return res;
    }

    private:
        template <size_t N, typename State, typename T>
        void assign(boost::array<T, N> & res, State const & old, T const & t, int counter) const
        {
            if(counter == N) return;

            res[counter] = old[counter];

            this->assign(res, old, t, ++counter);
        }
        
};

int main()
{
    boost::array<double, 3> boostarr={{1.0, 2.1, 3.2}};
    fusion::vector<double, double, double> fusionvec(boostarr);

    boost::array<double, 3> boostarr2 = fusion::fold(fusionvec, boost::array<double, 0>(), seq_to_array());
}