[ruby-core:61517] [ruby-trunk - Feature #9585] Add Object#in? to make ruby easier to read

Issue #9585 has been updated by Robert A. Heiler.


This probably would not be a big addition and not bother many.

I think it can be readable:

  array = [1,2,3,4,5]
  if 3.in? array
    puts 'Yup, is in the array!'
  end

I think one problem may be that it is on a Fixnum here though. Fixnums don't have much.

Also examples like:

  if status.in? 1, 2, 127 # better

Don't really seem much better.

I am neutral about this suggestion.

I do think we should point out that this way of counting is opposite to the current way, as
in:

(1..5).include? 3 # => true

With your proposal you would turn this around, in pseudo-code

3.in? 1..5

So one more to add to Cons would be:
* opposite to the current default way in Ruby.

----------------------------------------
Feature #9585: Add Object#in? to make ruby easier to read
https://bugs.ruby-lang.org/issues/9585#change-45806

* Author: So Wieso
* Status: Open
* Priority: Normal
* Assignee: 
* Category: core
* Target version: 
----------------------------------------
Please add an in? method to all objects, that allows the following:
`
4.in? 1,2,3,4
4.in? 1..4
"a".in? "abc"
7.in? 0..2, 5..8
3.in? small_numbers.select(&:odd?)
=>true
`
Background:
Since my first steps in ruby it always bugs me, that using Array#include? to perform multiple checks in one line breaks symmetry, forces me to read backward and thus lets me stumble in the head. Ruby tries to be close to natural language, and therefore the subject should stand on the left side. Example:
`
if status == 1
if status == 1 or status == 2
if [1,2,127].include? status # breaks symmetry
if status.in? 1, 2, 127 # better
`

Pros:
‣ Nicer to read, no need to read the line backward (brings joy to writers and readers)
‣ No new keyword
‣ Breaks nothing

Cons:
‣ One more method in Object
‣ `"a".in? "abc", "def" vs "a".in? ["abc", "def"]` (implementation is yet an example)

Neutral:
‣ Yet one more way to do it (isn't that ruby-style?)
‣ Belongs to Object, as a comparison operator like ==, eql?, ===, nil?
‣ “only cosmetics” vs elegance

Implementation for testing (you'd certainly find a less naive implementation):
`
class Object
  def in? *args
    raise ArgumentError if args.empty?
    args.any? {|a| a == self or a.include? self rescue false}
  end
end
`
This is related to https://bugs.ruby-lang.org/issues/3845
which was rejected for being an operator (even though the keyword already existed)



-- 
http://bugs.ruby-lang.org/