Best way of checking for a templated function instantiation

[Meta via Digitalmars-d-learn]

On Wednesday, 10 August 2016 at 12:36:14 UTC, Arafel wrote:
> Hi,
>
> I'm trying to check at compilation time if a given type 
> implements some operator (let's assume it's '+' in this case), 
> without caring about the type of the parameters it accepts. 
> Since operator overloading is expressed in D through templated 
> functions, what is the preferred way of checking if a template 
> is / can be instantiated with a given parameter list?
>
> So far I've come with a solution using __trait(compiles, ...), 
> but perhaps it's not 100% reliable -I'm no expert in template 
> wizardry-, or there are better options. I also tried with 
> hasMember, but it apparantly only shows that "opBinary" is 
> indeed present, but nothing more:
>
> ---
> void main() {
> 	struct S {
> 		int opBinary(string op)(int i) if (op == "+") {
> 			return 0;
> 		}
> 	}
>
> 	static assert(__traits(compiles, S.opBinary!"+"));
> 	static assert(!__traits(compiles, S.opBinary!"-"));
> }
> ---

__traits(compiles) is pretty much the only way to do it. For 
example, if you want to check that S supports opBinary!"+"(int):

static assert(__traits(compiles, auto _ = 
S.init.opBinary!"+"(int.init));

And if you want to check that the return type is int or 
implicitly converts to int, you can change the `auto _ = ...` to 
`int _ = ...`. However, if you want to be more explicit about it, 
you can do the following:

import std.traits;

static assert(is(ReturnType!(S.opBinary!"+") == int)); //Change 
to `... : int` for implicit conversion checking