Binding against a lambda in c++ - c++

Question

I try to understand how https://github.com/tomaka/luawrapper works and
extracted one codepath from it. I simplified it to understand it and
came up with the below code.
What puzzles me is the way struct Binder works and how readIntoFunction() creates the binder function objects in advance of it being used, leading to the creation of a call to the lambda that was supplied at the beginning.
Question now:
I had real problems getting my head around this piece of code. Is it just me that thinks this code is hilarious?
Is there some easier way to achieve the same thing? Is there some easier way to generate a binder function from the type signature of the lambda supplied?
g++ -g -std=c++14 test.cpp -o test.exe
test.cpp:
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <functional>
template<typename T> struct tag {};
template<typename TFunctionObject, typename TFirstParamType>
struct Binder {
TFunctionObject function;
TFirstParamType param;
template<typename... TParams>
auto operator()(TParams&&... params) -> decltype(function(param, std::forward<TParams>(params)...)) {
return function(param, std::forward<TParams>(params)...);
}
};
class A {
public:
int a[3];
/* trigger the actual call */
template<typename TCallback>
static int readIntoFunction(TCallback&& callback, A &c, int ) {
return callback();
}
/* at the first call 'callback' is the lambda supplied to
A::ca() at the beginning. Each iteration will generate a
derived call object with one argument less than 'callback' */
template<typename TCallback, typename TFirstType, typename... TTypes>
static int readIntoFunction(TCallback&& callback, A &c, int index, tag<TFirstType>, tag<TTypes>... othersTags)
{
const TFirstType v = c.a[index];
Binder<TCallback, const TFirstType&> binder{ callback, v };
return readIntoFunction(binder, c, index + 1, othersTags...);
}
template<typename TType, typename = void>
struct Split {
template<typename TType2>
static void push(A &c, TType2 value) {
}
};
/* with template packs ready, call readIntoFunction().
the 'value' parameter is the target lambda function to
call */
template<typename TReturnType, typename... TParameters>
struct Split<TReturnType (TParameters...)>
{
template<typename TFunctionObject>
static void push(A &c, TFunctionObject value) noexcept {
A::readIntoFunction(value, c, 0, tag<TParameters>{}...);
}
};
/* split up the function signature into return/parameters,
specialize from (*)() to (). */
template<typename TReturnType, typename... TParameters>
struct Split<TReturnType (*)(TParameters...)>
{
typedef Split<TReturnType(TParameters...)> SubPusher;
template<typename TType>
static void push(A &c, TType value) noexcept {
SubPusher::push(c, value);
}
};
/* entry, called with a lambda function as argument */
template<typename TFunctionType>
auto ca(TFunctionType&& data) {
typedef typename std::decay<TFunctionType>::type RealDataType;
Split<RealDataType>::push(*this, std::forward<TFunctionType>(data));
}
};
int main(int argc, char **argv) {
A c{{ 1, 2, 3}};
c.ca( (int (*)(int,float))[](int a,float b)->int {
std::cout << a << b << std::endl;
});
c.ca( (int (*)(int,float,double))[](int a,float b,double c)->int {
std::cout << a << b << c << std::endl;
});
}

Answer 1

Is there some easier way to generate a binder function from the type signature of the lambda supplied?
The short answer is “No”.
Generally, you could use standard library equivalents, std::function, std::bind, std::placeholders. The implementation code is even more complex. But they're in the standard library, i.e. you don’t have to support that code, and you’ll get documentation.
For this particular case, however, they won’t work. Because the function doesn’t just make a callable thing like std::function, instead it marshals the arguments + return value to LUA.
Other methods exist, but they aren’t necessarily simpler. Sometimes C #defines leads to simpler code. In other cases, external scripts or tools running in a pre-build step generate the boilerplate code from something else (special comments/other markup in your source, or external LUA code, or external protocol/interface definitions).
Generally, to write code like this, reflection support in the programming language helps. Unfortunately, C++ has no reflection. Hence that write-only template code.