#include <functional>
#define JUST_RETURN(...) decltype( __VA_ARGS__ ) { return __VA_ARGS__; }
#define OP(name,op) struct name {                                            \
  template<class X, class Y>auto operator()(X x, Y y) -> JUST_RETURN(x op y) \
};                                                                           \
template<class X, class Y>auto operator op(X x, Y y) -> JUST_RETURN(std::bind(name(), x, y))

OP(Mul, *)
// и т.д. для остальных операторов

#include <functional>
#include <iostream>
#include <string> // for "Hello, world!"

#define JUST_RETURN(...) decltype( __VA_ARGS__ ) { return __VA_ARGS__; }
#define OP(name,op) struct name {                                            \
  template<class X, class Y>auto operator()(X x, Y y) -> JUST_RETURN(x op y) \
};                                                                           \
template<class X, class Y>auto operator op(X x, Y y) -> JUST_RETURN(std::bind(name(), x, y))

OP(Mul, *)
OP(Div, /)
OP(Mod, %)
OP(Add, +)
OP(Sub, -)
OP(EQ, ==)
OP(LT, < )
OP(LE, <=)
OP(GT, > )
OP(GE, >=)

int main()
{
  using namespace std;
  using namespace std::placeholders;

  cout << ( 9 * _1)(5)          << endl;                     // 45
  cout << (_1 *  8)(5)          << endl;                     // 40
  cout << (_1 * _1)(5)          << endl;                     // 25
  cout << (_1 * _2)(5,6)        << endl;                     // 30
  cout << (_1 + _2 * _3)(5,6,7) << endl;                     // 47 (42+5)
  cout << (_3 - _2 * _1)(5,6,7) << endl;                     // -23 (7-30)
  cout << ( 9 * _2)(5,6)        << endl;                     // 54
  cout << (_2+", "+_1+"!")("world",string("Hello")) << endl; // "Hello, world!"
}

J>#include <functional>
J>#define JUST_RETURN(...) decltype( __VA_ARGS__ ) { return __VA_ARGS__; }
J>#define OP(name,op) struct name {                                            \
J>  template<class X, class Y>auto operator()(X x, Y y) -> JUST_RETURN(x op y) \
J>};                                                                           \
J>template<class X, class Y>auto operator op(X x, Y y) -> JUST_RETURN(std::bind(name(), x, y))

struct Mul
{
  template<class X, class Y>
  auto operator () (X x, Y y) const -> decltype(x*y) // у тебя в определении пропущено
  { return x*y; }
};

template<class X, class Y>
auto operator * (X x, Y y) -> decltype(std::bind(Mul(),x,y))
{ return std::bind(Mul(),x,y); }

struct F {};
struct G {};

auto fog = F() * G(); // странность: bind(Mul(),F(),G()) - мы точно этого хотели?
auto letsgo = fog();  // смысловая ошибка: в точке определения Mul не было оператора F*G
auto gogogo = fog(1)(1,2)(1,2,3); // по-прежнему bind(Mul(),F(),G())

                                                                         \
J>>template<class X, class Y>auto operator op(X x, Y y) -> JUST_RETURN(std::bind(name(), x, y))
К>

К>template<class X, class Y>
К>auto operator * (X x, Y y) -> decltype(std::bind(Mul(),x,y))
К>{ return std::bind(Mul(),x,y); }
К>

template<class X, class Y>auto operator op(X x, Y y) \
-> typename std::enable_if<                          \
        std::is_placeholder<X>::value                \
     || std::is_placeholder<Y>::value                \
     || std::is_bind_expression<X>::value            \
     || std::is_bind_expression<Y>::value            \
   , decltype(std::bind(name(), x, y))               \
   >::type                                           \
{ return std::bind(name(), x, y); }

#include <cstdio>

#define WHOAMI() printf("%s\n", __PRETTY_FUNCTION__)

template<class X, class Y>
int foo(X x, Y y)
{
    WHOAMI();
    return 1;
}

template<class X, class Y>
auto bar(X x, Y y) -> decltype(foo(x,y))
{
    WHOAMI();
    return foo(x,y);
}

struct F {};
struct G {};

int main()
{
    bar(F(),G());
}

#if 1 // вкл-выкл
float foo(F f, G g)
{
    WHOAMI();
    return 1.f;
}
#endif

Such (dependent — jazzer) names are unbound and are looked up at the point of the template instantiation (14.6.4.1) in both the
context of the template definition and the context of the point of instantiation.

The instantiation context of an expression that depends on the template arguments is the set of declarations
with external linkage declared prior to the point of instantiation of the template specialization in the same
translation unit.

#include <iostream>
using namespace std;

template<class T> void bar(T t) { foo(t); }

struct F {};

int main() {
    F f;
    bar(f);
    return 0;
}

void foo(F) { cout << "foo(F)"; }

// FIXME: When we perform these implicit instantiations, we do not carefully
// keep track of the point of instantiation (C++ [temp.point]). This means
// that name lookup that occurs within the template instantiation will
// always happen at the end of the translation unit, so it will find
// some names that should not be found. Although this is common behavior
// for C++ compilers, it is technically wrong. In the future, we either need
// to be able to filter the results of name lookup or we need to perform
// template instantiations earlier.

A specialization for a function template, a member function template, or of a member function or static
data member of a class template may have multiple points of instantiations within a translation unit, and
in addition to the points of instantiation described above
(типа правила the point of instantiation for such a specialization immediately follows the namespace scope declaration or definition that refers to the specialization — jazzer),
for any such specialization that has a point
of instantiation within the translation unit, the end of the translation unit is also considered a point of
instantiation. A specialization for a class template has at most one point of instantiation within a translation
unit. A specialization for any template may have points of instantiation in multiple translation units. If
two different points of instantiation give a template specialization different meanings according to the one
definition rule (3.2), the program is ill-formed, no diagnostic required.

14.6.4 Dependent name resolution [temp.dep.res]
In resolving dependent names, names from the following sources are considered:
— Declarations that are visible at the point of definition of the template.
— Declarations from namespaces associated with the types of the function arguments both from the instantiation context (14.6.4.1) and from the definition context.

#include <iostream>
using namespace std;

template<class T> void bar(T t)
{
    foo(t);
}

struct F {};

#if 1 // Change It
    typedef int T;
#else
    typedef F T;
#endif

void foo(T)
{
    cout << "foo(T)" << endl;
}

int main() {
    T f;
    bar(f);
}