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
