Re: rval->ref const(T), implicit conversions

[tsbockman via Digitalmars-d]

On Monday, 18 January 2016 at 18:08:31 UTC, tsbockman wrote:
Again, I can probably automate generation of the wrapper easily 
enough.

Genericized:

template acceptRVals(alias func) {
private:
    import std.traits : arity;
    alias impl = acceptRVals!(arity!func);

public:
    alias acceptRVals = impl!func;
}
template acceptRVals(size_t arity) {
    private enum mixStr = function() {
        import std.conv : to;

        string ctParams = "";
        string rtParams = "";
        string callArgs = "";

        foreach(size_t a; 0 .. arity) {
            string aStr = a.to!string;
            ctParams ~= "T" ~ aStr;
            rtParams ~= "auto ref T" ~ aStr ~ " a" ~ aStr;
            callArgs ~= "a" ~ aStr;

            if(a < (arity - 1)) {
                ctParams ~= ", ";
                rtParams ~= ", ";
                callArgs ~= ", ";
            }
        }

        return "pragma(inline, true) auto acceptRVals(" ~ 
ctParams ~ ")(" ~ rtParams ~ ") { return func(" ~ callArgs ~ "); 
}";
    }();

    template acceptRVals(alias func) {
        mixin(mixStr);
    }
}

struct CustomString {
    this(string data) {
        this.data = data;
    }

    string data;
    alias data this;
}

import std.stdio;

alias func = acceptRVals!(function(ref CustomString s1, ref 
CustomString s2) {
    writeln(s1);
    writeln(s2);
    s2 = "universe!";
});

void main() {
    CustomString b = CustomString("world!");
    func(CustomString("Hello"), b);

    writeln("Hello");
    writeln(b);
}

(I'm sure there are various corner cases not handled properly by 
this; obviously it would be nice if this was just handled 
automatically by the compiler like it should be.)