Proposal request: explicit propreties

[Steven Schveighoffer]

"Ary Borenszweig" wrote
> Currently properties can have these forms:
>
> Getter:
> -------
> Type property() {
>   // ...
> }
>
> Setter:
> -------
> void property(Type type) {
>   // ...
> }
>
> The problem is, the user can use them as functions or as properties. This 
> is ok from the compiler point of view, but the code looks ugly if it 
> doesn't make sense, like:
>
> writefln = 5;
>
> Further, if you want a function to be only used with property syntax, you 
> can't. Why would you wan't that? Because if you have
>
> class Foo {
>
>   int property() {
>     //
>   }
>
> }
>
> and then you decide to change it to
>
> class Foo {
>
>   int property;
>
> }
>
> for some reason, code that used Foo.property() won't compile anymore.
>
> I suggest marking properties as such like this:
>
> getter Type property() {
>   // ...
> }
>
> setter void property() {
>   // ...
> }
>
> "getter" and "setter" are attributes, just like "public", "static", etc. 
> The compiler only uses them to validate correct syntax usage. If they are 
> applied to any other declaration that is not a function, an error is 
> reported.
>
> Finally, there is another reason for wanting to mark functions as 
> properties: when you do autocompletion in an IDE, and it suggests you a 
> function, it can't know whether to autocomplete it as a function or as a 
> property. A solution could be writing something in the ddoc of that 
> function, but since there's no standard for this, each IDE will invent 
> it's own.
>
> Of course, this is not backwards compatible, so it should be a D2 feature.
>
> What do you think?

What about the C# way of doing it (or something similar)?

Type property
{
   get
   {
         ....
   }
   set
   {
         ....
   }
}

get and set don't have to be keywords in this context...

All in all, I'm not really upset with the way properties currently work, but 
I do prefer something explicit like this.

-Steve