DIP80: phobos additions

[Timon Gehr via Digitalmars-d]

On 06/24/2015 11:41 PM, Tofu Ninja wrote:
> On Wednesday, 24 June 2015 at 19:04:38 UTC, Wyatt wrote:
>> On Wednesday, 17 June 2015 at 09:28:00 UTC, Tofu Ninja wrote:
>>>
>>> I actually thought about it more, and D does have a bunch of binary
>>> operators that no ones uses. You can make all sorts of weird
>>> operators like +*, *~, +++, ---, *--, /++, ~~, ~-, -~,
>>> >>>--, &++, ^^+, in++, |-, %~, ect...
>>>
>>> void main(string[] args){
>>>     test a;
>>>     test b;
>>>     a +* b;
>>> }
>>> struct test{
>>>     private struct testAlpha{
>>>         test payload;
>>>     }
>>>     testAlpha opUnary(string s : "*")(){
>>>         return testAlpha(this);
>>>     }
>>>     void opBinary(string op : "+")(test rhs){
>>>         writeln("+");
>>>     }
>>>     void opBinary(string op : "+")(testAlpha rhs){
>>>         writeln("+*");
>>>     }
>>> }
>>
>> Oh right, meant to respond to this.  I'll admit it took me a few to
>> really get why that works-- it's fairly clever and moderately
>> terrifying.  (I showed it to a friend and he opined it may violate the
>> grammar.)
>>
>> But playing with it a bit...well, it's very cumbersome having to do
>> these overload gymnastics.  It eats away at your opUnary space because
>> of the need for private proxy types, and each one needs an opBinary
>> defined to support  it explicitly.  It also means you can't make
>> overloads for mismatched types or builtin types (at least, I couldn't
>> figure out how in the few minutes I spent poking it over lunch).
>>
>> -Wyatt
>
> I am thinking of writing a mixin that will set up the proxy for you so
> that you can just write.
>
> struct test
> {
>       mixin binOpProxy("*");
>       void opBinary(string op : "+*", T)(T rhs){
>            writeln("+*");
>       }
> }
>
> The hard part will be to get it to work with arbitrarily long unary
> proxies. Eg:
> mixin binOpProxy("~-~");
> void opBinary(string op : "+~-~", T)(T rhs){
>       writeln("+~-~");
> }

Obviously you will run into issues with precedence soon, but this should 
do it:

import std.stdio;
struct Test{
     mixin(binOpProxy("+~+-~*--+++----*"));
     void opBinary(string op : "+~+-~*--+++----*", T)(T rhs){
         writeln("+~+-~*--+++----*");
     }
}

void main(){
     Test a,b;
     a +~+-~*--+++----* b;
}

import std.string, std.algorithm, std.range;
int operatorSuffixLength(string s){
	int count(dchar c){ return 2-s.retro.countUntil!(d=>c!=d)%2; }
	if(s.endsWith("++")) return count('+');
	if(s.endsWith("--")) return count('-');
	return 1;
}
struct TheProxy(T,string s){
     T unwrap;
     this(T unwrap){ this.unwrap=unwrap; }
     static if(s.length){
         alias NextType=TheProxy!(T,s[0..$-operatorSuffixLength(s)]);
         alias FullType=NextType.FullType;
		mixin(`
         auto opUnary(string op : "`~s[$-operatorSuffixLength(s)..$]~`")(){
             return NextType(unwrap);
         }`);
     }else{
         alias FullType=typeof(this);
     }
}

string binOpProxy(string s)in{
	assert(s.length>=1+operatorSuffixLength(s));
	assert(!s.startsWith("++"));
	assert(!s.startsWith("--"));
	foreach(dchar c;s)
		assert("+-*~".canFind(c));
}body{
	int len=operatorSuffixLength(s);
     return `
         auto opUnary(string op:"`~s[$-len..$]~`")(){
             return TheProxy!(typeof(this),"`~s[1..$-len]~`")(this);
         }
         auto opBinary(string 
op:"`~s[0]~`")(TheProxy!(typeof(this),"`~s[1..$-1]~`").FullType t){
             return opBinary!"`~s~`"(t.unwrap);
         }
     `;
}