Defining Comparable#!=

[HertzDevil]

Comparable overrides only 5 out of the 6 relational operators. The sole exception, #!=, will return true if the two operands are unordered, because it is effectively !(self == other):

x = Float64::NAN
y = {x}

# `Float64#!=` called
x <=> x # => nil
x != x  # => false

# `Object#!=` called
y <=> y # => nil
y != y  # => true

The results become consistent if the following is defined:

module Comparable(T)
  def !=(other : T) : Bool
    cmp = self <=> other
    cmp ? cmp != 0 : false
  end
end

# `Float64#!=` overrides `Comparable#!=`
x != x # => false

# `Comparable#!=` called
y != y # => false

Is there any reason this is not done in the standard library?

[straight-shoota]

x != x #=> false is actually very surprising. The implementation of Float#!= seems to be missing a special case for NaN (which Float#== apparently covers).

I'd consider if there's even a good reason to override Object#!= at all. The default implementation !(self == other) is definitely correct.

The primary problem is that Float#!= is an override with wrong semantics.

[asterite]

Is there any reason this is not done in the standard library?

I think Comparable#== was implemented before we allowed <=> to return nil, and != was totally overlooked (my fault!)