Итак, я пытаюсь исправить класс, чтобы он мог использоваться для хэш-ключа. Однако, похоже, я не могу заставить его работать. Вот пример тестового случая:

 class Tmp
 def hash; rand(); end
end

module Patch
 refine Tmp do
  def hash; 1; end
  def eql?(rhs); hash == rhs.hash; end
 end
end

puts "=========================="
module A
 # Using the initial implementation of Tmp
 x = {}
 x[Tmp.new] = 1
 x[Tmp.new] = 2
 puts "#{Tmp.new.hash == Tmp.new.hash}"
 puts "#{Tmp.new.eql? Tmp.new}"
 puts "#{x}"
end

puts "=========================="
module A
 # Enabling the refinement of class Tmp here
 using Patch
 x = {}
 x[Tmp.new] = 1
 x[Tmp.new] = 2
 puts "#{Tmp.new.hash == Tmp.new.hash}"
 puts "#{Tmp.new.eql? Tmp.new}"
 puts "#{x}"
end
 

Это дает результат:

 ==========================
false
false
{#<Tmp:0x0000407e4ae818>=>1, #<Tmp:0x0000407e4ae7a0>=>2}
==========================
true
true
{#<Tmp:0x0000407e4ae188>=>1, #<Tmp:0x0000407e4ae110>=>2}
 

Как вы можете видеть, методы #eql? и #hash работают так, как ожидалось, но когда я пытаюсь использовать их в качестве хэш-ключа, он думает, что это разные ключи. Что я делаю не так?

Редактировать

В качестве отступления, в документах говорится:

Два объекта ссылаются на один и тот же хэш-ключ, если их хэш-значение идентично и два объекта являются eql? друг другу.

Определенный пользователем класс может использоваться в качестве хэш-ключа, если хэш и eql? методы переопределяются, чтобы обеспечить осмысленное поведение.

(Emphasis mine)

It’s interesting that that only #eql? seems to be used to determine key equality:

 class Tmp
 def hash; rand; end
 def eql?(rhs); true; end
end

puts "=========================="
module A
 x = {}
 x[Tmp.new] = 1
 x[Tmp.new] = 2
 puts "#{Tmp.new.hash == Tmp.new.hash}"
 puts "#{Tmp.new.eql? Tmp.new}"
 puts "#{x}"
end
 

Дает:

 ==========================
false
true
{#<Tmp:0x0000407e407b08>=>2}
 

Возвращаемое значение #hash не имеет значения:

 class Tmp
 def hash; 1; end
 def eql?(rhs); false; end
end

puts "=========================="
module A
 x = {}
 x[Tmp.new] = 1
 x[Tmp.new] = 2
 puts "#{Tmp.new.hash == Tmp.new.hash}"
 puts "#{Tmp.new.eql? Tmp.new}"
 puts "#{x}"
end
 

Дает:

 ==========================
true
false
{#<Tmp:0x0000407e40e408>=>1, #<Tmp:0x0000407e40e3b8>=>2}
 

Что, похоже, противоречит документам. Является ли это артефактом использования ruby v2.2.4? (Я использую ruby, который поставляется с Sketchup 2017)

Вы реализуете свой класс с явно непоследовательным поведением. Для любого объекта, где a.eql?(b) тогда по определению a.hash == b.hash as #hash должно отражать фактическое содержимое объекта. Если этого не произойдет, вы получите очень странные результаты.

Это похоже на то, как при написании компаратора сортировки, если a < b и b < c тогда a < c должно быть верно. Если по какой-то причине это не так, то ваши операции сортировки приведут к очень странным и противоречивым результатам.

Другими словами:

• a.eql?(b) должно быть истинно тогда и только тогда, когда a и b представляет собой одно и то же.
• a.hash == b.hash должно быть правдой, если a и b представлять одно и то же.

Обратите внимание, что a.hash == b.hash это не означает, что они обязательно одно и то же, но это указывает на высокую вероятность того, что это так. Для eql? подтверждения этого всегда необходима дополнительная проверка.

Внутренние хэш-функции могут вызывать или не вызывать обе эти функции. При небольших размерах рубиновый «Хэш» вообще не является хэш — таблицей, это просто крошечный массив. Как таковой, #hash может даже не вызываться до тех пор, пока таблица не достигнет определенного размера, и этот метод имеет значение.