Issue #7657 has been updated by Eregon (Benoit Daloze).

Assignee set to matz (Yukihiro Matsumoto)

> Would it make sense for Enumerable to implement to_ary as well?

Matz is not agreeing as you see in #1893:

" Implicit conversion methods such as #to_ary and #to_str should be
  defined only when the object provides (almost) equivalent behavior
  (i.e. method set).  Enumerable and Array are not the case. "

> Or is this purely a bug in Array#&?

Array#& (as well as #|, #-, #uniq and #uniq!) compare elements using #hash and #eql? as they build an Hash for performance reasons (O(m+n) instead of O(m*n), m=size of self, n=size of other array (or self in case of #uniq{,!})).
This is still not documented however for some of these methods, I'll try to fix this.

I think the reason this is done is semantically it makes less sense to have an intersection of an Array and an Enumerable. You would not have the reverse, as Enumerable does not have set-like methods (Array is already stealing a bit of Set in this regard because it is very practical).

As an illustration, [1,2,3] + enumerable raises an error as intended (unless enumerable implements #to_ary). Too loose conversion is dangerous (for example IO#each will only yield once the lines).

It could be done though at the expense of using #each instead of directly iterating on the Array structure, or converting with #to_a. I am not sure the gain of having the implicit #to_a would be clear, so I propose to use [1,3,5] & Thing.new.to_a in your case.

About #1028, it was just a bug in the way of checking whether an argument is an Array or not, the code handling Enumerable was already there (that code is actually almost duplicated with enum_take()).
----------------------------------------
Bug #7657: Array#& doesn't accept Enumerables
https://bugs.ruby-lang.org/issues/7657#change-35233

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/