as you have to keep not only all events inside your eventstore, but also all past event handlers to replay them

No I think thats wrong. Old versions of events should be replayable with new event handlers. For new data in the events there should be defaults. If the old event is not up-castable, then (as a rule of thumb), it is not the same event but a new event type.

template
void for_each_argument(F f, Args&&… args) {
using arrT = int[];
static_cast(arrT{ (f(std::forward(args)), 0)… });
}

How should we factorize non-static methods of a class? If it were usersManager.findUser(), would the final call always be a global function like findUserFinal() which wraps instance of UserManager?

Also, wrapping all these functions should be done during app initialization in wiring up stage and there should be some service/factory to provide all factorized functions? Otherwise, the code would become polluted with all the repeated wrapping calls, right?

#define SLOT_TYPE(__str__, __type__) param(__str__) = std::remove_reference_t{}

#define DECLARE_NAMED_TUPLE(…) decltype(namedtup::make_named_tuple(__VA_ARGS__))

… right? but then if you are using a tuple in a return statement like:

return make_named_tuple(param(“yodogg”) = 42);

… that yields a different type than, say:

int integer = 42;
return make_named_tuple(param(“yodogg”) = integer);

… the named parameter in first example, with the literal integer, has type int whereas the second example (in which the param value is stored in a variable) has type int &.

This makes the named tuple idiom, as implemented here, much less useful. I have tried to monkey around with this code, in order to deal with references in the manner I’ve described here, but it seems non-trivial to implement (especially in the case of struct types, where pass-by-reference is desirable). If there’s a solution to this, I’d be interested in seeing what it is, as I still like the named tuple idea. Yes!

I’m trying to limit this but I only get a mess with every thing I try. Can you help me please?

I am new to C++ and have a problem compiling your example with Visual Studio 2017. The for_each_argument function (see below) creates an compiler error: C4576 ‘a parenthesized type followed by an initializer list is a non-standard explicit type conversion syntax’.

Any idea how to fix this?

Thanks for your help!
Joe

template
void for_each_argument ( F f, Args&&… args )
{
(void)(int[]) {(f(forward(args)) , 0)…};
}

With this approach can you chain together functions with different input and output types. For example (int,string) | (string,bool) | (bool, void)