Re: opAssign overload question

[bearophile]

Ali Çehreli:

The type of literal 1 is int, not long. So, both functions are 
matched with implicit conversions. According to "Function 
Overloading" here:

  http://dlang.org/function.html

The match is later resolved by "If two or more functions have 
the same match level, then partial ordering is used to try to 
find the best match. Partial ordering finds the most 
specialized function."

If bool is considered to be more specialized than long, then 
the compiler is behaving according to spec. It is very 
confusing indeed. Especially, considering that an int 
*variable* would be matched to long:

    auto i = 1;
    foo(i);

Now the long overload gets called!

This is the code of the OP improved a little:


import std.stdio;

struct Value {
    public enum Type { bool_, long_ }

    private long longVal;
    private bool boolVal;
    private Type type;

    Value opAssign(in long val) pure nothrow {
        longVal = val;
        boolVal = val != 0;

        type = Type.long_;
        return this;
    }

    Value opAssign(in bool val) pure nothrow {
        longVal = val;
        boolVal = val;

        type = Type.bool_;
        return this;
    }

    Type getType() {
        return type;
    }

}

void main() {
    Value data;

    data = 1;
    data.writeln;
    data.getType.writeln;
    assert(data.getType == Value.Type.bool_);

    writeln;

    data = 10;
    data.writeln;
    data.getType.writeln;
    assert(data.getType == Value.Type.long_);
}


Indeed, such implicit casting rules and overload rules are quite 
arbitrary, and they cause confusion. Functional languages try 
hard to not have them.

Bye,
bearophile