#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std;


struct placeholder_plus {
    template <class L, class R> L operator() (const L& a, const R& b) {return a + b;}
//      template <class L> L operator() (L a, L b) {return a + b;}
};

struct placeholder_minus {
    template <class L, class R> L operator() (const L& a, const R& b) {return a - b;}
};


struct placeholder_shift {
       template <class L, class R> L& operator() (L& stream_object, const R& r) { return stream_object << r;}
};

template <class R, class T> struct ref_builder;

template <class R> struct equator {
       R r;
       equator(R r_) : r(r_) {}
       template <class T> const T& operator() (T& b) { return b = ref_builder<R, T>::ref(r, b); }
};

template <class L, class R> struct equator_1 {
       R r;
       L l;
       equator_1(L l_, R r_) : r(r_), l(l_) {}
       template <class T> const L operator() (T& b) { return l = ref_builder<R, T>::ref(r, b); }
};
template <class T, class L> struct ref_builder;

template <class L, class R, class F> struct functor {
       L lhs;
       R rhs;
       F f;
       functor(L l_, R r_, F f_) : lhs(l_), rhs(r_), f(f_) {}
       // The result of operator () is actually a result of operation ref(lhs),
       template <class T> typename ref_builder<L, T>::type operator() (T& a) {return f(ref_builder<L, T>::ref(lhs, a), ref_builder<R, T>::ref(rhs, a));}
};


struct placeholder {
    template <class R> equator<R>  operator= (const R& r) {return equator<R>(r);}
};

template<class T> struct var_holder {
     T& var;
     var_holder(T& t) : var(t) {}
    template <class R> equator_1<T&, R>  operator= (const R& r) {return equator_1<T&, R>(var, r);}
//     operator T& () {return var;}
};

template <class T> var_holder<T> var(T& var) {return var_holder<T>(var);}

template <class TP, class T> struct ref_builder {
      typedef const TP& type;
      static type ref(type t, T) {return t;}
};

template <class L> struct ref_builder<placeholder, L> {
      typedef L type;
      static type ref(placeholder p, type a) {return a;}
};

template <class L, class R> struct ref_builder<var_holder<L>, R> {
      typedef L& type;
      static type ref(var_holder<L> p, R&) {return p.var;}
};

template <class L, class R, class F, class T> struct ref_builder<functor<L, R, F>, T > {
      typedef typename ref_builder<L, T>::type type;
      template <class A> static type ref(functor<L, R, F> p, A& a) {return p(a);}
};

template <class R> functor<placeholder, R, placeholder_plus> operator+ (placeholder lhs, const R& rhs) {
       return functor<placeholder, R, placeholder_plus>(lhs,  rhs, placeholder_plus()) ;
}


template <class R, class A, class B, class C> functor<functor<A, B, C> , R, placeholder_plus> operator+ (functor<A, B, C> lhs, const R& rhs) {
       return functor<functor<A, B, C>, R, placeholder_plus>(lhs,  rhs, placeholder_plus()) ;
}

template <class R> functor<placeholder, R, placeholder_minus> operator- (placeholder lhs, const R& rhs) {
       return functor<placeholder, R, placeholder_minus>(lhs,  rhs, placeholder_minus()) ;
}

template <class R, class A, class B, class C> functor<functor<A, B, C> , R, placeholder_minus> operator- (functor<A, B, C> lhs, const R& rhs) {
       return functor<functor<A, B, C>, R, placeholder_minus>(lhs,  rhs, placeholder_minus()) ;
}



template <class L> functor<var_holder<L>, placeholder,  placeholder_shift> operator<< (L& stream_obj, placeholder rhs) {
       return functor<var_holder<L>, placeholder, placeholder_shift >(var_holder<L>(stream_obj),  rhs, placeholder_shift()) ;
}

template <class L, class R> functor<var_holder<L>, var_holder<R>,  placeholder_shift> operator<< (L& stream_obj, var_holder<R> rhs) {
       return functor<var_holder<L>, var_holder<R>, placeholder_shift >(var(stream_obj),  rhs, placeholder_shift()) ;
}

template <class L, class A, class B, class C> functor<var_holder<L>, functor<A, B, C>,  placeholder_shift>
   operator<< (L& stream_obj, const functor<A, B, C>& f) {
       return functor<var_holder<L>, functor<A, B, C>, placeholder_shift >(var_holder<L>(stream_obj), f, placeholder_shift()) ;
}

template <class R, class A, class B, class C>
  functor<functor<A, B, C>, R,  placeholder_shift> operator<< (functor<A, B, C> lhs, R rhs)
{
       typedef functor<A, B, C> type;
       return functor<type, R, placeholder_shift >(lhs,  rhs, placeholder_shift()) ;
}


placeholder _1;


int main() {
    vector<int> v(3);
    std::string space = "\n";

    v[0] = 1;
    v[1] = 2;
    v[2] = 3;

    int i = 0;
    for_each(v.begin(), v.end(), _1 =  _1 + 6 );


    for_each(v.begin(), v.end(), cout << _1 + 8.3 << ": " <<  _1 << "\n"); // (**)
    for_each(v.begin(), v.end(), var(i) = _1 + var(i));
    cout << i << endl;

}