function_traits | A library of type traits for introspecting C function

The abominable function types combinatory can be a real pain when dealing with template based on function type matching (see std::is_function).

Miscellaneous qualifers including const, volatile, &, &&, noexcept (plus the variadic arguments support) may lead to a large number of template specializations.

However, the noexcept specifier allows to use a boolean expression noexcept(expr):

• noexcept being equivalent to noexcept(true) as default

So, in a future, can we imagine to uniformize all qualifers with this model:

• const qualifier will be equivavent to const(true)
• volatile qualifier will be equivavent to volatile(true)
• & qualifier will be equivavent to &(true)
• && qualifier will be equivavent to &&(true)

And, the icing on the cake, make qualifiers deductible to be able to write something like:

I'm using the solution proposed in this answer to get the arguments from a lambda function and it's working fine when the number of parameters is fixed. I first created a variant with one argument and would like to add a second one which accepts two arguments. I'm not looking to generalize this, just the two options below.

Consider I have the following:

Some time ago came across the use of something like this:

Given any function (or callable) type Function, how can I get its all arguments types as a tuple type ?

For example, I need a trait function_traits::arguments, where:

I'm trying to build a function template, say util::caller, to apply elements stored in std::vector to a function that accepts those elements as arguments. For example, I have a function int func(int a, int b, int c) and a vector of int std::vector args = {1, 2, 3}, a function call might be like the following code snippet.

I am reading some c++ code, and the code list below makes me really confused.
I can guess it tries to define a specialized template, which tries to trait the input args types. But I got a few question:
the first template looks like both deriving and template specialization, if it is deriving, how can a struct derived from itself? if it is a template specialization, where is the template defination?

This question combines several pieces of code and is a bit complicated, but I tried slimming it down as much as possible.

I am trying to use std::enable_if to conditionally invoke the correct constructor as a result of ambiguous function signatures when a lambda expression is used as input, but the parameters of said lambda expression can be implicitly convertible to one another.

This is an attempt to build upon the following question: Here, but is sufficiently different and focuses on std::enable_if to merit another question. I am also providing the Live Example that works with the problem parts commented out.

To inspect the argument (and result) types of the functor, I have the following class:

I'm using the code from another answer to obtain the types of a lambda function (return and arguments). Here is the relevant code in the answer: