Re: guard condition for a callable thingy, with THESE arguments

[Ann W. Griffith via Digitalmars-d-learn]

On Sunday, 15 May 2016 at 01:59:15 UTC, cy wrote:
I take callbacks on occasion, and I don't really care if 
they're a delegate, or a function, or a callable object, and I 
can assert that in a template:

void foo(Callable)(Callable callback) 
if(isSomeFunction!Callable || isCallable!Callable) {
 ...
}

That works, but it doesn't show you what arguments the callable 
will take, or how many, or what its return type should be.

You can of course read the body of the `foo` function to spy 
out where the text "callable(" might be, but it'd be really 
nice if I could put that information in my guard condition 
somehow. What I want is something like this.

bool default_callback(int foo, string bar, Something baz) {
 ...
}

void foo(Callable)(Callable callback) 
if(calledTheSameAs!(Callable,default_callback)) {
 ...
}

or

void foo(Callable)(Callable callback) 
if(calledTheSameAs!(Callable,bool 
function(int,string,Something)) {
 ...
}

Is that possible to do? Has it already been done?

use "Parameters" in the constraint or make a template that you 
can reeuse.

----
import std.traits;

alias Model = void function(int, string);

void foo(Callable)(Callable callback)
if(is(Parameters!Callable == Parameters!Model)) {}

void main(string[] args)
{
    static void right(int,string){}
    static assert(__traits(compiles, foo(&right)));
    static void wrong(int){}
    static assert(!__traits(compiles, foo(&wrong)));
}
----