No need opUnary

[Ali Çehreli]

On 12/18/22 08:21, Salih Dincer wrote:
 > Don't you think it's interesting that it doesn't need unary operator
 > overloading?

Yes, it is interesting. I put comments to explain it to myself:

import std.stdio;

struct S
{
     int value;

     /* The folowing declaration allows objects of this type to be
        implicitly convertible to 'int' (the return type of
        'opCall').

        In other words, since opCall returns 'int', now we know S
        objects can implicitly be used in place of an int. The
        value will be determined by calling opCall.

        For those of us who may not know opCall, it allows an
        object to be used as a function. For example, when you
        have an 'obj', you can do 'obj()'. (And as seen below, it
        returns 'int' for this struct.)

        (Note: It confused me for a bit because there are two
        opCall definitions below and they both return
        'int'. However, there is no ambiguity because the compiler
        picks the one that takes no parameter for the following
        alias this.)  */
        alias opCall this;

     this(int i) {
         value = i;
     }

     /* I didn't know one could do the following. You are giving a
        new name (opAssign) to opCall. I wonder whether the
        compiler considers opCall for the assignment operation or
        whether it looks for a proper opAssign definition. (Too
        lazy to check...)  */
     alias opAssign = opCall;

     /* This is the function call operator that takes an 'int',
       supporting usages like obj(42). */
     @property opCall(int x) {
         return value = x;
     }

     /* This is the function call opCall that takes nothing,
        supporting usages like obj(). */
     @property opCall() inout {
         return value;
     }

     /* This is the operator overload for usages like 'obj += 42'. */
     @property opOpAssign(string op)(int x) {
         write(":"); // came here before
         mixin("return value"~op~"=x;");
     }
     // no need: opUnary(string op)();
}

void main()
{
     /* Ok, this is regular object construction. */
     S a = S(10),

     /* Using a comma above is something I would never do but 'b' is
       another object being constructed regularly. */
       b = S(-1);

     /* Since S does not define the '+' operation, I think the
        compiler looks and finds an implicit conversion, which
        happens to be to 'int'. I think the following expression
        is addition of two ints: 10 + (-1)' */
     writeln(a + b); // 9

     /* Although S does not support the ++ operator, the D
        compiler finds the += operation and replaces ++ with
        a+=1. And then a is implicitly converted to 'int', gets the
        value 11. Again, the expression is an int addition of 11 +
        (-1). */
     writeln(++a + b); // :10

     /* This uses opOpAssign. */
     a += 10; // :

     /* This result makes sense. */
     assert(a == 21);

     writeln("\n--");

     writeln(-b); // 1
}

Ali