Thank you to everyone who responded, both here and in various other places. I appreciate your feedback. The questionnaire will remain below for posterity's sake.
To clarify a few things:
- I did not intend to mean that we should/can use the
@
symbol for annotations. I should have been more clear to state that this was about the idea of using annotations to dictate what is a setter, not on the exact details here. What symbol is used for annotations is fairly irrelevant if we don't like the idea of using them as a means to declare getters/setters, don't you think? - I'm not sure why everyone likes C# syntax. It seeems that I am a lone man who believes that is a syntactic abomination.
##Greetings, minions of PHP!
I have some questions for all of you. They are regarding annotations in PHP. They also are regarding accessors/properties.
Question #1: What are your initial thoughts on the following (just initial thoughts: not a brain core dump):
class Foo {
private $bar;
@bar.getter
public function getBar() { return $this->bar; }
@bar.setter
public function setBar($value) { $this->bar = $value; }
}
Note that this is not just meta-data; this would behave as follows:
$foo = new Foo();
$foo->bar = 42; // calls $foo->setBar(42);
$bar = $foo->bar; // calls $foo->getBar();
Question #2: Assuming that you had the following code in your codebase, would you go through the effort of transitioning to use accessors/adding the annotations?
class Foo {
private $bar;
public function getBar() { return $this->bar; }
public function setBar($value) { $this->bar = filter($value); }
}
Question #3: Is the value gained by easily transitioning your code to use accessors worth the downsides you listed in response to question #1?
Question #4: Does the fact that Python has a syntax that uses annotations to define accessors change your mind at all?
I don't like the syntax, mainly because I feel the cognitive distance between a property and the accessor is too great. Meaning that I feel it's too far of a mental shift to go back and forth between variables, and random methods with a specific annotation.
No, because it offers no benefit over current implementations other than being able to access it as a property. With the currently proposed method, it offers the reduction of code. But this syntax still requires the code boilerplate, so there's no significant benefit that this provides me over current code, while the rejected proposal allows me to reduce actual executed code.
Not with this implementation of accessors.
No. While I think we should take features from other languages where they make sense, I don't feel that this feature makes sense (even in the context of python)...