byKey and byValue: properties or methods?

[Peter Alexander]

On 19/01/12 12:51 AM, Timon Gehr wrote:
> On 01/19/2012 01:41 AM, Peter Alexander wrote:
>> On 18/01/12 12:52 AM, Timon Gehr wrote:
>>> On 01/18/2012 01:40 AM, Jonathan M Davis wrote:
>>>> On Tuesday, January 17, 2012 19:31:25 bearophile wrote:
>>>>> Nick Sabalausky:
>>>>>> Without properties, member function access *ANY* many value
>>>>>> accesses are "a.b()". Is this member value a plain-old-var or a
>>>>>> function?
>>>>>> Who knows! It's a leeked out implementation detail, hooray!
>>>>>
>>>>> I have a partially related question.
>>>>>
>>>>> Currently this code compiles even with -property:
>>>>>
>>>>> void main() {
>>>>> int[int] aa = [1:2];
>>>>> auto byval = aa.byValue();
>>>>> }
>>>>>
>>>>> But I think byValue is a property, so isn't it right to give a
>>>>> compilation
>>>>> error if you add () after the name of a property?
>>>>
>>>> Definitely a bug. Strict enforcement requires that parens be used on
>>>> all
>>>> function calls and that no properties use parens. If you use parens on
>>>> them,
>>>> that would mean that you're using them on the return value of the
>>>> property
>>>> (e.g. opCall) - and in fact, that's one of the main reasons that
>>>> @property was
>>>> added in the first place, since without enforcement, property
>>>> functions which
>>>> return a delegate result in an ambiguity.
>>>>
>>>> - Jonathan M Davis
>>>
>>> A related and way more embarrassing problem is that lazy function
>>> parameters have the same issue.
>>>
>>> This program prints nothing:
>>> import std.stdio;
>>> void foo(lazy void delegate() dg){
>>> dg();
>>> }
>>> void main(){
>>> foo({writeln("hello");});
>>> }
>>
>> Perhaps I'm wrong, but this issue is different.
>>
>> The code you have written is something that would be written by someone
>> that doesn't understand how lazy works.
>
> It is written by someone who understands how it should work.
>
>> You have to use () to un-lazy
>
> What would 'un-lazying' be and what is supposed to be its effect?

Under the hood, lazy is just a delegate with different syntax.

void foo(lazy int x) {}
int a;
foo(a++);

Essentially translates to:

void foo(int delegate() x) {}
int a;
foo( { return a++; } );

Inside foo, you have to do x() to evaluate the delegate, just like 
normals delegates. x on its own without parens would just be the 
delegate variable. If you had a lazy delegate parameter then that is 
like a delegate that returns a delegate, so you have to do x()() to 
evaluate the returned delegate.

>> it, and then () again to invoke the delegate. There is no ambiguity like
>> there is with property delegates.
>
> The code has exactly the same semantics whether or not you write the
> parens after a lazy variable except for the case when it is a delegate
> or function pointer.

I was not aware of this. I believe this is a bug (or at least a design 
flaw).