On Friday, 6 April 2018 at 20:33:10 UTC, Chris Katko wrote:
Sorry if this is "re-opening" an old thread, but did anything come from this and DIP50? It seems like a really interesting concept and this thread was one of the first results for a Google search.


Thanks for reminding me about this thread, I thought I would see how close i could get to having this work now that I know D's edges better:

On Sunday, 11 July 2010 at 13:29:36 UTC, Michel Fortin wrote:

That said, I don't feel like I'm cheating when using string mixins. I find them a quite good substitute to AST macros. And perhaps string mixins are simpler too: you don't have to learn a new macro syntax, you just manipulate strings. Though I'm still waiting for the day we can use string mixins in expressions to do things like this:

        int num = 1;
        string result = substitute!"Number: $num";
        assert(result == "Number: 1");

So what i came up with was:

--- substituter.d
module substituter;

string substituteForMixin(string input){

    input ~= ` `;
    string output = ``;
    size_t l= input.length-1;

    for(size_t i=0; i<l; i++){
        if(input[i]=='#' && input[i+1]=='{'){
            output ~= (i==0) ? `to!string(` : `"~to!string(`;
            while(input[i] != '}'){
                output ~= input[i++];
            output ~= (i==l-1) ? `)` : `)~"`;
            if(i==0) output ~= `"`;
            output ~= input[i];
            if(i==l-1) output ~= `"`;
    return output;

mixin template Substituter(){
    string substitute(alias string ident)(){
        import std.conv : to;
        mixin(`return `~substituteForMixin(ident)~`;`);

@safe unittest{

    mixin Substituter;

    int number = 42;

        substitute!("number is #{number}")
        == "number is 42"
        substitute!("#{number+1} is the result of number+1")
        == "43 is the result of number+1"
substitute!("you get #{number*number} when you square number")
        == "you get 1764 when you square number"

I think thats as clean as I can make it currently. Also I'm using #{} syntax to allow basic expressions and converting to!string on everything.

Not sure if this syntax is documented but you can use enum like:

enum wrapmixin(alias string s) = {mixin(s)};
enum wrapmixin(alias string s){mixin(s)};

And the mixin() is run at the time the enum is called. The only problem with this though is the lambda/function is defined in the scope enum was defined not where the enum was called. So I think its just sugar for:

template wrapmixin(alias string s){alias wrapmixin = {mixin(s);}}
template wrapmixin(alias string s){auto wrapmixin(){mixin(s);}}

To work around this I used a mixin template to work around the scope issue.

Now to bring us back to 2018, I think that this enum version of the code should inject the function/lambda into the scope of it's caller. That would allow us to do a lot of cool things.

Also the other idea I had was to have mixin functions that only take compiletime args (they are UFCS-able though, unlike templates) and mixin themselves when called like:

mixin add1Xtimes(alias int a, alias int t){
    uint i=t;
    return a;
@safe unittest{
    uint n=0;

And that becomes:

@safe unittest{
    uint n=0;
    uint __m0_i=4;
    uint __m1_i=6;

Notice that if the return is never used it's stripped out.

I haven't really given much thought to the implementation of this though.

Reply via email to