Another useful thing to have would be "given this argument set to
a function, give me the function that would be called".

This would do implicit function template instantiation and
overload resolution, but yield the function instead of the return
value.

Imagine:

void foo(int a) {}
void foo(string b) {}


I want to get the address of foo(string). How do you do that
right now? Well, you have to loop over overloads and check the
types. What a pain, but at least doable.

But wouldn't it be cool if you could do

&__functionOf(foo("foo"))

Where the __functionOf is the magic.


So far, this is kinda just a convenience, but now imagine the
case of a template. Even if template reflection worked, you'd
need to figure out the template arguments and that can be
basically impossible given the conversions and specializations.

Then

&__functionOf(writeln("bar"))

for example would give a void function(string). There you can do
`&writeln!string`


And in cases more complex than that, the compiler's logic need
not be reimplemented in user cde.