• =?UTF-8?B?Ik5vcmRsw7Z3Ig==?= (10/10) Nov 20 2014 In my module symbolic.d at
• =?UTF-8?B?Ik5vcmRsw7Z3Ig==?= (5/9) Nov 20 2014 As usual I had done a couple of mistakes...which are solved know
• =?UTF-8?B?QWxpIMOHZWhyZWxp?= (13/23) Nov 20 2014 Glad that it works. :)
• IgorStepanov (34/44) Nov 20 2014 Seq opBinary(string op)(Patt rhs)
• =?UTF-8?B?Ik5vcmRsw7Z3Ig==?= (2/17) Nov 21 2014 Great! I've update my code! Thanks!

=?UTF-8?B?Ik5vcmRsw7Z3Ig==?= <per.nordlow gmail.com> writes:

In my module symbolic.d at

https://github.com/nordlow/justd/blob/master/symbolic.d

is it somehow possible to overload binary operator ~ on pairs of 
instances SPatt?

I'm asking because my current try at

https://github.com/nordlow/justd/blob/master/symbolic.d#L332

is not called in the unittest at

https://github.com/nordlow/justd/blob/master/symbolic.d#L347

Isn't it possible to do operator overloading in an abstract 
base-class?

=?UTF-8?B?Ik5vcmRsw7Z3Ig==?= <per.nordlow gmail.com> writes:

On Thursday, 20 November 2014 at 22:10:28 UTC, Nordlöw wrote:
 In my module symbolic.d at

 https://github.com/nordlow/justd/blob/master/symbolic.d

 is it somehow possible to overload binary operator ~ on pairs 
 of instances SPatt?

As usual I had done a couple of mistakes...which are solved know 
at

https://github.com/nordlow/justd/blob/master/symbolic.d#L63

Why can't I find these bugs before I do my posts? :)

=?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:

On 11/20/2014 02:18 PM, "Nordlöw" wrote:
 On Thursday, 20 November 2014 at 22:10:28 UTC, Nordlöw wrote:
 In my module symbolic.d at

 https://github.com/nordlow/justd/blob/master/symbolic.d

 is it somehow possible to overload binary operator ~ on pairs of
 instances SPatt?

 As usual I had done a couple of mistakes...which are solved know at

 https://github.com/nordlow/justd/blob/master/symbolic.d#L63

 Why can't I find these bugs before I do my posts? :)

Glad that it works. :)

Not directly related to your post but just because your post reminded 
me, there is the following feature that simplifies matters when one 
needs virtual operators:

   template opOpAssign(string op) if (op == "~")
   { alias concatAssign opOpAssign; }

Here is the enhancement request:

   https://issues.dlang.org/show_bug.cgi?id=5893

And here is the implementation including the tests:

 
https://github.com/D-Programming-Language/dmd/pull/989/files#diff-51d0a1ca6214e6a916212fcbf93d7e40R246

Ali

"IgorStepanov" <wazar mail.ru> writes:

On Thursday, 20 November 2014 at 22:10:28 UTC, Nordlöw wrote:
 In my module symbolic.d at

 https://github.com/nordlow/justd/blob/master/symbolic.d

 is it somehow possible to overload binary operator ~ on pairs 
 of instances SPatt?

 I'm asking because my current try at

 https://github.com/nordlow/justd/blob/master/symbolic.d#L332

 is not called in the unittest at

 https://github.com/nordlow/justd/blob/master/symbolic.d#L347

 Isn't it possible to do operator overloading in an abstract 
 base-class?

Seq opBinary(string op)(Patt rhs)
{
     static if (op == "~")
     {
         return seq(this, rhs);
     }
     else
     {
         static assert(false, "Unsupported binary operator " ~ op);
     }
}

As far I understood your question, you want to override opBinary 
in a derived class?
You can't do it directly, because opBinary is template and 
template can not be overriten. However, you may declare virtual 
non-template method for "~" and call it from opBinary.

And `static if (op == "~")` is not good. Use template constraint 
instead:

class Patt
{
     // It is better then your static if.
     // Compiler will raise better error message for incorrect 
operator.
     Seq opBinary(string op)(Patt rhs) if (op == "~")
     {
         return opCatImpl(rhs);
     }

     protected Seq opCatImpl(Patt rhs) //you may override it in 
derived class
     {
         return seq(this, rhs);
     }
}

=?UTF-8?B?Ik5vcmRsw7Z3Ig==?= <per.nordlow gmail.com> writes:

On Thursday, 20 November 2014 at 22:35:51 UTC, IgorStepanov wrote:
 class Patt
 {
     // It is better then your static if.
     // Compiler will raise better error message for incorrect 
 operator.
     Seq opBinary(string op)(Patt rhs) if (op == "~")
     {
         return opCatImpl(rhs);
     }

     protected Seq opCatImpl(Patt rhs) //you may override it in 
 derived class
     {
         return seq(this, rhs);
     }
 }

Great! I've update my code! Thanks!