Re: Making == symmetric?

"Ben Giddings" <[e-mail]> schrieb im Newsbeitrag
news:[e-mail]...
> Nathan Weston wrote:
> > def compare(a,b)
> >    if a.can_compare_to?(b)
> >       return a.compare_to(b)
> >    elsif b.can_compare_to?(a)
> >       return b.compare_to(a)
> >    else
> >      return false
> >    end
> > end
>
> How about
>
> def compare(a, b)
>    retval = false
>    if a.can_compare_to(b)
>      retval = a.compare_to(b)
>    end
>    if retval and b.can_compare_to(a)
>      retval = b.compare_to(a)
>    end
>
>    return retval
> end
>
> This way if both of them know how to compare themselves to the other
one,
> the comparison returns true only if both agree they're equal.

But that's inefficient to a degree that can cause problems for
applications.  You end up always doing two comparisons.  Even making the
compare() method more complex (i.e do only one comparison if the
instances' classes match) doesn't really solve this issue since for the
standard case you still get the overhead.

> Aside from the code though, I'm not sure if I like the idea.  While in
> principle I agree that equality tests should be symmetrical, I also
think
> that it is more natural to have an equality operator which you can
> overload.  I think you'd still need "can_compare_to?" to know if 'a'
knows
> how to compare itself to an instance of 'b'...
>
> Maybe instead:
>
> def compare(a, b)
>    retval = false
>    if a.can_compare_to?(b)
>      retval = a.==(b)
>    end
>    if retval and b.can_compare_to?(a)
>      retval = b.==(a)
>    end
>
>    return retval
> end

Doesn't solve the overhead problem.

What one would really need is multiple dispatch:

module Kernel
  def self.register_compare(classA, classB, &comp)
    ( @comparisons ||= {})[ [classA, classB] ] = comp
    @comparisons[ [classB, classA] ] = proc { |b,a| comp.call(a, b) }
  end

  def self.compare(a, b)
    c = @comparisons[ [a.class, b.class] ]
    c.nil? ? a == b : c.call( a, b )
  end
end


class Foo
  Kernel.register_compare( self, self ) do |a,b|
    puts "Foo == Foo"
    false
  end

  def ==(b)
    Kernel.compare( self, b )
  end
end


class Bar < Foo
  Kernel.register_compare( self, self ) do |a,b|
    puts "Bar == Bar"
    false
  end

  Kernel.register_compare( self, Foo ) do |a,b|
    puts "Bar == Foo"
    false
  end
end

f1 = Foo.new
f2 = Foo.new

f1 == f2

b1 = Bar.new
b2 = Bar.new

b1 == b2

b1 == f1
f1 == b1


But this has several disadvantages, too: You keep creating all those
temporary arrays and you have the need for O(n**2) comparison operators.

Regards

    robert