CS>auto a = [](auto x){ cout << x << endl; }; 
CS>

CS>template <typename X> lambda_type [](X x){ cout << x << endl; };

CS>lambda_type<int> a; 
CS>a(1);

CS>lambda_type<double> a; 
CS>a(3.14);

CS>lambda_type<const char*> a; 
CS>a("asd");
CS>

// template<class X> -- не здесь!
struct PrintX
{
  template<class X> // вот он где!
  void operator()(X x) { cout << x << endl; }; 
};

int main(int argc, char* argv[]) { 
    std::function<void(int)> func1 = [](int x) { std::cout << x << std::endl; }; 
    std::function<void(int,int)> func2 = [](int x, int y) { std::cout << x << y << std::endl; }; 
    f(func1); 
    f(func2); 
    return 0; 
}

template<typename Function>
struct function_traits : public function_traits<decltype(&Function::operator())>
{
};

// []() -> R
template<typename Lambda, typename R>
struct function_traits<R(Lambda::*)() const>
{
    typedef std::function<R()> function;
};

// []() mutable -> R
template<typename Lambda, typename R>
struct function_traits<R(Lambda::*)()>
{
    typedef std::function<R()> function;
};

// [](P0) -> R
template<typename Lambda, typename R, typename P0>
struct function_traits<R(Lambda::*)(P0) const>
{
    typedef std::function<R(P0)> function;
};

// [](P0) mutable -> R
template<typename Lambda, typename R, typename P0>
struct function_traits<R(Lambda::*)(P0)>
{
    typedef std::function<R(P0)> function;
};

// [](P0, P1) -> R
template<typename Lambda, typename R, typename P0, typename P1>
struct function_traits<R(Lambda::*)(P0, P1) const>
{
    typedef std::function<R(P0, P1)> function;
};

// [](P0, P1) mutable -> R
template<typename Lambda, typename R, typename P0, typename P1>
struct function_traits<R(Lambda::*)(P0, P1)>
{
    typedef std::function<R(P0, P1)> function;
};

template <typename Function>
struct function_traits<Function&> :function_traits<Function>{};

template <typename Function>
struct function_traits<Function&&> :function_traits<Function>{};

template<typename Lambda> //TODO: enable_if Lambda::operator() ?
value vfunc(Lambda&& lambda)
{
    typedef typename function_traits<Lambda>::function function;
    return vfunc(static_cast<function>(lambda));
}

template<class F> // F - это void(int)
struct function
{
  F f;
  using argT = traits<F>....;  // int

                               //       объект-лямбда   объект-аргумент типа argT
  template<class L, class = decltype( ( *(L*)nullptr )( *(argT*)nullptr ) )> // SFINAE
  function(L lambda): f{lambda} {}

  //... другие конструкторы
};

return vfunc(static_cast<function>(lambda));

return vfunc(function(lambda));

#include <functional>
#include <iostream>

template <typename T>
void f(std::function<void(T)> g)
{
    std::cout << "1 arg:";
    g(1);
}

template <typename T1, typename T2>
void f(std::function<void(T1 t1,T2 t2)> g)
{
    std::cout << "2 args:";
    g(1,2);
}

int main(int argc, char* argv[])
{
    auto func1 = [](int x) { std::cout << x << std::endl; };
    auto func2 = [](int x, int y) { std::cout << x << y << std::endl; };

    f(func1);
    f(func2);

    return 0;
}

CS>template <typename T>
CS>void f(std::function<void(T)> g)

CS>template <typename T1, typename T2>
CS>void f(std::function<void(T1 t1,T2 t2)> g)

CS>int main(int argc, char* argv[])
CS>{
CS>    auto func1 = [](int x) { std::cout << x << std::endl; };
CS>    auto func2 = [](int x, int y) { std::cout << x << y << std::endl; };

CS>    f(func1);
CS>    f(func2);

CS>    return 0;
CS>}
CS>

template <G> void f1(G g) {...}
template <G> void f2(G g) {...}

auto func1 = [](int x) { std::cout << x << std::endl; };
auto func2 = [](int x, int y) { std::cout << x << y << std::endl; };
f1(func1);
f2(func2);

//template <typename ClassType, typename ReturnType, typename... Args>
//struct function_traits<ReturnType(ClassType::*)(Args...) const>

template <typename ClassType, typename ReturnType, typename Arg1>
struct function_traits<ReturnType(ClassType::*)(Arg1) const> { static const unsigned arity = 1;... }

template <typename ClassType, typename ReturnType, typename Arg1, typename Arg2>
struct function_traits<ReturnType(ClassType::*)(Arg1, Arg2) const> { static const unsigned arity = 2; ... }

...

function<int(int,int)> sum = [](int a, int b) { return a + b; };

auto sum = [](int a, int b) { return a + b; };

template<typename G>
void f(G g)
{
    ....
    g();
}

void g1(int);
void g2(int, int);

f(std::bind(&g1, 1));
f(std::bind(&g2, 1, 2));

void f(std::function<void(int)> g)
    f(func1);

template <typename T>
std::function<T> cvt(T &x) {return x;}

    auto func1 = cvt([](int x) { std::cout << x << std::endl; });

PM>Я бы отказался от поддержки старых компиляторов и требовал С++11

class value 
{
public:
  value( int i );
  value( double f );
  value( string s );
  value( std::function<value(unsigned int argc, const value* argv)> func ); // value-function 

  template<typename T> T get() const;
};

   // 
   template<typename R,typename P0>
      inline value vfunc( std::function<R(P0)> func )
      {
        return value([func](unsigned int argc, const value* argv) -> value { 
          R r = func(argc >= 1? argv[0].get<P0>(): P0() ); 
          return value(r); }); 
      }
    template<typename R,typename P0,typename P1>
      inline value vfunc( std::function<R(P0,P1)> func )
      {
        return value([func](unsigned int argc, const value* argv) -> value { 
          R r = func(argc >= 1? argv[0].get<P0>(): P0(),
                     argc >= 2? argv[1].get<P1>(): P1() ); 
          return value(r); }); 
      }

    ...

value local_func = vfunc( []{ int a, int b } { return a + b; } );

std::function<int(int,int)> t = []{ int a, int b } { return a + b; };
value local_func = vfunc( t );

#include <functional>
#include <iostream>

template <typename T>
void f(std::function<void(T)> g)
{
    std::cout << "1 arg:";
    g(-1);
}

template <typename T>
void f(void g(T))
{
    std::cout << "1 arg:";
    g(1);
}

template <typename T1, typename T2>
void f(void g(T1,T2))
{
    std::cout << "2 args:";
    g(11,22);
}

template <typename T1, typename T2, typename T3>
void f(void g(T1,T2,T3))
{
    std::cout << "3 args:";
    g(111,222,333);
}

int main(int argc, char* argv[])
{
    auto func1 = [](int x) { std::cout << x << std::endl; };
    auto func2 = [](int x, int y) { std::cout << x << y << std::endl; };
    auto func3 = [](int x, int y, int z) { std::cout << x << y << z << std::endl; };

    f(+func1);
    f(+func2);
    f(+func3);

    return 0;
}

lambda_as_std_function2.cpp(27) : error C2593: 'operator +' is ambiguous
        could be 'built-in C++ operator+(void (__cdecl *)(int))'
        or       'built-in C++ operator+(void (__vectorcall *)(int))'
        while trying to match the argument list '(main::<lambda_c762786ee855352b046bdd0fba86f419>)'

использование:
    /**
     * Same as the other writeFunction, except that the template parameter is automatically detected
     * This only works if the data is either a native function pointer, or contains one operator() (this is the case for lambdas)
     */
    template<typename... TData>
    void writeFunction(TData&&... data) noexcept {
        static_assert(sizeof...(TData) >= 2, "You must pass at least a variable name and a value to writeFunction");
        typedef typename std::decay<typename std::tuple_element<sizeof...(TData) - 1,std::tuple<TData...>>::type>::type
            RealDataType;
        typedef typename FunctionTypeDetector<RealDataType>::type
            DetectedFunctionType;
        
        return writeFunction<DetectedFunctionType>(std::forward<TData>(data)...);
    }

определение:
    // this structure takes a pointer to a member function type and returns the base function type
    template<typename TType>
    struct RemoveMemberPointerFunction { typedef void type; };          // required because of a compiler bug

    // this structure takes any object and detects its function type
    template<typename TObjectType>
    struct FunctionTypeDetector { typedef typename RemoveMemberPointerFunction<decltype(&std::decay<TObjectType>::type::operator())>::type type; };


// this structure takes any object and detects its function type
template<typename TRetValue, typename... TParameters>
struct LuaContext::FunctionTypeDetector<TRetValue (TParameters...)>             { typedef TRetValue type(TParameters...); };
template<typename TObjectType>
struct LuaContext::FunctionTypeDetector<TObjectType*>                           { typedef typename FunctionTypeDetector<TObjectType>::type type; };

// this structure takes a pointer to a member function type and returns the base function type
template<typename TType, typename TRetValue, typename... TParameters>
struct LuaContext::RemoveMemberPointerFunction<TRetValue (TType::*)(TParameters...)>                    { typedef TRetValue type(TParameters...); };
template<typename TType, typename TRetValue, typename... TParameters>
struct LuaContext::RemoveMemberPointerFunction<TRetValue (TType::*)(TParameters...) const>              { typedef TRetValue type(TParameters...); };
template<typename TType, typename TRetValue, typename... TParameters>
struct LuaContext::RemoveMemberPointerFunction<TRetValue (TType::*)(TParameters...) volatile>           { typedef TRetValue type(TParameters...); };
template<typename TType, typename TRetValue, typename... TParameters>
struct LuaContext::RemoveMemberPointerFunction<TRetValue (TType::*)(TParameters...) const volatile>     { typedef TRetValue type(TParameters...); };

function getRecordset( params ) {
   var nrs = ...; // opening  recordset somehow
   function nextRecord() { gets next record from nrs }
   function prevRecord() { gets prev record from nrs }
   
   // returns public API of the recordset, hides nrs completely: 
   return {
     next: nextRecord, 
     prev: prevRecord
     ...
   };
}

var rs = getRecordset("shoppingCartData");

while(var record = rs.next()) {
  ...
}

value getRecordset() {
  std::shared_ptr<db::recordset> nrs = ....

  std::function<value()> nextRecord = [nrs]() -> value {
    ... return next record as key/value map
    ... or 'undefined' as value() 
  };
  std::function<value()> prevRecord = [nrs]() -> value { ...  };

  value r; 
  r.set_item("next", vfunc(nextRecord) );
  r.set_item("prev", vfunc(prevRecord) );
  return r;
}

 std::function<...> var = ...lambda...;

decltype(lambda [](int,int)->int) -> std::function<int(int,int)>

auto foo = [](int a,int b) { return a + b; };

decltype(foo)::function_type -> std::function<int(int,int)>

CS>decltype(lambda [](int,int)->int) -> std::function<int(int,int)> 
CS>

CS>auto foo = [](int a,int b) { return a + b; };

CS>decltype(foo)::function_type -> std::function<int(int,int)> 
CS>

  auto a = [](auto x){ cout << x << endl; };
  a(1);
  a(3.14);
  a("asd");
  
  std::function<void(int)> fi{a}; 
  std::function<void(double)> fd{a}; 
  std::function<void(const char*)> fs{a}; 

  fi(1);
  fd(3.14);
  fs("asd");

  auto b = [](double x){ cout << x << endl; };
  std::function<void(int)> fb{b};
  fb(3.14); // напечатает 3
  
  auto c = [](int x){ cout << x << endl; };
  std::function<void(double)> fc{c};
  fc(3.14); // тоже напечатает 3

CS>>auto foo = [](int a,int b) { return a + b; };

CS>>decltype(foo)::function_type -> std::function<int(int,int)> 
CS>>

J>  auto a = [](auto x){ cout << x << endl; };
J>  a(1);
J>  a(3.14);
J>  a("asd");
  
J>  std::function<void(int)> fi{a}; 
J>  std::function<void(double)> fd{a}; 
J>  std::function<void(const char*)> fs{a}; 

J>  fi(1);
J>  fd(3.14);
J>  fs("asd");
J>

auto a = [](auto x){ cout << x << endl; };

template <typename X> lambda_type [](X x){ cout << x << endl; };

lambda_type<int> a; 
a(1);

lambda_type<double> a; 
a(3.14);

lambda_type<const char*> a; 
a("asd");

J>  auto b = [](double x){ cout << x << endl; };
J>  std::function<void(int)> fb{b};
J>  fb(3.14); // напечатает 3
  
J>  auto c = [](int x){ cout << x << endl; };
J>  std::function<void(double)> fc{c};
J>  fc(3.14); // тоже напечатает 3
J>

J>// template<class X> -- не здесь!
J>struct PrintX
J>{
J>  template<class X> // вот он где!
J>  void operator()(X x) { cout << x << endl; }; 
J>};
J>

void test() {
  intptr_t counter = 0;
  auto lambda = [&counter](auto x) { counter += x; return counter; };
  lambda(5);
  lambda(5.5);
  lambda("hello");
}

J>Добро пожаловать в С++14! (если ты пропустил вечеринку с Boost.Lambda)

CS>void test() {
CS>  intptr_t counter = 0;
CS>  auto lambda = [&counter](auto x) { counter += x; return counter; };
CS>  lambda(5);
CS>  lambda(5.5);
CS>  lambda("hello");
CS>}
CS>

struct Lambda
{
  intptr_t& counter;

  template<class X>
  intptr_t operator()(X x) { counter += x; return counter; }; 
};

CS>Добро пожаловать в мир practical programming

CS>>void test() {
CS>>  intptr_t counter = 0;
CS>>  auto lambda = [&counter](auto x) { counter += x; return counter; };
CS>>  lambda(5);
CS>>  lambda(5.5);
CS>>  lambda("hello");
CS>>}
CS>>

J>struct Lambda
J>{
J>  intptr_t& counter;

J>  template<class X>
J>  intptr_t operator()(X x) { counter += x; return counter; }; 
J>};
J>

auto lambda1 = [](int x) mutable { return x; }
auto lambda2 = [](int x) { return x; }

// сгенерированный компилятором эквивалент
struct generated_lambda1
{
    int operator()(int x) const { return x; }
}

struct generated_lambda2
{
    int operator()(int x) { return x; }
}