Andrei Alexandrescu wrote:
Ary Borenszweig wrote:
Andrei Alexandrescu wrote:
Steven Schveighoffer wrote:
On Tue, 04 Aug 2009 12:23:41 -0400, Andrei Alexandrescu
<seewebsiteforem...@erdani.org> wrote:
Steven Schveighoffer wrote:
On Tue, 04 Aug 2009 09:45:51 -0400, grauzone <n...@example.net>
wrote:
Steven Schveighoffer wrote:
don't think it's worth adding them until we can have full
reflection capabilities so we can get at elements of code and
therefore get the annotations associated with it. I see much
more usefulness for annotations as reflection hints than as a
replacement for keywords.
But we already have full reflection. It's called __traits. You
can build a serialization library or "proper" (user friendly?)
reflection on top of it.
I think you are the 1 millionth person to say it, and yet we
still do not have a "user friendly" reflection system. Why is
that? You'd think that if it could be done, somebody would have
done it by now.
The reality is there's quite few of us. D is not in the stage where
if something could be done, somebody somewhere has done it or is
working on it.
That's understandable, nobody can expect a language as young as D to
have everything.
But in reality, I think the *theory* that everything is there to
build a reflection system is only proven when it actually happens.
I'm sure when the enterprising person or persons go to develop it,
they will find pieces missing from the static reflection system.
Exactly. I'm absolutely sure there are quite a few things needed here
and there. I can assure you I'll push hard for those.
So my point is that adding annotations before reflection works and
is implemented makes little sense to me, because the usage of them
will be crippled by the fact that reflection isn't complete.
What I'd like to see is something like this possible:
void foo (int timeout, string bar, float f = 4.0);
void foo(int timeout);
call!(foo)("timeout=5,bar=\"hello\"");
Taking into account the default value of f, what the parameters are
named, and which overload to call. I could certainly do it with C#.
This is interesting. It means we'd need reflection for parameter
names, which currently does not exist.
Why do it with strings? Why not
call!(foo)(5, "hello")
with varaidic args?
Well some don't like to need to remember the order of arguments.
But that's a way totally different thing discussed here.
First you need to introduce argument names when invoking a function.
void foo(int timeout, string bar) {
..
}
Can be used as:
foo(timeout=5, bar="100")
(with some other syntax, of course)
Once you have that, you could do:
call!(foo)(timeout=5, bar="100")
Voilà!
