Type inference for delegates/lambdas as regular parameters?

[Jakob Ovrum]

On Wednesday, 29 February 2012 at 16:50:11 UTC, Alex Rønne 
Petersen wrote:
> (Didn't have much luck posting this on dmd-internals, so I'm 
> posting here.)
>
> Hi,
>
> Consider this code:
>
> bool contains(T)(T[] arr, scope bool delegate(T) dg)
> in
> {
>    assert(dg);
> }
> body
> {
>    foreach (i; arr)
>        if (dg(i))
>            return true;
>
>    return false;
> }
>
> import std.stdio;
>
> void main()
> {
>    writeln(contains([1, 2, 3], x => x == 2));
> }
>
> This doesn't compile with 2.058; the type of x in the lambda
> expression cannot be deduced. Specifying the type explicitly 
> works
> fine.
>
> This works:
>
> bool contains(alias dg, T)(T[] arr)
> {
>    foreach (i; arr)
>        if (dg(i))
>            return true;
>
>    return false;
> }
>
> import std.stdio;
>
> void main()
> {
>    writeln(contains!(x => x == 2)([1, 2, 3]));
> }
>
> Wasn't there supposed to be type inference for delegates passed 
> as
> regular parameters in 2.058?
>
> Regards,
> Alex

The type inference scenario that didn't work, was supposed to be 
implemented, and was ultimately added for 2.058 is,

Given this function:

     bool contains(int[] arr, scope bool delegate(int) dg);

You should be able to call it like this:

     contains(arr, x => x == 2);
     // Alternatively,
     contains(arr, (x) { return x == 2; });

This was not previously possible, you had to make the parameter 
types of those delegates explicit.

There is a bug that sometimes makes this inference crash even 
with 2.058 though, but I think it might have been fixed for the 
next release already (I got the same error message as one I saw 
in a bug report for a recently fixed bug).

Now, it would be nice to have the inference you ask for as well, 
but I don't believe it's what was talked about.

Of course, you might be referring to conversations I missed...