Idea for @annotations

[Jacob Carlborg]

On 2011-08-01 09:00, KennyTM~ wrote:
> On Aug 1, 11 13:42, %u wrote:
>> An idea for a potential use of annotations:
>>
>> How about being able to annotate _anything_ with a template?
>>
>> It would be the equivalent of Python's annotations: the template's
>> first parameter would be an alias to the thing being annotated, and
>> its return value would be the code generated for that element. Of
>> course, if there's no transformation being done, then it should
>> simply "return" the alias itself.
>>
>
> +1.
>
>> This would allow you to say something like:
>>
>> auto memoize(alias Fn, T...)(T args) { /* memoize code here */ }
>>
>> @memoize
>> int fib(int n) { ... }
>>
>> which would be somewhat (but not completely) "equivalent" to
>>
>> mixin memoize!(function int(int n) { ... });
>>
>
> I believe you mean
>
> alias memoize!(<that function>) fib;
>
> your @property below won't work as a mixin.
>
> Also, self-reference should be handled:
>
> @memoize
> ulong fib(ulong n) {
> return n < 2 ? 1 : fib(n - 2) + fib(n - 1);
> // ^^^ recursion^^^
> }
>
> @exportName("F/List")
> class F_List {
> int content;
> F_List next;
> // ^^^^^^ self-reference
> }
>
> This works in Python trivially because functions and classes are
> looked-up by name in runtime. This isn't true in D, at least if it's a
> simple alias-ing.
>
>>
>> And more trivial things like @property would simply be
>> template property(alias A) { alias A property; }
>> with their sole effect being extra information found with
>> reflection.
>>
>
> I'd prefer to make it more explicit, e.g. use a __traits to include that
> extra information:
>
> alias __traits(setAnnotation, X, "foo.prop", 1234) Y;
> // Y is a copy or reference of X but with the extra property
>
> enum prop = __traits(getAnnotationy, Y, "foo.prop");
> // returns 1234, compile-time error if 'foo.prop' does not exist.
>
> enum prop = __traits(getAnnotationy, Y, "foo.bar", false);
> // same as above but with a default value.
>
> static if (__traits(hasAnnotation, Y, "foo.prop"))
> alias __traits(removeAnnotation, Y, "foo.prop") Z;
>
> So, e.g. one could write
>
> template serializable(alias F) if (is(f == struct) || ...) {
> alias __traits(setAnnotation, F, "mymodule.serializable", true)
> serializable;
> }
>
> ...
>
> @serializable
> struct MyObject {
> int x;
> ...
> }
>
> and the serializer can check with
>
> auto serialize(F)(F x) if (__traits(getAnnotation, F,
> "mymodule.serializable", false)) {
> ...
> }

That would be awesome.

>>
>> Implementing this would obviously be difficult as I would assume,
>> but does it sound like a reasonable idea?
>
> Would you mind to write a DIP?
> (http://www.prowiki.org/wiki4d/wiki.cgi?LanguageDevel/DIPs)
>
> (Speaking of which, what happened to DIP11?)


-- 
/Jacob Carlborg