This method is like the include? method but instead of receiving a value and check if the array has it, it receives an array an check if it's part of another one.

file a Feature Request in bugs.ruby-lang.org.

It surprised me that ["a", "c"].part_of? ["a", "b", "c"] returns true.
Should not put local variable declarations after executable code.

@nobu the way I see it is ["a", "b", "c"] includes ["a", "c"]. That's way it returns true.

It seemed like returning true if X is a portion of Y to me, where X.part_of?(Y).
I expected only this would return true:

["a", "b"].part_of?(["a", "b", "c") #=> true

Anyway, you should go to http://bugs.ruby-lang.org/projects/ruby-trunk/issues/new

@nobu Done with the Feature Request: http://bugs.ruby-lang.org/issues/6515

1.9.3p125 :001 > a = [1,2,3,4,5]
=> [1, 2, 3, 4, 5]
1.9.3p125 :002 > b = [2,3,4]
=> [2, 3, 4]
1.9.3p125 :003 > c = [4,5,6]
=> [4, 5, 6]
1.9.3p125 :004 > b == a & b
=> true
1.9.3p125 :005 > c == a & c
=> false

yap @hmaddocks. You're right, that's Set Theory. I'm proposing a much easier way to implement this theory making things much faster. If you review the code you can notice that I'm not comparing the sets because it's more expensive, instead I'm comparing the difference between them with an empty array.

@hmaddocks I tested this PR and one importance difference is that it isn't order dependent as your example

ruby-1.9.3-p125 :001 > a = [1,2,3,4,5]
 => [1, 2, 3, 4, 5] 
ruby-1.9.3-p125 :002 > b = [4,3,2]  # it is your b but in a reverse order
 => [4, 3, 2] 
ruby-1.9.3-p125 :003 > b == a & b
 => false

but

ruby-1.9.3-p125 :001 > [4,3,2].part_of? [1,2,3,4,5]
=> true

The expression

array_1.part_of? array_2

implies to me that you are treating the arrays as atomic units yet your implementation is treating the array as an arbitrary collection of objects i.e., it's the contained objects that are being tested not the array.
[2,3,4] != [4,3,2] even though they contain the same objects.
Seems to me that you want an iterative version of include?

1.9.3p125 :001 > a = [1,2,3,4,5] => [1, 2, 3, 4, 5] 1.9.3p125 :002 > b = [2,3,4] => [2, 3, 4] 1.9.3p125 :003 > a.include? b => false 1.9.3p125 :004 > b.inject{|memo, obj| memo && a.include?(obj) } => true 1.9.3p125 :005 > c = [4,3,2] => [4, 3, 2] 1.9.3p125 :006 > c.inject{|memo, obj| memo && a.include?(obj) } => true 1.9.3p125 :007 > d = [4,5,6] => [4, 5, 6] 1.9.3p125 :008 > d.inject{|memo, obj| memo && a.include?(obj) } => false

I'm closing this, please refer to Feature #6515 on redmine. Thank you!