property syntax strawman

[Oliver Hoog]

JPF schrieb:
> Michiel Helvensteijn schrieb:
>> Michiel Helvensteijn wrote:
>>
>>> --------------------------------------------------
>>> bool empty {
>>>     void set(auto value) { ... }
>>>     auto get() { ... }
>>> }
>>>
>>> empty = false; // empty.set(false)
>>> auto b = empty; // auto b = empty.get()
>>> --------------------------------------------------
>>>
>>> for example, requires no hacks and no keywords. And has the added
>>> advantage that you can still use the getter and setter methods directly.
>> It should be noted that there is an ambiguity if the type of the property is
>> a struct/class with members named 'get' and 'set'. As I see it, there are
>> three ways to resolve it:
>>
>> * Disallow properties with such a struct/class. This seems a little bit
>> excessive and silly. But it is one way.
>>
>> * The 'set' and 'get' from the property are only used for the
>> property-calling syntax. They can not be referenced directly. The members
>> of the struct/class would all be accessable. This would work about the same
>> way as, for example, the suggestion from John C in this thread. And if you
>> go down this path, you might as well condense the syntax, as he did.
>>
>> * The 'set' and 'get' from the property are accessable functions and they
>> overshadow possible member functions with those names.
>>
>> My language uses the third way, but there is no problem with overshadowing.
>> The 'set' and 'get' functions have the same special purpose for every type,
>> and the property is meant to override them.
>>
>> I guess D could do something similar using, instead of my 'get' and 'set',
>> D's 'this' and 'opAssign' respectively.
>>
> There's at least one more solution:
> define the property as
> --------------------------------------------------
>>> bool empty {
>>>     void set(auto value) { ... }
>>>     auto get() { ... }
>>> }
> --------------------------------------------------
> but rewrite empty.get/set to empty.__get/__set. As far as I know names
> beginning with __ are reserved, so the returned type of the property
> couldn't define it. Accessing the setter/getter directly could still be
> done using
> --------------------------------------------------
> empty = false; // empty.__set(false)
> auto b = empty; // auto b = empty.__get()
> 
> auto getter = &empty.__get()
> --------------------------------------------------
> This also allows getting function pointers for the setter and the
> getter. As an addition
> --------------------------------------------------
> auto b = &empty
> --------------------------------------------------
> would then return a pointer to the returned value.

But you would have to write more than necessary. Simpler is:
---
bool foo {
	in(bar) { ... }
	out { return ... }
}
---
in is translated to: void in(bool bar) {...}
out is translated to: bool out() {...}

To get a delegate to in:
auto f = &foo.in;

foo = 5; is equivalent to foo.in(5);

This way you don't need any new keywords or ugly (double) underscores.
And it's unambiguous and pretty clear.