How to create mixin template and pass name of a variable?

[Bosak]

On Friday, 2 August 2013 at 12:47:51 UTC, monarch_dodra wrote:
> On Friday, 2 August 2013 at 12:17:12 UTC, Bosak wrote:
>> On Friday, 2 August 2013 at 12:10:00 UTC, Bosak wrote:
>>> On Friday, 2 August 2013 at 11:52:32 UTC, monarch_dodra wrote:
>>>> On Friday, 2 August 2013 at 11:37:27 UTC, Bosak wrote:
>>>>> I want to create a mixin template such that:
>>>>>
>>>>> mixin template ArgNull(alias arg, string name)
>>>>> {
>>>>> if(arg is null)
>>>>>     throw new Exception(name~" cannot be null.");
>>>>> }
>>>>>
>>>>> But is there a way to do that with only one template 
>>>>> argument. And then use it like:
>>>>>
>>>>> string text = null;
>>>>> mixin ArgNull!(text);
>>>>>
>>>>> And the above mixin to make:
>>>>>
>>>>> if(text is null)
>>>>> throw new Exception("text cannot be null.");
>>>>
>>>> A mixin template can't inject arbitrary code (AFAIK), but 
>>>> only members/functions/structs etc.
>>>>
>>>> A simple string mixin would solve what you need better 
>>>> anyways:
>>>>
>>>> import std.stdio, std.typetuple, std.string;
>>>>
>>>> //----
>>>> template ArgNull(alias name)
>>>> {
>>>>  enum ArgNull = format(q{
>>>>     if(%1$s is null)
>>>>         throw new Exception("%1$s cannot be null.");
>>>>  }, name.stringof);
>>>> }
>>>>
>>>> void main()
>>>> {
>>>>  string s1 = "hello";
>>>>  string s2;
>>>>
>>>>  mixin(ArgNull!s1);
>>>>  mixin(ArgNull!s2);
>>>> }
>>>> //----
>>>>
>>>> FYI, "q{}" is called a "token string", and is formidably 
>>>> useful to write a string that contains code. Also, I'm 
>>>> exploiting the alias arg to extract the name out of the 
>>>> variable. This makes it impossible to accidentally call the 
>>>> mixin with an invalid string (the error will be *at* the 
>>>> mixin call, not *in* the mixin call).
>>>
>>> Oh I like your solution. It is just what I needed, thanks! 
>>> Also I didn't knew you could make enums that contain string 
>>> values. So in D enums are like constants in C#, right? I see 
>>> that enums are used a lot with templates. And why is the name 
>>> of the enum the same with the name of the template? Does it 
>>> allways have to be like that?
>
> In D, you can type enums, and string is part of the types 
> compatible.
>
> enum food : string
> {
>     burger = "burger",
>     pie = "pie",
> }
>
> That said, this is not what is going on here. What you are 
> seeing is known as "manifest constant". They keyword "enum" 
> means: "This "variable" is a compile-time know name".
>
> EG:
> enum N = 25; //N is a *keyword* known by the compiler
> int  M = 32; //M is just some variable
> int[N] arr1; //OK
> int[M] arr2; //Error: variable M cannot be read at compile time
>
> This brings us to templates. A "template" isn't an object in 
> itself, but rather, a namespace that can hold tons of useful 
> stuff. Unlike a namespace though, a template can be 
> parameterized. This means basically, you can have the namespace 
> "foo!int" and the namespace "foo!string" for example.
>
> This scheme becomes fun once you mix CTFE into this. CTFE means 
> "compile time function evaluation", which means your function 
> is run *while* your program is compiling. This is cool because 
> you can store the result, and the compiler *knows* the result.
>
> A very simple template could be:
>
> template Hello(alias name)
> {
>     enum String = "Hello " ~ name;
> }
>
> First, you create the namespace Hello!"bob", and then you can 
> extract String to obtain "Hello bob".
>
> Templates most often contain enums or Aliases, but sometimes, 
> also functions, or new types.
>
> As you can see though, adding ".String" is a bit of a pain. 
> That's where "eponymous" templates come in. By making an 
> object/alias carry the same name as the template, then the 
> template *becomes* that alias directly.
>
> If we go back to the above example, and write it as:
> template Hello(alias name)
> {
>     enum Hello = "Hello " ~ name;
> }
>
> In this case, Hello!"bob" *is* the string "Hello bob". You now 
> have a parameterized string(!) You can use it:
> string hello_bob = Hello!"bob";
> But what is coolest is that the compiler knows this too, so you 
> can mix it in too, or whatever.
>
> This is exactly what I did. My template name is ArgNull. 
> Instead of doing a "simple" string operation, I used the 
> function format, which can be evaluated CTFE. There's not much 
> magic going on.
>
> I hope it wasn't too much? These techniques in meta-programming 
> are a bit hard to write and master, but the idea is that 
> *useage* should be straight forward.
>
>> Also is there a way to see my code after mixins, templates and 
>> CTFE gets executed? Like some kind of compiler switch or 
>> something?
>
> This is currently being discussed and worked on, but as of 
> today, no.

Thanks a lot for your explanation. Now enums and templates are a 
lot more clear to me!