Insane template metaprogramming madness
You can figure out the first parameter of a non-overloaded function pointer pretty easily; I'm not sure but your code looks more complicated than it ought to be.

Unfortunately, your code completely falls down in the presence of overloads and/or templates. Here's the error message:

prog.cc:36:46: error: reference to overloaded function could not be resolved; did you mean to call it?
    using type = extract_function_t&lt;decltype(&amp;Callable::operator()), pick_first&gt;;
                                             ^~~~~~~~~~~~~~~~~~~~~


and here are some types that trigger it:

struct oops1 {
    void operator()(int);
    void operator()(double);
};

struct oops2 {
    void operator()(int);
    void operator()(int) const;
};

void oops3(int);
void oops3(double);

struct oops4
{
    using correct_answer = const std::vector&lt;std::map&lt;int, char&gt;&gt;&amp;;
    template&lt;class T, std::enable_if_t&lt;std::is_same_v&lt;T, const std::vector&lt;std::map&lt;int, char&gt;&gt;&gt;, int&gt; = 0&gt;
        void operator()(T&amp;) {}
};


And here's another error message that I get:

prog.cc:11:1: error: implicit instantiation of undefined template 'pick_first&lt;&gt;'
using pick_first_t = typename pick_first&lt;Args...&gt;::type;
^


with this input:

void oops5(void);




If I were tackling this problem, I would first ask myself what "the type of the first parameter" even means in C++, given that we have function overloading and templates. But then I might try to detect the appropriate type by messing around with

struct ConvertibleToAnything {
    template&lt;class T&gt; operator T() const;
};


and then inspecting f(ConvertibleToAnything{}) and trying to figure out which operator T was getting instantiated.

In the cases where overloading and/or templates rendered the question meaningless, I would try to at least give a nice static_assert error message, if not actually produce a tag type so that is_same_v&lt;deduce_first_parameter_t&lt;oops1&gt;, signature_is_ambiguous_t&gt;.