User defined attributes use

[simendsjo]

On Monday, 16 September 2013 at 06:47:40 UTC, ilya-stromberg 
wrote:
> On Sunday, 15 September 2013 at 18:31:40 UTC, simendsjo wrote:
>> On Sunday, 15 September 2013 at 17:34:06 UTC, matovitch wrote:
>>> Hi everyone,
>>>
>>> I read the documentation about user defined attributes, but I 
>>> don't see their uses. Ok, it'a a template expression you can 
>>> link to a declaration, but what are they useful for ? (not 
>>> sure about the syntax ;-))
>>>
>>> Can you declare a template constraint as a user defined 
>>> attribute to do something like :
>>>
>>> void 
>>> template_function_which_go_back_and_forth(@("Bidirectional") 
>>> @("Range") BR)(BR br) {...}
>>>
>>> This would be awesome (even if not really occidental) to do 
>>> something like:
>>>
>>> @("SmallTypeSet") @("MediumTypeSet") @("LargeTypeSet") Type
>>>
>>> This could allow to build tree based category structure.
>>
>> It enables declarative programming.
>> And because this is D, there is no runtime overhead.
>> A common use is to add semantics to types and instances that 
>> is difficult or very intrusive to do by creating 
>> structs/classes by hand.
>>
>> A little validation example:
>>
>> @nonNull // An instance shouldn't be allowed to be null
>> class C {
>>  @matches("[0-9]+")
>>  string someNumber;
>>
>>  @interval!"(]"(0, 10) // (0, 10] range
>>  int someInt;
>> }
>>
>> C c;
>> validate(c); // returns ["C is null", "someNumber doesn't 
>> match '[0-9]+'", "someInt is outside the interval '(0, 10]'"]
>>
>> And ORMs usually use annotations:
>>
>> @table("some_tablename")
>> class C {
>>  @id("id_field_name")
>>  int id;
>> }
>>
>> Take a look at C# and Java libraries to see how many uses 
>> attributes/annotations - they are still quite new in D, so 
>> they are still underutilized.
>> A very big difference is of course that UDAs are available at 
>> compile time :)
>
> Can you print a full examle? For example, can you implement 
> "matches" UDA and validate function.
> It's intresting how can I create new UDA and check if it's 
> available for class/field.

I don't have a full example without adding a lot of code, but 
this partial
example might give you the gist of it.


// This is the type that validates
struct matches(string mustMatch)
{
     alias re = ctRegex!(mustMatch);

     static string[] validate(T)(const ref T t)
     {
         static if(!isSomeString!T)
             static assert(0, "matches only works on strings, not 
"~T.stringof);
         return match(t, re).empty ? ["no match"] : null;
     }
}

// and this is the code that runs all validators for a variable
void validate(alias T)(ref Appender!(string[]) app)
{
     static if(isTupleWrapper!T)
     {
         validate!(T.Head)(app);
         validate!(T.Tail)(app);
     }
     else
     {
         foreach(memberAttr; getValidaterAttrs!T)
         {
             foreach(attr; memberAttr.Tail)
             {
                 foreach(msg; attr.validate(T))
                     if(msg.length)
                         app.put(msg);
             }
         }
     }
}

// .. And here is some of the plumbing

string[] validate(Vars...)()
{
     auto app = appender!(string[])();
     validate!Vars(app);
     return app.data();
}


// The getMembersAndAttributesWhere are templates in my little 
library that isn't released. Uses quite some custom __traits 
stuff, but it's basically __traits(getAttributes
template getValidaterAttrs(alias T)
{
     alias getValidaterAttrs = 
TypeTuple!(getMembersAndAttributesWhere!(T, 
isValidationAttr).Elements,
                                          
getMembersAndAttributesWhere!(TypeOf!T, 
isValidationAttr).Elements);
}

// Well.. Incomplete
template isValidationAttr(alias T)
{
     enum isValidationAttr = hasMember!(TypeOf!T, "validate");
}