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

using namespace std;

namespace proto = boost::proto;
namespace mpl = boost::mpl;

template<typename>
struct expr_wrapper;

struct arg_tag {};

struct wrapper_domain
  : proto::domain<proto::pod_generator<expr_wrapper> >
{};

template<int N>
struct arg
  : proto::or_<proto::nullary_expr<arg_tag, mpl::int_<N> > >
{};

template<typename T>
struct readonly
  : proto::callable {
  typedef const T& result_type;
};

template<typename T>
struct readwrite
  : proto::callable {
  typedef T& result_type;
};

template<int N, typename T>
struct argtype
  : proto::or_<
    proto::when<proto::assign<arg<N>, proto::_>, readwrite<T>()>
  , proto::otherwise<readonly<T>()>
>
{};

namespace boost { namespace proto {
template<class T> struct is_callable< readonly<T> > : mpl::true_ {};
template<class T> struct is_callable< readwrite<T> > : mpl::true_ {};
} }

template<typename Expr>
struct expr_wrapper {
  BOOST_PROTO_BASIC_EXTENDS(Expr, expr_wrapper<Expr>, wrapper_domain)
  BOOST_PROTO_EXTENDS_ASSIGN()
  BOOST_PROTO_EXTENDS_SUBSCRIPT()

  template<int N, typename T>
  struct atype 
    : boost::result_of<argtype<N,T>(const Expr&)>
  {};

  typedef void result_type;

  template<typename T0>
  result_type
  operator()(typename boost::result_of<argtype<0, T0>(const Expr &)>::type arg0) const
  {
    cout << "arg0 " << arg0 << "\n";
  }
};

expr_wrapper<proto::nullary_expr<arg_tag, mpl::int_<0> >::type> const _1 = {{{}}};
expr_wrapper<proto::nullary_expr<arg_tag, mpl::int_<1> >::type> const _2 = {{{}}};

int main()
{
  int i = 42;
  (_1)(i);
  return 0;
}