Issue #7657 has been updated by Nevir (Ian MacLeod). Let me see if I understand the implicit conversion cases: * If an object implements #to_ary, #to_str, etc - it is asserting that it is close enough to the desired type in behavior that we don't need to perform an explicit coercion? * I.e. if I implement #to_ary, I'm asserting that I behave close enough to an Array that you can just use me directly. In that case, why is it an exception if the result of #to_ary is not a subclass of Array? irb(main):001:0> class Thing irb(main):002:1> include Enumerable irb(main):003:1> def each(*args, &block) irb(main):004:2> [1,2,3,4,5].each(*args, &block) irb(main):005:2> end irb(main):006:1> def to_ary irb(main):007:2> self irb(main):008:2> end irb(main):009:1> end irb(main):010:0> Array(Thing.new) TypeError: can't convert Thing to Array (Thing#to_ary gives Thing) irb(main):011:0> [1,3,5] & Thing.new TypeError: can't convert Thing to Array (Thing#to_ary gives Thing) Re: building a Hash under the covers, the use of #hash and #eql? is primarily for the individual elements of the container? From looking at the C source, it looks like #& is just doing a traditional for loop over the array instead of using #each. https://github.com/ruby/ruby/blob/trunk/array.c#L3856 It doesn't seem like that code needs to assert that the input is an array at all except to avoid message dispatch overhead - ary_add_hash is also just doing a standard for loop, from what I can tell: https://github.com/ruby/ruby/blob/trunk/array.c#L3736 Maybe it makes more sense to build the hash via #each (or use the existing functions if the input is an Array, to preserve performance)? ---------------------------------------- Bug #7657: Array#& doesn't accept Enumerables https://bugs.ruby-lang.org/issues/7657#change-35238 Author: Nevir (Ian MacLeod) Status: Open Priority: Normal Assignee: matz (Yukihiro Matsumoto) Category: Target version: ruby -v: ruby 1.9.3p125 (2012-02-16 revision 34643) [x86_64-darwin12.1.0] This seems similar to http://bugs.ruby-lang.org/issues/6923 Example: irb(main):001:0> class Thing irb(main):002:1> include Enumerable irb(main):003:1> def each(*args, &block) irb(main):004:2> [1,2,3,4,5].each(*args, &block) irb(main):005:2> end irb(main):006:1> end => nil irb(main):007:0> Array(Thing.new) & [1,3,5] => [1, 3, 5] irb(main):008:0> [1,3,5] & Thing.new TypeError: can't convert Thing into Array irb(main):009:0> Thing.class_eval do irb(main):010:1* alias_method :to_ary, :to_a irb(main):011:1> end => Thing irb(main):012:0> [1,3,5] & Thing.new => [1, 3, 5] Would it make sense for Enumerable to implement to_ary as well? Or is this purely a bug in Array#&? -- http://bugs.ruby-lang.org/