property syntax strawman

[JPF]

Oliver Hoog wrote:
> 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 ... }
> }
> ---
I just took the basic syntax from above, but I agree in/out is way
better than the double underscores.

> 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.