#include <iostream>
#include <boost/proto/proto.hpp>
#include <boost/proto/proto_typeof.hpp>

namespace mpl = boost::mpl;
namespace proto = boost::proto;
namespace fusion = boost::fusion;
using proto::_;

struct placeholder
{
   friend std::ostream &operator <<(std::ostream &sout, placeholder)
   {
       return sout << "var_";
   }
};

proto::terminal<placeholder>::type const var_ = {{}};

// Work around annoyng msvc compiler bugs ...
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
#define _left(x) call<proto::_left(x)>
#define _right(x) call<proto::_right(x)>
#define _make_minus(x,y) call<proto::_make_minus(x,y)>
#define _make_assign(x,y) call<proto::_make_assign(x,y)>
#endif

struct Solve
   : proto::or_<
       // Solved:
       proto::assign<proto::terminal<placeholder>, _>
       // Rewrite "var_ + x = y" to "var_ = y - x"
       , proto::when<
            proto::assign< 
                proto::plus< proto::terminal<placeholder>, _>, _ >
            , proto::_make_assign( 
                proto::_left(proto::_left) , 
                proto::_make_minus( proto::_right, proto::_right(proto::_left) ) 
            ) 
       >
       // Rewrite "x + var_ = y" to "var_ = y - x"
       , proto::when<
            proto::assign< 
                proto::plus< _, proto::terminal<placeholder>>, _ >
            , proto::_make_assign( 
                proto::_right(proto::_left) , 
                proto::_make_minus( proto::_right, proto::_left(proto::_left) ) 
            ) 
       >
       // Rewrite "x + ? = y" to "Solve(? = y - x)"
       , proto::when<
            proto::assign< 
                proto::plus< proto::terminal<_>, _>, _ >
            , Solve(
                proto::_make_assign( 
                    proto::_right(proto::_left) , 
                    proto::_make_minus( proto::_right, proto::_left(proto::_left) ) 
                ) 
            )
       >
       // Rewrite "? + x = y" to "Solve(? = y - x)"
      , proto::when<
            proto::assign< 
                proto::plus< _, proto::terminal<_> >, _ >
            , Solve(
                proto::_make_assign( 
                    proto::_left(proto::_left) , 
                    proto::_make_minus( proto::_right, proto::_right(proto::_left) ) 
                ) 
            )
       >
   >
{};

int main()
{
    BOOST_PROTO_AUTO(expr1, var_ + 1 = 2 );
    BOOST_MPL_ASSERT(( proto::matches<BOOST_TYPEOF(expr1), Solve>));
    proto::display_expr( expr1 );
    proto::display_expr(Solve()(expr1));
    std::cout << "--------------------\n";

    BOOST_PROTO_AUTO(expr2, 3 + var_ = 2 );
    BOOST_MPL_ASSERT(( proto::matches<BOOST_TYPEOF(expr2), Solve>));
    proto::display_expr( expr2 );
    proto::display_expr(Solve()(expr2));
    std::cout << "--------------------\n";

    BOOST_PROTO_AUTO(expr3, 3 + var_ + 1 = 2 );
    BOOST_MPL_ASSERT(( proto::matches<BOOST_TYPEOF(expr3), Solve>));
    proto::display_expr( expr3 );
    proto::display_expr(Solve()(expr3));
    std::cout << "--------------------\n";

    BOOST_PROTO_AUTO(expr4, proto::lit(5) + 3 + var_ + 1 + 4 = 2 );
    BOOST_MPL_ASSERT(( proto::matches<BOOST_TYPEOF(expr4), Solve>));
    proto::display_expr( expr4 );
    proto::display_expr(Solve()(expr4));
    std::cout << "--------------------\n";
}