callback craziness

[ag0aep6g via Digitalmars-d-learn]

On 08/08/2016 02:42 AM, Engine Machine wrote:
> So, what about passing in the lambda verses the temp variable?

Nothing. I didn't see a case where it worked one way but not the other. 
If you have code where adding a variable makes things work, please post 
a complete test case.

[...]
> My code is as follows and I cannot get 0 parameters working nor passing
> the function in directly. These were my original questions to begin with
> and haven't been answered. Here is the code I am using.
>
> alias callback(Args...) = @nogc void function(string, int, Args);
> @nogc public void foo(Args...)(callback!Args c, Args args, int x) { }
>
> foo((string s, int i) { }, 1);
>
> does not work
>
> nor does
>
> foo!()((string s, int i) { }, 1);

The second one does work. https://dpaste.dzfl.pl/212b467c62a4

> Ultimately it would also be nice if the template parameters were deduced
> automatically instead of having to specify them. The compiler should be
> able to figure out the types supplied parameters.
>
> e.g.,
>
> foo((string s, int i, T x) { }, someT, 1);
>
> instead of
>
> foo!(T)((string s, int i, T x) { }, someT, 1);
>
> should it not?

I think the `callback` template is the problem here.

Template instantiation is a one way street. You generally can't answer 
the question "With what arguments would template Foo need to be 
instantiated to get result Bar?". For starters, multiple different 
arguments may map to the same result, making the reverse ambiguous.

It works when you skip the `callback` template and put the 
function/delegate type directly into the signature:

----
@nogc public void foo(Args...)(void function(string, int, Args) @nogc c,
     Args args, int x)
{}

void main() @nogc
{
     foo((string s, int i) { }, 1);

     alias T = float;
     T someT;
     foo((string s, int i, T x) { }, someT, 1);
}
----