//ChangeLog:
//  2010-10-06.1207 CST
//    WHAT:
//      Followed Christopher's suggestions in post:
//        http://article.gmane.org/gmane.comp.lib.boost.user/62731
//    RESULT:
//      Compiles with variadic fusion; however, still fails compile
//      without variadic fusion.
//      
//WARNING@2010-09-29:
//  1) Don't try to compile this code with that from:
/*
http://svn.boost.org/svn/boost/sandbox/variadic_templates/
 */
//    otherwise, you'll get a compile-time error about
//    mpl::vector0.
//
//  2) Only works with variadic fusion:
/*
http://svn.boost.org/svn/boost/sandbox/SOC/2009/fusion/
 */
//     otherwise, you'll get compile-time error in category_of.hpp
//     about joine_view<...>& not being class, struct, or union.
//
//Purpose:
//  Answer question in post:
//
//    http://article.gmane.org/gmane.comp.lib.boost.user/62386
//
//References:
//  [ffold]
//    http://www.boost.org/doc/libs/1_44_0/libs/fusion/doc/html
//      /fusion/algorithm/iteration/functions/fold.html
//
#include <boost/fusion/algorithm/iteration/fold.hpp>
#include <boost/fusion/view/joint_view.hpp>
#include <boost/fusion/container/vector.hpp>
#include <boost/fusion/sequence/io.hpp>
#include <boost/type_traits/remove_reference.hpp>

#include <iostream>

namespace fold_join
{
struct join_ftor
/**@brief
 *  Forward decl of functor for joining 2 fusion sequences.
 */
;
template<typename T,unsigned Index=0>
struct tu
{
    tu(T a_t):my_t(a_t){}
    T my_t;
    
        friend
      std::ostream&
    operator<<
      ( std::ostream& sout
      , tu const& x
      )
    {
        sout<<"tu<"<<Index<<">("<<x.my_t<<")";
        return sout;
    } 
};

}//exit fold_join namespace

namespace fold_join
{     
struct join_ftor
/**@brief
 *  modified from 'struct make_string' from [ffold].
 */
{
    template<typename Sig>
    struct result;

    template<typename Self, typename Lhs, typename Rhs>
    struct result<Self(Lhs,Rhs)>
    {
            typedef 
          boost::fusion::joint_view
          < typename boost::remove_reference<Lhs>::type
          , typename boost::remove_reference<Rhs>::type
          > 
        type
        ;
    };
        
    template<typename Lhs, typename Rhs>
    typename result<join_ftor const(Lhs&,Rhs&)>::type
    operator()(Lhs& lhs, Rhs& rhs)const
    {
            return boost::fusion::joint_view<
                    Lhs, Rhs
            >(lhs,rhs);
    }
        
};

}//exit fold_join namespace

using namespace boost;
using namespace fold_join;

int main(void)
{
    typedef fusion::vector<> t0;
    typedef fusion::vector<tu<int,1>, tu<char,1>, tu<double,1> > t1;
    typedef fusion::vector<tu<int,2>, tu<char,2>, tu<double,2> > t2;
    typedef fusion::vector<tu<int,3>, tu<char,3>, tu<double,3> > t3;

    t0 v0;
    t1 v1(100,'b',300.1);
    t2 v2(100,'b',300.1);
    t3 v3(100,'b',300.1);
    std::cout<<"v0="<<v0<<"\n";
  #if 0
    std::cout<<"v1="<<v1<<"\n";
    std::cout<<"v2="<<v2<<"\n";
    std::cout<<"v3="<<v3<<"\n";
  #endif
    fusion::vector<t1,t2,t3> vv(v1,v2,v3);
    std::cout<<"vv="<<vv<<"\n";
    join_ftor joiner;
    auto fold_vv=fusion::fold(vv,v0,joiner);
    std::cout
      <<"fold(vv,v0,join_ftor())="
      <<fold_vv
      <<"\n";
    return 0;
}