about lambdas

[Timon Gehr]

On Wednesday, 2 January 2013 at 21:12:33 UTC, Maxim Fomin wrote:
> On Wednesday, 2 January 2013 at 21:00:10 UTC, Michael wrote:
>> R  With(I, R)(I o, R function (I) fun)
>> {
>> 	static if(isAssignable!(I, typeof(null)))
>> 		return o is null ? null : fun(o);
>> 	else
>> 		return fun(o);
>> }
>>
>> ...
>>
>> in main function
>> ----------------
>> foreach(p; persons)	
>> 	p.With((Person x) => x.address); // works
>>
>> but
>> ----------------
>> foreach(p; persons)	
>> 		p.With(x => x.address); // error
>>
>> nullcheck.d(89): Error: template maybe.With does not match any 
>> function template
>> declaration. Candidates are:
>> maybe.d(20):        maybe.With(I, R)(I o, R function(I) fun)
>> nullcheck.d(89): Error: template maybe.With(I, R)(I o, R 
>> function(I) fun) cannot
>> deduce template function from argument types !()(Person,void)
>>
>>
>> Why?
>
> The first one is a lambda function, the second one is a lambda 
> template. Templates have type void.

Actually the 'void' is just a diagnostics bug. (lambda templates 
only exist in template parameter lists.) The reason the matching 
fails is that IFTI is not smart enough to devise a type for the 
parameter 'x', and therefore no type for 'R' is obtained, what 
makes the matching fail. Currently other parameters are not taken 
into account during IFTI matching. I believe that the reason is 
that otherwise the compiler needs to be clever about the order in 
which it analyzes the parameters. I consider this one of the more 
annoying limitations.

A workaround that should work in this case is to use a template 
parameter:

auto With(alias fun, I)(I o) // maybe add a template constraint 
here
{
	static if(isAssignable!(I, typeof(null)))
		return o is null ? null : fun(o);
	else
		return fun(o);
}

---

foreach(p; persons)	
     p.With!(x => x.address);

This creates a template from the lambda, and instantiates it once 
inside 'With'. This way the return type does not have to be part 
of the template parameters.