User Defined Attributes

[deadalnix]

Le 06/11/2012 08:55, Walter Bright a écrit :
> References:
>
> http://www.digitalmars.com/d/archives/digitalmars/D/Custom_attributes_again_163042.html
>
>
> http://www.digitalmars.com/d/archives/digitalmars/D/custom_attribute_proposal_yeah_another_one_163246.html
>
>
> Inspired by a gallon of coffee, I decided to get it implemented. It's
> simple, based on what D already does (CTFE and heterogeneous tuples),
> easy to implement, easy to understand, and doesn't break anything. It
> should do everything asked for in the above references (except it's not
> a type constructor).
>
> You can download it here and try it out:
>
> http://ftp.digitalmars.com/dmd2beta.zip
>
> As a bonus, that beta also can generate Win64 executables, and you can
> even symbolically debug them with VS! (Thanks to Rainer Schütze for his
> invaluable help with that).
>
> Here's the rather skimpy and lame spec I banged out:
> =====================================================
> User Defined Attributes
> -----------------------
>
> User Defined Attributes (UDA) are compile time expressions that can be
> attached
> to a declaration. These attributes can then be queried, extracted, and
> manipulated
> at compile time. There is no runtime component to them.
>
> Grammatically, a UDA is a StorageClass:
>
> StorageClass:
> UserDefinedAttribute
>
> UserDefinedAttribute:
> [ ArgumentList ]
>
> And looks like:
>
> [ 3 ] int a;
> [ "string", 7 ]: int b;
>
> If there are multiple UDAs in scope for a declaration, they are
> concatenated:
>
> [ 1 ] {
> [ 2 ] int a; // has UDA's [1,2]
> [ "string" ] int b; // has UDA's [1,"string"]
> }
>
> UDA's can be extracted into an expression tuple using __traits:
>
> [ 'c' ] string s;
> pragma(msg, __traits(getAttributes, s));
>
> prints:
>
> tuple('c')
>
> If there are no user defined attributes for the symbol, an empty tuple
> is returned.
> The expression tuple can be turned into a manipulatable tuple:
>
> template Tuple(T...) {
> alias T Tuple;
> }
>
> enum EEE = 7;
> ["hello"] struct SSS { }
> [3] { [4][EEE][SSS] int foo; }
>
> alias Tuple!(__traits(getAttributes, foo)) TP;
>
> pragma(msg, TP);
> pragma(msg, TP[2]);
>
> prints:
>
> tuple(3,4,7,(SSS))
> 7
>
> and of course the tuple types can be used to declare things:
>
> TP[3] a; // a is declared as an SSS
>
> The attribute of the type name is not the same as the attribute of the
> variable:
>
> pragma(msg, __traits(getAttributes, typeof(a));
>
> prints:
>
> tuple("hello")
>
> Of course, the real value of UDA's is to be able to create user defined
> types with
> specific values. Having attribute values of basic types does not scale.
> The attribute tuples can be manipulated like any other tuple, and
> can be passed as the argument list to a template.
>
> Whether the attributes are values or types is up to the user, and
> whether later
> attributes accumulate or override earlier ones is also up to how the
> user interprets them.

OK, I may break all the happiness of that news but . . .

Tuple in D is notoriously known to be a badly designed feature. Basing 
more stuff on that just because we have them is short sighted and will 
only result in D's tuples being broken forever, several tuples 
implementations for more user confusion, or future major breakage.

We still don't have any scheme for a stable D, feature testing or 
whatever, so everybody should be prepared for many new ICE (or even more 
fun, bugs). After we all love them or we wouldn't be using D ! Who need 
a programming language to be stable or reliable ?

Surprise feature ! Yaw, no wonder D's toolchain is so wonderfull ! Let's 
not talk these awesome static code analysis tools, java would become 
jealous.

BTW, I don't really like that syntax, but really, that isn't important.