Shouldn't the compiler be able to resolve foo!g(3) to the first template foo?

import std.stdio;
import std.algorithm;
import std.range;

auto foo(F, T)(T x)
{
    return x.foo(F);
}

auto foo(F, T)(T x, F f)
{
    return f(x);
}

int g(int x) { return x; }

void main()
{
    foo(3, &g); // 2nd foo
    foo!g(3);   // error
}

I get the error message.

onlineapp.d(20): Error: template onlineapp.foo cannot deduce function from argument types !(g)(int), candidates are:
onlineapp.d(5):         onlineapp.foo(F, T)(T x)
onlineapp.d(10):        onlineapp.foo(F, T)(T x, F f)

On Wednesday, 28 June 2017 at 11:49:57 UTC, Balagopal Komarath wrote:
> Shouldn't the compiler be able to resolve foo!g(3) to the first template foo?
>
> import std.stdio;
> import std.algorithm;
> import std.range;
>
> auto foo(F, T)(T x)
> {
>     return x.foo(F);
> }
>
> auto foo(F, T)(T x, F f)
> {
>     return f(x);
> }
>
> int g(int x) { return x; }
>
> void main()
> {
>     foo(3, &g); // 2nd foo
>     foo!g(3);   // error
> }
>
> I get the error message.
>
> onlineapp.d(20): Error: template onlineapp.foo cannot deduce function from argument types !(g)(int), candidates are:
> onlineapp.d(5):         onlineapp.foo(F, T)(T x)
> onlineapp.d(10):        onlineapp.foo(F, T)(T x, F f)

symbol 'g' isn't type.

auto foo(alias F, T)(T x)
{
    return x.foo(&F);
}

On Wednesday, 28 June 2017 at 12:19:31 UTC, vit wrote:
> auto foo(alias F, T)(T x)
> {
>     return x.foo(&F);
> }

With this definition foo!((x) => x+1)(3); doesn't work. Is there a way to solve this?

On Thursday, 29 June 2017 at 06:40:04 UTC, Balagopal Komarath wrote:
> On Wednesday, 28 June 2017 at 12:19:31 UTC, vit wrote:
>> auto foo(alias F, T)(T x)
>> {
>>     return x.foo(&F);
>> }
>
> With this definition foo!((x) => x+1)(3); doesn't work. Is there a way to solve this?

You don´t need overload templates:



import std.traits : isCallable;

auto foo(alias F, T)(T x)
if(isCallable!F)			//this line is optional
{
    return F(x);
}


int g(int x) { return x; }

struct G{
	int i;
	this(int i){
		this.i = i;
	}
	int opCall(int x){return x*i;}	//int operator()(int x)
}

void main(){
    foo!g(3);
	foo!((int x) => x*2)(3);
	auto g2 = G(4);
	foo!g2(3);
	foo!(G(5))(3);
}

On Friday, 30 June 2017 at 04:51:23 UTC, vit wrote:
> import std.traits : isCallable;
>
> auto foo(alias F, T)(T x)
> if(isCallable!F)			//this line is optional
> {
>     return F(x);
> }
>

Thanks. That works.