Ruby on Rail bitwise operators (&) for the complex types arrays

Question

I am trying to use the bitwise operator (&) for the arrays in the Ruby on Rails

When I have the simple type arrays

one = ["one", "two", "three"]
two = ["one", "two", "three"]

And have this code

puts (one & two)

I get the output:

one two three

However, when I am having the complex types arrays

list1 = [Someitem.new("1", "item1"),Someitem.new("2", "item2"),Someitem.new("3", "item3"),Someitem.new("4", "item4")]
list2 = [Someitem.new("1", "item1"),Someitem.new("2", "item2"),Someitem.new("3", "item3"),Someitem.new("4", "item4")]

For the class where I do override the to_s method

class Someitem
    attr_accessor :item_id, :item_name
    def initialize(item_id, item_name)
      self.item_id = item_id;
      self.item_name= item_name;
    end
    
   def to_s
     item_name
   end  
end

And have this code

puts (list1 & list2)

I get nothing in the output

What can I do to get the output for the complex types arrays using the bitwise & operator to find common values within those two lists?

Stefan · Accepted Answer · 2021-09-26 10:43:49Z

3

The Ruby 3.0 docs for Array#& say:

[...] items are compared using eql?

The Ruby 2.7 docs for Array#& say:

It compares elements using their hash and eql? methods for efficiency

So in order to get this working for your class, you have to implement / override eql? and (for 2.7 compatibility) hash according to the docs. There are many ways to do this, here's a simple approach:

class Someitem

  # ...

  def hash
    [item_id, item_name].hash
  end

  def eql?(other)
    return false unless other.is_a?(Someitem)

    [item_id, item_name] == [other.item_id, other.item_name]
  end
  alias == eql?  # <- this isn't needed but convenient
end

The above implementation uses item_id and item_name to calculate the object's hash and to determine object equality:

Someitem.new("1", "item1").hash == Someitem.new("1", "item1").hash
#=> true

Someitem.new("1", "item1").eql? Someitem.new("1", "item1")
#=> true

[Someitem.new("1", "item1")] & [Someitem.new("1", "item1")]
#=> [#<Someitem:0x00007f8ff505d228 @item_id="1", @item_name="item1">]

edited Sep 26, 2021 at 10:43

answered Sep 25, 2021 at 21:30

Stefan

115k14 gold badges157 silver badges233 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Cary Swoveland Over a year ago

Note that if the instance methods eql? and hash are not defined on the class Someitem the methods Kernel#eql? and Kernel#hash apply. (Someitem.instance_method(:eql?).owner #=> Kernel; Someitem.instance_method(:hash).owner #=> Kernel.)

Cary Swoveland · Accepted Answer · 2021-09-25 20:46:20Z

Firstly, while Integer#& is the bit-wise AND operator, Array#& is the set intersection operator (though I find the term "set" grating because an array is not a set).

You appear to be assuming that

Someitem.new("1", "item1") == Someitem.new("1", "item1") #=> true

However, the two instances are not the same object, so in fact:

Someitem.new("1", "item1") == Someitem.new("1", "item1") #=> false

Recalling that every object has a unique object_id, consider the following:

list1.map(&:object_id)
  #=> [1520, 1540, 1560, 1580]
list2.map(&:object_id)
  #=> [1600, 1620, 1640, 1660]

Since [1520, 1540, 1560, 1580] and [1600, 1620, 1640, 1660] have no common elements we see that their intersection is empty:

list1.map(&:object_id) & list2.map(&:object_id)
  #=> [1520, 1540, 1560, 1580] & [1600, 1620, 1640, 1660]
  #=> []

razvans · Accepted Answer · 2021-09-25 20:52:43Z

When arrays are involved, & is actually the intersection, it's not the bitwise AND.

To return the common elements between your lists, the #hash method is called.

For your first example, calling "one".hash returns the same value all the time, which is actually a hit.

"one".hash # => 103347303317675750
"one".hash # => 103347303317675750

In the second example you work with different instances, which, of course don't match.

Someitem.new("1", "item1").hash # => a_value
Someitem.new("1", "item1").hash # => another_value

If you pass the same instance to both arrays, it will match.

 a = Someitem.new("1", "item1")
 a.hash # => a_value
 a.hash # => same_value_as_above

 list1 = [a]
 list2 = [a]
 list1 & list2 # => [a]

Collectives™ on Stack Overflow

Ruby on Rail bitwise operators (&) for the complex types arrays

3 Answers 3

1 Comment

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related