#include <iostream>

using namespace std;
 
template <class Functor>
struct Lambda {
  const Functor f;

  Lambda( const Functor& f ): f(f) {}

  template <class T>
  T operator()( const T& x ) const { return f( x ); }
};

struct Var {
  template <class T>
  T operator()( const T& x ) const { return x; }
};

template <>
struct Lambda< Var > {
  Var f;
       
  template <class T>
  T operator()( const T& x ) const { return x; }
};

typedef Lambda< Var > ParamX;

ParamX x;

struct Adicao {
  template <class A, class B>
  static A aplica( A a, B b ) { return a + b; }
};

struct Multiplicacao {
  template <class A, class B>
  static A aplica( A a, B b ) { return a * b; }
};

struct Subtracao {
  template <class A, class B>
  static A aplica( A a, B b ) { return a - b; }
};

struct Divisao {
  template <class A, class B>
  static A aplica( A a, B b ) { return a / b; }
};

template <class O, class A, class B>
class Oper {
    private:
      const A a;
      const B b;
      
    public:
      Oper( const A& a, const B& b ): a(a), b(b) {}
      
      template <class T> 
      T operator()( const T& x ) const { return O::aplica( a(x), b(x) ); }
};

template <class C>
class Constante {
  private:
    const C n;

  public:
    Constante( const C& n ): n(n) {} 
    
    template <class T> 
    C operator()( const T& ) const { return n; } 
}; 

// Lambda e Lambda

template <class A, class B>
inline Lambda< Oper< Adicao, A, B > > operator + ( const Lambda<A>& a, const Lambda<B>& b ) {
  return Oper< Adicao, A, B  >( a.f, b.f );
}

template <class A, class B>
inline Lambda< Oper< Multiplicacao, A, B > > operator * ( const Lambda<A>& a, const Lambda<B>& b ) {
  return Oper< Multiplicacao, A, B  >( a.f, b.f );
}

template <class A, class B>
inline Lambda< Oper< Subtracao, A, B > > operator - ( const Lambda<A>& a, const Lambda<B>& b ) {
  return Oper< Subtracao, A, B  >( a.f, b.f );
}

template <class A, class B>
inline Lambda< Oper< Divisao, A, B > > operator / ( const Lambda<A>& a, const Lambda<B>& b ) {
  return Oper< Divisao, A, B  >( a.f, b.f );
}

// Lambda e Constante

template <class A, class B>
inline Lambda< Oper< Adicao, A, Constante<B> > > operator + ( const Lambda<A>& a, const B& b ) {
  return Oper< Adicao, A, Constante<B> >( a.f, b );
}

template <class A, class B>
inline Lambda< Oper< Adicao, Constante<B>, A > > operator + ( const A& a, const Lambda<B>& b ) {
  return Oper< Adicao, Constante<B>, A >( a, b.f );
}

template <class A, class B>
inline Lambda< Oper< Multiplicacao, A, Constante<B> > > operator * ( const Lambda<A>& a, const B& b ) {
  return Oper< Multiplicacao, A, Constante<B> >( a.f, b );
}

template <class A, class B>
inline Lambda< Oper< Multiplicacao, Constante<B>, A > > operator * ( const A& a, const Lambda<B>& b ) {
  return Oper< Multiplicacao, Constante<B>, A >( a, b.f );
}

template <class A, class B>
inline Lambda< Oper< Subtracao, A, Constante<B> > > operator - ( const Lambda<A>& a, const B& b ) {
  return Oper< Subtracao, A, Constante<B> >( a.f, b );
}

template <class A, class B>
inline Lambda< Oper< Subtracao, Constante<B>, A > > operator - ( const A& a, const Lambda<B>& b ) {
  return Oper< Subtracao, Constante<B>, A >( a, b.f );
}

template <class A, class B>
inline Lambda< Oper< Divisao, A, Constante<B> > > operator / ( const Lambda<A>& a, const B& b ) {
  return Oper< Divisao, A, Constante<B> >( a.f, b );
}

template <class A, class B>
inline Lambda< Oper< Divisao, Constante<B>, A > > operator / ( const A& a, const Lambda<B>& b ) {
  return Oper< Divisao, Constante<B>, A >( a, b.f );
}

template <class Functor>
void imprime( int a, int b, Functor f ) {
  for( int i = a; i <= b; i++ )
    cout << f(i) << " ";
    
  cout << endl;
}

int main(int argc, char *argv[]) {
  imprime( 0, 10, x*x + x + 1 ); 

  system("PAUSE");
  return EXIT_SUCCESS;
}