Annotations-Properties Questionnaire.md

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?

1. This looks horrible. I can't prevent my brain from dumping a few things:

• The problem of "spatial distance" is still present. In my opinion, the property should enclose its accessors.

• Futhermore, there are unnecessary redundancies, which over-complicate readability. Iam talking about:

  $bar
  @bar.getter
  getBar
  @bar.setter
  setBar
  

  Reading five times "bar" and two times "set" and "get". Just compare it to:

  $bar
  get
  set
  

  No redundancies and a lot easier to read.

• The "@" is already an operator in a different context (error handling).

2. In general, yes. But not with the proposed annotation syntax. +1 for RFC v1.2 / C# style.
3. Definitely not.
4. No.