# Will #in? be in ruby2? (was Re: Finding shared elements between to arrays.)

Eric wrote:

a3 = a1.select { |e| a2.include?(e) }

compare:
a3 = a1.select { |e| e.in? a2}

the latter is more straightforward. the former expression rocks my brain
from left to right.

Can we see light for #in? in ruby2? (just asking since december is near
and i do not see it in mauricioās eigenclass site either)

kind regards -botp

On 10/9/07, PeĆĀ±a, Botp [email protected] wrote:

compare:
a3 = a1.select { |e| e.in? a2}

I really donāt like that proposal. Itās not a property of e that it is
in
a2, its a property of a2 that it contains e.

From: Devi Web D. [mailto:[email protected]]

# that it is in a2, its a property of a2 that it contains e.

pls enlighten my poor brain

i just want to ask if e is in a2. same way like i want to ask eg if e==2
ā¦ in fact, i find #in? so genericā¦

or maybe you want a keyword only like msbasicās

``````e in a2
``````

?

kind regards -botp

Quoth PeĆĀ±a, Botp:

Eric wrote:

a3 = a1.select { |e| a2.include?(e) }

compare:
a3 = a1.select { |e| e.in? a2}

the latter is more straightforward. the former expression rocks my brain
from left to right.

Can we see light for #in? in ruby2? (just asking since december is near
and i do not see it in mauricioās eigenclass site either)

kind regards -botp

Array#include?

arr = [:sym, āstrā] # => [:sym, āstrā]
arr.include? :sym # => true

HTH,

PeĆĀ±a wrote:

or maybe you want a keyword only like msbasicās

``````e in a2
``````

?

kind regards -botp

Why donāt you just define #in? in Object yourself, and then you can use
it anywhere in your code. Thatās something I really like about Ruby: if
Iām missing something from a core or library class, I can just drop it
in for my own use.

mortee

On 10 Oct 2007, at 14:06, PeĆ±a, Botp wrote:

e==2 ā¦ in fact, i find #in? so genericā¦

or maybe you want a keyword only like msbasicās

``````e in a2
``````

?

kind regards -botp

If I understand you correctly the :in? method would have to be
defined in Object (so that all Objects could be tested). So something
like:

irb(main):001:0> class Object
irb(main):002:1> def in?(enum)
irb(main):003:2> enum.include?(self)
irb(main):004:2> end
irb(main):005:1> end
=> nil
irb(main):006:0> 1.in? [1,2,3]
=> true
irb(main):007:0> 4.in? [1,2,3]
=> false

Danielās point (I think) is that this pollutes the top level Object
with a property which for many (most?) Objects is never relevant. If
you never put it an Object into a collection then the idea of being
āinā something makes no sense.

On the other hand it is always an intrinsic part of an Enumerable
implementing class (by definition a collection of Objects) that you
may often need to know whether it āincludesā a specified object.

Iām not sure why the includes construct rocks your brain though. Both

a3 = a1.select { |e| a2.include?(e) }

reads as: āselectā from a1 those e where a2 āincludesā e.

a3 = a1.select { |e| e.in? a2}

reads as: āselectā from a1 those e where e is āinā a2.

That said I always write this as:

a3 = a1 & a2

Alex G.

Bioinformatics Center
Kyoto University

David A. Black wrote:

Hi ā

On Wed, 10 Oct 2007, mortee wrote:

Why donāt you just define #in? in Object yourself, and then you can use
it anywhere in your code. Thatās something I really like about Ruby: if
Iām missing something from a core or library class, I can just drop it
in for my own use.

Itās not risk-free, though, since if two people define a given method
differently, one of them will get trampled on.

method name collisions whithin a module/class coming from different
sources.

I think that this problem should be solved somehow instead of avoiding
the power of ability to extend arbitrary classes. Iām absolutely aware
of the issue though.

mortee

On 10/10/07, PeĆ±a, Botp [email protected] wrote:

As most other posters I am opposed to #in? (really how can it be the
responsibility of an arbitrary object to implement test for
containment) , but I would rather compare

a3 = a1.select{ |e| e.in? a2}

to

a3 = a1 & a2

Cheers
Robert

Hi ā

On Wed, 10 Oct 2007, mortee wrote:

i just want to ask if e is in a2. same way like i want to ask eg if e==2 ā¦ in fact, i find #in? so genericā¦
Why donāt you just define #in? in Object yourself, and then you can use
it anywhere in your code. Thatās something I really like about Ruby: if
Iām missing something from a core or library class, I can just drop it
in for my own use.

Itās not risk-free, though, since if two people define a given method
differently, one of them will get trampled on.

David

On 10/10/07, Robert D. [email protected] wrote:

containment) , but I would rather compare

a3 = a1.select{ |e| e.in? a2}

to

a3 = a1 & a2

ā¦ but it is not the same , & eliminates duplicates, always forget
Sorry
Robert

From: Alex G.

# Objects is never relevant. If

arggh, i wish we could measure that āpollutionā. (sometimes, i even
includes Transās facets gem of extensions My addition of it is not
about polluting, itās about me expressing my thoughts well in a program.
I thought in? would include just a very small helpful code.

# the idea of being āinā something makes no sense.

well i thought that all objects in ruby can be put into a container, so
i reckon #in? (like #include?) would be very handy too. I use it many
times.

# know whether it āincludesā a specified object.

no problem there.

# reads as: āselectā from a1 those e where e is āinā a2.

iām reading it again, and i still find the second one much better to

try reading it like in math or in symbolic logic,

{|e| e.in? a}

read: āe such that e is in aā

whereas

{|e| a.in? e}

read: āe such that a includes eā

suddenly, my point of (object) reference changes from e to a and from
left to right. which is kind of weird to me assumming I were to right it
in a technical report.

I would use include? and in? like the ff,

{|a| a.include? e}

{|e| e.in? a}

note the similarity and difference. clear reading left to right.
Clearly, if thereās a place for include?, there is too for in?.

# a3 = a1 & a2

that was just a simple example (and besides, iām not even sure they are
the same) to show difference bw include? and in?.

kind regards -botp

On 10/11/07, Robert K. [email protected] wrote:

situation when there is an instance method in the class and then a
singleton method definition is attempted.

Jim W. uses something like this in rake. He defines a method
which takes a block containing a method definition

class Module

IF

extension is

the

# end

def rake_extension(method)
if instance_methods.include?(method)
\$stderr.puts āWARNING: Possible conflict with Rake extension:
else
yield
end
end
end

Note that it produces a warning rather than an exception.

Also I guess he figured that Module#rake_extension wouldnāt already
exist!

## It pays to read the classics!

Rick DeNatale

My blog on Ruby

2007/10/10, mortee [email protected]:

differently, one of them will get trampled on.

method name collisions whithin a module/class coming from different sources.

I think that this problem should be solved somehow instead of avoiding
the power of ability to extend arbitrary classes. Iām absolutely aware
of the issue though.

what about an operator like ādef_onceā or ādef!ā which will raise an
exception if the method is defined for that class already? Of course,
we could cook our own using define_method but there are some
restrictions so itās not exactly equivalent to def.

Semantics would have to be carefully chosen. At the moment it seems
that ādef_onceā should raise only if a) the instanceās class has an
instance method of the same name already or b) there is a singleton
method of the same name. However, I am not sure how to deal with the
situation when there is an instance method in the class and then a
singleton method definition is attempted.

What do you guys think? This would at least make sure that you
immediately notice if a method is defined twice and it seems to easier
integrate with the language than selector namespaces.

Kind regards

robert

On 10/10/07, Robert D. [email protected] wrote:

ā¦ but it is not the same , & eliminates duplicates, always forget

Also, #& uses #eql? whereas #include? uses #== .

2007/10/12, George [email protected]:

On 10/10/07, Alex G. [email protected] wrote:

On 10 Oct 2007, at 14:06, PeĆ±a, Botp wrote:
Danielās point (I think) is that this pollutes the top level Object
with a property which for many (most?) Objects is never relevant. If
you never put it an Object into a collection then the idea of being
āinā something makes no sense.

Just playing devilās advocate, but could the same thing not be said
for Object#hash ?

Hehe, very true. I think the judgment whether to put a method in
Object should rather be whether it is sufficient general - which makes
it harder to put down #in?.

Me personally I am rather unbiased on this one apart from that I do
not find the current state of affairs difficult to understand or use.
My 0.02EUR

Kind regards

robert

On 10/10/07, Alex G. [email protected] wrote:

On 10 Oct 2007, at 14:06, PeĆ±a, Botp wrote:
Danielās point (I think) is that this pollutes the top level Object
with a property which for many (most?) Objects is never relevant. If
you never put it an Object into a collection then the idea of being
āinā something makes no sense.

Just playing devilās advocate, but could the same thing not be said
for Object#hash ?