On Sunday, 2 September 2012 at 16:59:19 UTC, Maxim Fomin wrote:
This reminds me custom attributes discussion which can be found
in NG archive.
Requested language additions relevant to attributes may be
divided
into three groups:
1 (tags). We want to tag some (likely function) declarations
like @nogc.
IMO, this is a poor choice.
2 (extending type). We want to define type (likely classes) and
then
extend its functionality.
AFAIK C# attributes belong to this camp (correct me if I am
wrong). In
this case (likely class) type implicitly derives
from attribute class. Obviously this also related to compile
time
because D being static typed language and has no
way to be aware at run time that type functionality was
extended. I
think that it is not worth embedding in the language, because
it is already possible to derive from base class, or interface,
or
instantiated template or to use mixin.
This is my preferred solution. This is also similar to Java. In
fact there are only small differences between C# and Java
semantics. This also includes other languages on the matching
platforms, E.g. Nemerle is a .net language and provides the same
attributes mechanism as C#. I assume that Scala does the same
with Java annotations.
The C# way (which I slightly prefer over the Java one):
class Whatever : Annotation { // user defined annotation type
}
Java uses @interface to define a user defined annotation.
@interface whatever { // user defined annotation type
}
I don't get your last point at all regarding inheritance - in
both Java and C# it should be possible to use polymorphism with
annotations. No need to add a new mechanism for it.
class Foo : whatever {} // inheritance
Really, the main things that are needed inside the compiler are a
mechanism to attach custom attributes to various lingual parts, a
way to mark such custom attributes by e.g. deriving from a
special class (not unlike the IUnknown interface in D for COM)
and standard compiler APIs for usage inside such an attribute.
One extra step is defining an execution model for custom
attributes:
Java way is multi-pass - compiler executes the annotations which
generate new version of the code, which is run through the
compiler again, and so forth.
Nemerle way - attributes can be macros which in turn can
manipulate the AST.
etc..
3 (extending instance). We want to make some instance of
(extremely likely class) type to extend functionality
while still remaining in original type without affecting type.
I don't get this at all. What's the purpose of having a single
type?
I offer simple solutions because I estimate probability of
introducing
complex addition to the language now as
extremely low.
