fold with a fusion::vector initialized state

Applying boost::fusion::fold with a std::vector initial state works fine.

        #include <vector>
        #include <boost/fusion/container/map.hpp>
        #include <boost/fusion/container/vector.hpp>
        #include <boost/fusion/include/fold.hpp>
        struct A;
        struct B;
        struct C;
        int ia = 1, ib = 2, ic = 3;
        namespace fusion = boost::fusion;

        template< typename FusionIteratorT, typename Ret>
        struct initialize_map_with_fusion_vector {

            template<typename T>
            Ret operator()(FusionIteratorT& i,  T& val) {
                val = fusion::deref(i);
                return fusion::next(i);
            } 
        };

        void use_fold_with_std_vector() 
        {
            using M = fusion::map<fusion::pair<A, int>, fusion::pair<B, char>, fusion::pair<C, double>>;
            M fm;
            std::vector<int> sv = { ia, ib, ic };
            fusion::fold(fm, sv.begin(), 
                initialize_map_with_std_vector<std::vector<int>::iterator>());
        } 

int main() {use_fold_with_std_vector();}

When the same notion is applied to a fusion::vector however, the code fails to compile with the error no instance of overloaded function "boost::fusion::fold" matches the argument

    #include <vector>
    #include <boost/fusion/container/map.hpp>
    #include <boost/fusion/container/vector.hpp>
    #include <boost/fusion/include/fold.hpp>
    #include <boost/fusion/algorithm/iteration/fold.hpp>
    namespace fusion = boost::fusion;

    struct A;
    struct B;
    struct C;
    std::vector<int> va = { 4, 5, 6 };
    std::vector<char> vb = { 'a', 'b', 'c' };
    std::vector<double> vc = { 10., 11., 12. };    

    template< typename FusionIteratorT, typename Ret>
    struct initialize_map_with_fusion_vector {

        template<typename T>
        Ret operator()(FusionIteratorT& i,  T& val) {
            val = fusion::deref(i);
            return fusion::next(i);
        } 
    };

    void use_fold_with_fusion_vector() {
        using M = fusion::map<fusion::pair<A, std::vector<int>>, fusion::pair<B, std::vector<char>>, fusion::pair<C, std::vector<double>>>;
        using V = fusion::vector<std::vector<int>, std::vector<char>, std::vector<double>>;
        auto fm = M();
        auto fv = V(va, vb, vc);
        using FusionIteratorT = decltype(fusion::begin(fv));
        using Ret = fusion::result_of::next<fusion::result_of::begin<decltype(fv)>::type>::type;
        fusion::fold(fm, fusion::begin(fv),
            initialize_map_with_fusion_vector<FusionIteratorT, Ret > ());
}

int main() {use_fold_with_fusion_vector();}

How can I make fusion::fold work with a fusion::vector initializer?