I had a similar problem - I needed to iterate over elements of a map and find each element's index. It works by using template recursion, iterating from the start of the sequence, with the exit specialization being when the type of the current element being iterated over is the same as the type of the element in the sequence you are working with. A natural side effect of this is that the types in the sequence need to be unique, otherwise later duplicate types will get their index to be the index of the first element in the sequence with the same type. Here is my code, it may help (I posted this on stackoverflow here: http://stackoverflow.com/questions/11698413/find-the-index-of-an-element-in-... ) #include <iostream> #include #include #include #include #include #include #include #include #include #include #include namespace fusion = boost::fusion; namespace mpl = boost::mpl; // given a field, returns a fusion pair of template<class field> struct make_pair { typedef typename fusion::result_of::make_pair::type type; }; // given a sequence of fields, returns a fusion map which maps field -> field::type template struct make_map { typedef typename fusion::result_of::as_map, make_pairmpl::_1>::type>::type type; }; //------------------------------------------------------------------------------------------- // iterate through a fusion map to find the index of a given key template struct key_index { typedef typename fusion::result_of::next<iter>::type next_iter; typedef typename fusion::result_of::key_of::type next_key; enum { value = 1 + key_index::value }; }; template struct key_index { enum { value = 0 }; }; //------------------------------------------------------------------------------------------- // copy an element from a vector to a map, if the index in the vector exists template struct do_copy { template<typename T> void operator()(const vector& v, const T& dest) { const_cast(dest) = fusion::at_c<index>(v); } }; template struct do_copy { template<typename T> void operator()(const vector&, const T&) { } }; //------------------------------------------------------------------------------------------- // initialise a map with the corresponding elements in a vector, vector may be smaller than the map template struct init { init(const vector& v) : _v(v) {} template <typename pair> void operator()(const pair& data) const { typedef typename fusion::result_of::begin<map>::type begin_iter; typedef typename fusion::result_of::key_of::type key_type; enum { index = key_index::value }; enum { in_vec = fusion::result_of::size<vector>::type::value > index }; do_copy()(_v, data.second); } private: const vector& _v; }; //------------------------------------------------------------------------------------------- struct field1 { typedef std::string type; }; struct field2 { typedef int type; }; struct field3 { typedef double type; }; struct field4 { typedef std::string type; }; struct field5 { typedef int type; }; struct field6 { typedef double type; }; struct my_map { template my_map(args... a) { typedef typename fusion::vector vector; fusion::for_each(_map, init(vector(a...))); } typedef typename make_map::type map; map _map; }; struct print { template <typename pair> void operator()(pair const& data) const { std::cout << data.second << " "; } }; //------------------------------------------------------------------------------------------- int main() { my_map m("hello world", 5, 2.4); fusion::for_each(m._map, print()); std::cout << std::endl; return 0; }