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/