Anybody have any idea on how to do shared operator overloads?

[Tejas]

On Thursday, 2 June 2022 at 01:49:32 UTC, Ruby The Roobster wrote:
> On Thursday, 2 June 2022 at 01:29:39 UTC, Ruby The Roobster 
> wrote:
>> On Thursday, 2 June 2022 at 01:00:57 UTC, Ali Çehreli wrote:
>>> On 6/1/22 17:36, Ruby The Roobster wrote:
>>> > A stripped down version of some code I have:
>>>
>>> Not much experience here but I made two changes:
>>>
>>> 1) Added 'shared':
>>>
>>> >          this(Complex!real num = Complex!real(0,0)) shared
>>> >          {
>>> >              this.num = num;
>>> >          }
>>> >          this(shared Complex!real num = cast(shared
>>> > Complex!real)Complex!real(0,0))
>>> >          {
>>> >              this.num.re = num.re;
>>> >              this.im.re = im.re;
>>>
>>> 2) Fixed apparent typos:
>>>
>>>   this.num.im = num.im;
>>>
>>> >          }
>>>
>>> I can't guarantee that correct functions are called. It just 
>>> compiles with 2.100.0. :)
>>>
>>> Ali
>>
> Yes, those were typos.  However, when making this post, I 
> forgot to mark ```this(shared Complex!real num = cast(shared 
> Complex!real)Complex!real(0,0))``` as shared.  The other 
> constructor is not marked as shared in my code, considering as 
> shared classes have all of their members marked as shared.
>
> I also have a bug:  __traits(compiles) only checks if the 
> expressions are SEMANTICALLY correct, not if they actually 
> compile, which they don't.
>
> Interestingly, this code compiles between 2.063 and 2.066.1, if 
> you were to put it into run.dlang.io, given the above changes 
> (including the p1 + p2!), and set to all compilers.

I fixed the typos and added some extra constructors and also 
wrote a little more complex `opBinary` for the `shared` overload 
of `Number`. Now the thing works(AFAICT):

```d
public import std.complex;
public import std.stdio;

public interface Mtype
{
     // ...
}

public class Number : Mtype
{
     public:
     	// new code begin
         this()
         {
             this.num = Complex!real(1,1);
         }
         this() shared
         {
             this.num = Complex!real(1,1);
         }
     	// new code ends
         this(Complex!real num = Complex!real(0,0))
         {
             this.num = num;
         }
         this(shared Complex!real num = cast(shared 
Complex!real)Complex!real(0,0)) shared
         {
             this.num.re = num.re;
             this.num.im = num.im;
         }
         Number opBinary(string op)(Number rhs) //Standard opBinary
         {
             mixin("return new Number(this.num " ~ op ~ " 
rhs.num);");
         }
         shared(Number) opBinary(string op)(shared Number rhs) 
shared
         //changed this code a little as well
         {
             mixin(q{return new shared 
Number(Complex!real(this.num.re} ~ op ~ q{rhs.num.re, 
this.num.im} ~ op ~ q{rhs.num.im));}); //Placeholder untill I can 
get the code to work
         }
     package:
         Complex!real num;
}

bool isMtype(T)()
{
     bool ret = true;
     // ...
     shared T p = new shared T();
     shared T p2 = new shared T();
     ret &= __traits(compiles, T, p + p2);
     return ret;
}

static assert(isMtype!Number); //This fails. Not anymore :D

void main()
{
     shared num1 = new shared Number();
     shared num2 = new shared Number();
     auto num3 = num1 + num2;
     writeln("real: ", num3.num.re, "\nimaginary: ",num3.num.im);
}
```