#include <iostream>

//--------------------------------------------------
// Applicative templates. 

template<class T>
struct bin_mul {static T apply(T a,T b) {return a*b;}};


template<class T>
struct bin_add {static T apply(T a,T b) {return a+b;}};

template<class T>
class NumExpr
{
  const T& x;

public:
  NumExpr(const T& _x): x(_x) {}
  T get() const {return x;}
};


template<class ET, class T>
class Expr
{
  ET /* & */ sub_expr;
public:
  Expr(ET _sub_expr): sub_expr(_sub_expr) {}
  T get() const {return sub_expr.get();}
};



// Binary expression
template<class ET1, class ET2, class OT, class T>
class BinExpr
{
  ET1 /* & */ sub_expr1;
  ET2 /* & */ sub_expr2;

public:
  
  BinExpr(ET1 _sub_expr1, ET2 _sub_expr2): 
    sub_expr1(_sub_expr1), sub_expr2(_sub_expr2) {}

  T get() const {return OT::apply(sub_expr1.get(),sub_expr2.get());}
};





//----------------------------------------------------------------------
// Operators.
// Unfortunately, we need binary operators for each combination
// of two operands of type NumExpr<...> or Expr<...>

template<class T>
Expr< BinExpr<NumExpr<T>,NumExpr<T>,bin_add<T>, T>,T > 
operator + (NumExpr<T> a, NumExpr<T> b)
{
  typedef BinExpr<NumExpr<T>,NumExpr<T>,bin_add<T>,T >  Expr_T;
  return Expr<Expr_T,T>(Expr_T(a,b));
}

template<class ET1, class T>
Expr< BinExpr<Expr<ET1,T>,NumExpr<T>, bin_add<T>,T>,T > 
operator + (Expr<ET1,T> a, NumExpr<T> b)
{
  typedef BinExpr< Expr<ET1, T> , NumExpr<T>, bin_add<T>,T >  Expr_T;
  return Expr<Expr_T,T>(Expr_T(a,b));
}

template<class ET1, class T>
Expr< BinExpr<NumExpr<T>,Expr<ET1,T>, bin_add<T>,T>,T > 
operator + (NumExpr<T> a, Expr<ET1,T> b)
{
  typedef BinExpr< NumExpr<T>, Expr<ET1,T>, bin_add<T>,T >  Expr_T;
  return Expr<Expr_T, T>(Expr_T(a,b));
}

template<class ET1, class ET2, class T>
Expr< BinExpr<Expr<ET1,T>,Expr<ET2,T>, bin_add<T>,T>,T>
operator + (Expr<ET1,T> a, Expr<ET2,T> b)
{
  typedef BinExpr< Expr<ET1,T> , Expr<ET2,T>, bin_add<T>,T >  Expr_T;
  return Expr<Expr_T,T>(Expr_T(a,b));
}

template<class T>
Expr< BinExpr<NumExpr<T>,NumExpr<T>,bin_mul<T>,T>,T> 
operator * (NumExpr<T> a, NumExpr<T> b)
{
  typedef BinExpr<NumExpr<T>,NumExpr<T>,bin_mul<T>,T >  Expr_T;
  return Expr<Expr_T,T>(Expr_T(a,b));
}

template<class ET1, class T>
Expr< BinExpr<Expr<ET1,T>,NumExpr<T>, bin_mul<T>,T >,T > 
operator * (Expr<ET1,T> a, NumExpr<T> b)
{
  typedef BinExpr< Expr<ET1,T> , NumExpr<T>, bin_mul<T>,T >  Expr_T;
  return Expr<Expr_T,T>(Expr_T(a,b));
}

template<class ET1, class T>
Expr< BinExpr<NumExpr<T>, Expr<ET1,T>, bin_mul<T>,T >,T > 
operator * (NumExpr<T> a, Expr<ET1,T> b)
{
  typedef BinExpr< NumExpr<T>, Expr<ET1,T> ,  bin_mul<T>,T >  Expr_T;
  return Expr<Expr_T,T>(Expr_T(a,b));
}

template<class ET1, class ET2, class T>
Expr< BinExpr<Expr<ET1,T>, Expr<ET2,T>, bin_mul<T>,T>,T> 
operator * (Expr<ET1,T> a, Expr<ET2,T> b)
{
  typedef BinExpr< Expr<ET1,T>, Expr<ET2,T>,  bin_mul<T>,T >  Expr_T;
  return Expr<Expr_T,T>(Expr_T(a,b));
}


template<class ET, class T>
inline T get(Expr<ET,T> e) {return e.get();}

//----------------------------------------------------------------------
// Try it out 
main()
{
	double _a = 3.2;
	double _b = 4.1;
	double _c = 2.2;
	double _d = 3.3;
	double _e = 8.9;
	
  NumExpr<double> a(_a);
  NumExpr<double> b(_b);
  NumExpr<double> c(_c);
  NumExpr<double> d(_d);
  NumExpr<double> e(_e);

  cout << get(a + ( b + c * e ) * d) << endl;
	cout << (_a + ( _b + _c * _e ) * _d) << endl;
}