metafunction | testing lib that adds capabilities | Mock library

You should change your parent classes to accept all keyword arguments and just use the ones they recognize. And then you can use super as intended:

Seems the only difference is that it does not handle non-public inheritance.
Thanks to Axalo for the comment

As pointed out in the comment by @rafix07, the issue here is that the lambda is returning void, so it's signature is not matched in the first definition of test, and falls back to the other overload. One fix is to apply a comma operator to the argument of val, i.e. changing

While it is possible to implement some of the concepts in Boost.Hana with types that involve different dimensions known only at run-time, Boost.Hana.Sequence and some of the concepts that are a part of its "Minimal Complete Definition" require length and elements to be known at compile-time.

• Foldable requires that the length be known at compile-time.
• Iterable requires that each element be accessible at compile-time.
• Sequence requires Foldable and Iterable.

The group function requiring a Sequence and the run-time length of std::vector make this impossible.

The section Computational Quadrants in the Boost.Hana manual elaborates on algorithms requiring compile-time vs run-time information.

(The Group concept is likely doable, but I don't think that is part of the question.)

Regarding the comments about specializing third party templates for standard types, it is possible but considered bad form. The solution is to make a wrapper type of some kind or provide your own concepts.

Edit:

A comment suggested an example of implementing std::array as a Sequence since its length is known at compile-time. While I can't find a silver bullet in the "Laws" of Sequence that forbid homogeneously typed lists, I can say that the premise of Sequence is working with heterogeneously typed data structures. Elements may contain run-time data, but all of the predicates in the algorithms rely exclusively on "compile-time" information so functions like group would be completely useless for std::array. (This is explained in the aforementioned link)

The problem I see is that, in three points of your code, you have to add a typename to say the compiler that whats follows is a typename.

I hope this answer can explain why.

You have to add two typename here

There is conceptually no such thing as "get primitive type from its typedef alias".

An alias of a type is simply a name for the same type. As such, you can do:

From slide 14 in http://www.pdimov.com/cpp2/mp11_slides.pdf:

So basically, this seems to be your guidance:

When you get the "can’t expand into a fixed parameter list" error, try quoting the metafunction and using the _q algorithm instead

The main issue here is that a structured bindings declaration is just that -- a declaration. We cannot form a "structured binding expression" in order to get the type, which is required in metaprogramming to constrain a template (for e.g., the void_t pattern, or a concept/requires clause)

Per [dcl.struct.bnd], despite the presence of an assignment-expression, a structured binding is distinctly a declaration.

Template metaprogramming relies on types, and a declaration is without a type. You cannot for example say decltype(int a = 10) or even decltype(int a) for this reason.

You can say decltype(int{}) because now we have an expression. For this reason, your void_t pattern does not work.

Unfortunately concepts/constraints don't help us, because we cannot have a declaration inside a requires clause (per [gram.expr])

Personally I think it's a bit of an oversight that we cannot have the equivalent of int{} for structured bindings. But then again, reflection is on its way anyway, so the point is probably moot.

Edit: As dfri pointed out, there is a GNU extension called statement expressions that can make this possible (as an extension it is understandably not portable code)

Make metafunction generic.

As you have it above, there's no generic type. To be safe firstClosure is only going to take a key that foo and bar have in common, but they have no key in common so never is the only possible parameter. If you were to give them a key in common, firstClosure would be typed to accept that.