Proposal request: explicit propreties

[Jacob Carlborg]

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?

I like the way it is now because you don't have to write the () after a 
function call (taking no arguments) if you like but I understand why 
explicit properties would be a good thing. If explicit properties were 
introduced in the language I would like this syntax:

get T name (){}
set T name (){}

and also something I like to call property shortcut:

1) get string name;
2) set string name;
3) get set string name;
4) private set string name;
5) private set string name; public get string name;
6) static get string name;
7) get set
    {
	string name;
	int age;
	private string foo;
    }

that would work something like read and write attributes in Ruby.
1) creates a private variable and a public get method
2) creates a private variable and a public set method
3) creates a private variable and a public get and set method
4) creates a private variable and a private set method
5) creates a private variable, a private set method and a public get method
6) creates a private static variable and a public static get method
7) creates three private variables, two public set methods (name and 
age), two public get methods (name and age), a private set method (foo) 
and a private get method (foo)

The thing is that the variables always should be private, the methods 
would be public as default and if you put a protection attribute 
(public, private, protected ...) in front of a property shortcut it 
should affect only the created method.