On how a little knowledge is completely useless.

userspace) 2) adding syntax (probably can't be done in userspace unless
somebody thinks of a clever way to do it).

I've thought of it, and I guess I'll give it a go, I could make this a
proposal if it makes sense to.

The idea is to make the Zend Engine aware that annotations exist without
the worry of what the syntax is. Syntax can then be deferred to the
consumer. How to accomplish? Well:

• Zend Engine should have a new token T_ANNOTATION that is demarcated by
  an opening [ and a closing ] (with necessary escaping for ] along the
  way if need be) that should exists before PHP declarations (func,
  property, method, class, const, etc). Multiple annotations per
  declaration are ok.

• Add new methods to Reflection APIs: getAnnotations() and
  getParsedAnnotations().

• Add a new extension called annotation responsible for registering and
  implementing annotation parsers:

  annotation_register_parser($name, AnnotationParser $p|$validcallback);

  ** and an interface for AnnotationParser

  interface AnnotationParser
  {
  public function tokenize($string); // array of tokens
  public function execute(array $tokens);
  }

  (if AnnotationParser is used, Reflection can "byte-code" cache the
  tokens from tokenize())

• Add real implementations of syntax:

  // class to handle proposed doctrine syntax, similar to c#
  class AnnotationAttributeParser { /** ... */ }

  // perhaps a simple key value based parser
  class AnnotationKeyValueParser { /** .. */ }

  // perhaps a PHP include parser
  class AnnotationPHPIncludeParser { /** .. */ }

• Usage:

  annotation_register_parser('doctrine', new AnnotationAttributeParser);

  // callbacks can be used as wel

  annotation_register_parser('zfservice', array('MyClass',
  'myCallbackMethod'));

How would this work?

When Reflection<>::getParsedAnnotations() is called, it will check
for a registered key in the annotation (of one does not exist, exception
is thrown).. code would look like this:

[doctrine:ClassMap('foo' => 'bar', 'rest of c# nested syntax')]
public $foo;

This also allows other frameworks to propose and use their own syntax
that makes the most sense to them:

[symfonyDi:arg1=Foo,arg2=Bar]
public function setStuff(Foo $arg1, Bar $arg2) {...}

or

[zendservice:param1=string;return=int]
public function doFooForWebService() { /* .. */ return $someInt; }

you could even use url based annotations:

annotation_register_parser('wordpress', 'parse_str');

in code:

[wordpress:first=value&arr[]=foo+bar&arr[]=baz]
function wp_plugin_handle_something() {}

Since annotation formats and knowing annotations might be required are a
requirement of the framework/system the consumer has adopted, that
framework can specify the format of the string used inside the annotation.

Also, multiple annotations can be attached to various declarations,
hence the getParsedAnnotations(), perhaps getParsedAnnotation($index)
would be valid as well.

thoughts?
-ralph

On Fri, Sep 17, 2010 at 6:28 AM, Christian Kaps
christian.kaps@mohiva.com wrote:

On Fri, 17 Sep 2010 10:02:10 +0100, Richard Quadling
rquadling@gmail.com wrote:

One thing that did come to mind is if we ignore all the issues and
complexities of actually implementing annotations, are annotations
useful to a significant number of userland developers. On the surface,
(and this is probably where I'm going wrong), it would seem to only
really be of use to framework developers, and whilst there are at
least 2.5 frameworks per developer, the vast majority of userland
developers are not framework developers.

This isn't right. At a first glance, yes it looks that only framework
developers can have a benefit from annotations in the core. But the
annotations extending the API of a framework so that all developers
which using this frameworks have a great benefit of them.

Lets take as dependency injection as example. If the framework
implements this concept than the user of the framework make the usage of
this. Or the bean validation framework. This is only for the framework
users.

I agree with Christian here, something that is "for framework
developers" benefits all of the userland users that use that
framework.
So we are not looking at the minority of framework developers but at
the majority of framework users.

So i think the point of "is there use for annotations" is mute, yes
there is and we don;t see more examples cause we never had it.
How often did anyone suggest creating a state machine in the ZF
Controller before we had goto available? once it became available we
started finding uses for it.

So i'm pretty sure one Annotations exist, more and more people will
get familiar with it and find new ways to use it in their mindset.

Thanks for that.

So, where can I read something about annotations aimed at what must be
painfully obvious someone without all the skills.

How would I use annotations? What problems that I don't know I have do
they solve for me?

Richard.

--
Richard Quadling
Twitter : EE : Zend
@RQuadling : e-e.com/M_248814.html : bit.ly/9O8vFY