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