Метапрограммирование в boost::proto (boost::spirit)

//  Copyright (c) 2001-2011 Hartmut Kaiser
//
//  Distributed under the Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at [url]http://www.boost.org/LICENSE_1_0.txt[/url])
 
//#include "spirit_test.h"
//#include "spirit_parser.h"
//#include "recursive.h"
//#include "cpptest.h"
 
#include <iostream>
#include <vector>
#include <cmath>
#include <boost/proto/proto.hpp>
#include <boost/proto/core.hpp>
#include <boost/proto/context.hpp>
#include <boost/typeof/std/ostream.hpp>
#include <boost/type.hpp>
#include <complex>
using namespace boost;
 
 
 
 
template<typename Expr>
struct calculator;
 
// Define a placeholder type
template<int I>
struct placeholder
{};
 
struct calculator_grammar
  : proto::or_<
        proto::plus< calculator_grammar, calculator_grammar >
      , proto::minus< calculator_grammar, calculator_grammar >
      , proto::multiplies< calculator_grammar, calculator_grammar >
      , proto::divides< calculator_grammar, calculator_grammar >
      , proto::terminal< proto::_ >
    >
{};
 
 
// the calculator domain will be wrapped in the
// calculator<> expression wrapper.
struct calculator_domain
  : proto::domain< proto::generator<calculator>,calculator_grammar >
{};
 
struct calculator_context
  : proto::callable_context< calculator_context const >
{
    // Values to replace the placeholders
    std::vector<double> args;
 
    // Define the result type of the calculator.
    // (This makes the calculator_context "callable".)
    typedef double result_type;
 
    // Handle the placeholders:
    template<int I>
// Define a calculator domain. Expression within
    double operator()(proto::tag::terminal, placeholder<I>) const
    {
        return this->args[I];
    }
};
 
// Define a calculator expression wrapper. It behaves just like
// the expression it wraps, but with an extra operator() member
// function that evaluates the expression.
template<typename Expr>
struct calculator
  : proto::extends<Expr, calculator<Expr>, calculator_domain>
{
    typedef
        proto::extends<Expr, calculator<Expr>, calculator_domain>
    base_type;
 
    calculator(Expr const &expr = Expr())
      : base_type(expr)
    {}
 
    typedef double result_type;
 
    // Overload operator() to invoke proto::eval() with
    // our calculator_context.
    double operator()(double a1 = 0, double a2 = 0) const
    {
        calculator_context ctx;
        ctx.args.push_back(a1);
        ctx.args.push_back(a2);
 
        return proto::eval(*this, ctx);
    }
};
 
 
int main()
{
 
    // Define the Protofied placeholder terminals
    calculator<proto::terminal<placeholder<0> >::type > const _1;
    calculator<proto::terminal<placeholder<1> >::type   > const _2 ;
 
    calculator_context ctx;
 
    double d =  ((_2 - _1) / _2 * 100)(31,32),k;
 
    std::cout << d << std::endl;
 
    return 0;
}

template <class L, class OpTag, class R>
struct Expression {
 
    Expression (L const& l, R const& r) :l(l),r(r){}
 
    L const& l;
    R const& r;
 
    typedef doublet result_type;
 
    result_type operator()(){
        return OpTag::apply(l,r);
    }
 
};
 
template <class L, class R>
Expression<L,plus,R> operator+(L const& l, R const& r){
    return Expression<L,plus,R>(l,r);
}
 
template <class L, class R>
Expression<L,minus,R> operator-(L const& l, R const& r){
    return Expression<L,minus,R>(l,r);
}