lazy redux

[Andrei Alexandrescu]

Leandro Lucarella wrote:
> Michal Minich, el  7 de diciembre a las 13:51 me escribiste:
>> Hello Denis,
>>
>>>> 1. auto t = new Thread ( { a=42 } );
>>>> or auto t = new Thread ( () { a=42 } );
>>> It already works, just try it (but don't forget to put a semicolon at
>>> the  end).
>>>
>>>> 2. array.findAll (arr, (item) { item.contains ("abc") } ); 3. foo (
>>>> (a, b) { a + b } );
>>>>
>>>> 4. array.findAll (arr, (item) { return item.contains ("abc"); } );
>>>>
>>>> I'm not proposing this syntax (maybe I probably should, but I have
>>>> feeling I would not be first). It may not even be possible to parse
>>>> it,  but seems to me more similar to how currently functions are
>>>> written. In  this setting {exp} or {stm} is not *special* case.
>>>>
>>> I believe it would work. And yes, it was already proposed by many
>>> others.
>>>
>> it works with two differences:
>>
>> 1. the semicolon is required, even if the body consist only of one
>> expression. This is a minor detail.
>> 2. more importantly - parameter types must be specified explicitly.
>> I don't understand why type of b cannot be inferred in this example:
>>
>> void foo (void delegate (int a) dg)
>> {
>>    dg(1);
>> }
>>
>> void main ()
>> {
>>    foo ( (int b)  { writeln (b); } );
>> }
> 
> It doesn't do implicit returning either:
> 
> $ cat -n x.d
>      1	
>      2	import std.stdio;
>      3	
>      4	void foo (int delegate() dg)
>      5	{
>      6		writeln(dg());
>      7	}
>      8	
>      9	void main()
>     10	{
>     11		int a = 5;
>     12		foo({a;});
>     13	}
>     14	
> $ dmd x.d
> x.d(12): Error: var has no effect in expression (a)
> x.d(12): Error: function x.foo (int delegate() dg) is not callable using argument types (void delegate())
> x.d(12): Error: cannot implicitly convert expression (__dgliteral1) of type void delegate() to int delegate()
> 
> To make it work you have to do it like this:
>     12		foo({return a;});
> 
> Which is considerably uglier than
>     12		foo({a});
> 
> At least when talking about replacing "lazy" :)
> 
> Nobody wants to write:
> enforce({ return a == 5; });
> instead of:
> enforce(a == 5);
> 
> But:
> enforce({a == 5});
> 
> Could be acceptable.

A nit - it's the second argument of enforce that must be lazy, e.g.

enforce(a == 5, {return text("a is not 5, it's ", a);});

Not looking good anyway.


Andrei