interface opEquals

Nov 23

Antonio

Nov 23

Jonathan M Davis

Nov 24

Nov 25

Nov 27

Nov 27

November 23

Posted by Antonio

Permalink

Antonio

Permalink

interface IOpt(T)
{
  T value();
  bool empty();
  bool opEquals(IOpt!T other);
}

class None(T) : IOpt!T
{
  bool empty() => true;
  T value(){ throw new Exception("None has not a value"); }
  bool opEquals(IOpt!T other)=>other.empty;
}

class Some(T) : IOpt!T
{
  this(T value)  { this._value = value; }
  bool empty() => false;
  T value()=> _value;
  bool opEquals(IOpt!T other)=>!other.empty && other.value==_value;

  private T _value;
}

IOpt!T some(T)(T v)=>new Some!T(v);
IOpt!T none(T)()=>new None!T;

void main()
{
  assert(new Some!int(1) == new Some!int(1));
  assert(new None!int == new None!int);
  assert(none!int.opEquals(none!int));
  assert(none!int == none!int);
}

It compiles, but last assertion assert(none!int == none!int); fails

core.exception.AssertError@testiface.d(33): Assertion failure

To avoid "extrange effects" I test an alternative equality that fails too:

  assert( (cast (IOpt!int) new None!int) == (cast (IOpt!int) new None!int));

What seems strange to me is that none!int.opEquals(none!int) works properly.

Questions

Why, when applied to interface, opEquals called directly behavior is not the same that when calling == ?
Is it the expected behaviour?

On Thursday, November 23, 2023 2:20:25 PM MST Antonio via Digitalmars-d-learn wrote: > * Why, when applied to interface, ```opEquals``` called directly behavior is not the same that when calling ```==``` ? > > * Is it the expected behaviour? I'd have to take the time to study your code in detail to see whether what exactly you're seeing makes sense or not, but it's not expected that normal D code will call opEquals directly, and for classes, == does more than call lhs.opEquals(rhs). It does additional stuff to try to have the correct behavior for equality without you having to code it all up yourself in opEquals. == on classes results in the free function, opEquals, in object.d being called. That function does a variety of checks such as checking whether either reference is null (to avoid dereferencing null) and using is to compare the address of the class references first (to avoid calling the class' opEquals if both references are to the same object). It also makes sure that both rhs.opEquals(lhs) and lhs.opEquals(rhs) are true for == to be true to avoid subtle bugs that can come into play when comparing a base class against a derived class. https://github.com/dlang/dmd/blob/master/druntime/src/object.d#L269 - Jonathan M Davis

interface IOpt { bool opEquals(IOpt other) const @safe pure; } class None : IOpt { bool opEquals(IOpt other) const @safe pure => true; } void main() { None a = new None(), b = new None(); IOpt a2 = a, b2 = b; assert(a == b); assert(a2 == a); assert(b2 == b); assert(a2 == b2); // fails!!! }

Forums