//Purpose:
//  Investigate reasons why the composition of 2 proto transforms:
//    TR2(TR1(expr_valu0,state,data),state,data)
//  fails to compile whereas when in separate statements:
//    expr_type1 expr_valu1(TR1(expr_valu0,state,data));
//    TR2(expr_valu1,state,data);
//  the TR2 succeeds.
//Motivatione:
//  This failure of transform composition occurred in
//    pass_thru_tag_xform.cpp.~1.72~
//  with error msg:
/*
pass_thru_tag_xform.cpp:541: error: no match for call to '(lookahead::empty::xfrm_reduce_n) (boost::proto::exprns_::expr<boost::proto::tag::terminal, boost::proto::argsns_::term<lookahead::empty::tag_literal<literal_yes> >, 0l>, int&, int&)'
 */
#include <boost/proto/proto.hpp>
#include <boost/proto/transform.hpp>

using namespace boost::proto;

  template
  < unsigned I
  >
struct type_i
;
  template
  <
  >
struct type_i
  < 0
  >  
{
    type_i(void)
    {}
    type_i(type_i<0>const&)
    {}
    type_i(type_i<1>const&)
    {}
    operator type_i<1>()const
    ;
};  
  template
  <
  >
struct type_i
  < 1
  >  
{
    type_i(void)
    {}
    type_i(type_i<1>const&)
    {}
    type_i(type_i<0>const&)
    {}
    operator type_i<0>()const
    {
        return type_i<1>();
    }
};

type_i
  < 0
  >  
::
    operator type_i<1>()const
    {
        return type_i<1>();
    }

    typedef 
  terminal<type_i<0> > 
type_expr_type_i0;
    typedef 
  terminal<type_i<1> > 
type_expr_type_i1;
    typedef
  when
  < type_expr_type_i0
  , type_expr_type_i1::type(_value)
  > 
type_xfrm_i0_to_i1;
    typedef
  when
  < type_expr_type_i1
  , type_expr_type_i0::type(_value)
  > 
type_xfrm_i1_to_i0;

int main(void)
{
    int xfrm_state;
    int xfrm_data;
    
    type_xfrm_i0_to_i1 valu_xfrm_i0_to_i1;
    type_xfrm_i1_to_i0 valu_xfrm_i1_to_i0;
    type_i<0> const valu_i0;

    type_expr_type_i0::type valu_expr_type_i0_0={valu_i0};
    
    {//demonstrates success of proto transform composition
     //when *not* using temporaries.
        type_expr_type_i1::type valu_expr_type_i1_1
          ( valu_xfrm_i0_to_i1
            ( valu_expr_type_i0_0
            , xfrm_state
            , xfrm_data
            )
          );
        type_expr_type_i0::type valu_expr_type_i0_2
          ( valu_xfrm_i1_to_i0
            ( valu_expr_type_i1_1
            , xfrm_state
            , xfrm_data
            )
          );
          
    }
  #if 0
    {//demonstrates failure of proto transform composition
     //when using temporaries.
          type_expr_type_i0::type valu_expr_type_i0_2
          ( valu_xfrm_i1_to_i0
            ( valu_xfrm_i0_to_i1 
              ( valu_expr_type_i0_0
              , xfrm_state
              , xfrm_data
              )//produces temporary corresponding
               //to valu_expr_type_i1_1 above.
            , xfrm_state
            , xfrm_data
            )
          );
          
    }
  #endif
    {//demonstrate that pass_through transforms don't
     //suffer the same limitation.
          type_expr_type_i0 valu_expr_type_i0;
          type_expr_type_i0::type valu_expr_type_i0_2
          ( valu_expr_type_i0
            ( valu_expr_type_i0
              ( valu_expr_type_i0_0
              , xfrm_state
              , xfrm_data
              )//produces temporary corresponding
               //to valu_expr_type_i1_1 above
               //but of different type.
            , xfrm_state
            , xfrm_data
            )
          );
    }
    return 0;
}