I’m going to be honest, haven’t looked at this in that close of a detail.
But here is something that standout quite obviously.
Addresses of functions are not constant expressions, and template arguments are required to be a constant expression known at compile time.
There’s no guarantee that the addresses of different functions are distinct, or have a certain order, that they exist at all, and in certain case they might not even be known until runtime.
So, I have absolutely no idea how you would envision this to work.



From: Std-Proposals <std-proposals-bounces_at_[hidden]> On Behalf Of organicoman via Std-Proposals
Sent: Wednesday, July 10, 2024 19:39
To: Andrey Semashev via Std-Proposals <std-proposals_at_lists.isocpp.org>
Cc: organicoman <organicoman_at_[hidden]>
Subject: Re: [std-proposals] template params of a function template


>> template<void(*)(int)>
>> struct A { // impl };

>You can't. A function pointer points to a >function. You can't have a
>pointer to a function template. So, at the >point when A is instantiated,
>the function pointer must be either null or >point to a function, whether
>it was generated as a result of a function >template instantiation or was
>never a template to begin with.

Yet a function pointer is compile time constant, that means we can examine its properties at compile time. And the template arguments are among these properties.
This is related to type erasure.
I think the compiler should allow a way to access the template arguments of a function pointer.
Because when we pass a function pointer generated from a function template usually we do

A<foo<T1,T2>> a;

Which is mandatory to avoid overload ambiguity.

And at this point, we see clearly the template arguments, and i don't see why the compiler can't see them!



Sent from my Galaxy