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?
@
syntax for annotations is sensible, but I wouldn't want to see it used as a means of denoting property accessors. Frankly, I think C# got it right. I foresee annotations needing a sort of delimiter, depending on how they'd be implemented.Accessors, not with the proposed syntax or implementation. C# style accessors, then yes. Annotations, in general, yes.
No, syntactically it's too different, I don't think the benefits outweigh wrapping my head around it.
No. On a syntactic note, PHP being a C-style language (syntactically), I think borrowing syntax from other OO C-style languages would be the most reasonable.
Addendum: I forgot about the error suppression operator, but it doesn't change my answer. Instead, deprecate the error suppression operator. Whenever it's interpreted in class scope, it's an annotation. When it's removed, we can all sleep easier knowing that nobody can
$foo = @$bar['qux'];