7

Ruby has a fairly powerful case..when..else construct for when you need to match criteria against a single variable. What is the "canonical" way to match criteria against multiple variables without simply nesting case statements?

Wrapping multiple variables in an array (like [x, y]) and matching against it isn't equivalent, because Ruby won't apply the magical case === operator to the elements of the array; the operator is only applied to the array itself.

I'm going to go ahead and respond with a community-wiki answer with a (defeated) stab at this question.

Improve this question
4
  • As far as I know, Ruby does apply === to each element recursively... ideone.com/yMAlZ Commented Feb 1, 2011 at 3:21
  • @Nakilon I've tested, and it doesn't appear to apply it recursively. For example, ['hello', 3] won't match with [String, 3]. Commented Feb 1, 2011 at 3:24
  • aaaa... sorry, my fault. Forgot difference between == and ===. Commented Feb 1, 2011 at 3:25
  • I suspect that Array inherits === from Object, so the default behavior is to compare the hash values of both sides of the test, not to test the contents. If you want a test of types and values, you'll need to add === to Array and implement the behavior desired. Commented Feb 1, 2011 at 3:44

6 Answers 6

Reset to default
4

You need to use an if..elsif..else, and ensure that the variables you want to match against appear on the right-hand side of the === operator (which is what case essentially does).

For example, if you want to match x and y against some criteria:

if (SomeType === x) && (1..10 === y)
  some_value
elsif (:some_symbol === x) && (11..20 === y)
  some_other_value
end
Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

3

This is a simplistic way to add ===:

class Array
  def ===(other)
    return false if (other.size != self.size)

    other_dup = other.dup
    all? do |e|
      e === other_dup.shift
    end
  end
end

[
  ['foo', 3],
  %w[ foo bar ],
  %w[ one ],
  []
].each do |ary|

  ary_type = case ary
  when [String, Fixnum] then "[String, Fixnum]"
  when [String, String] then "[String, String]"
  when [String] then "[String]"
  else
    "no match"
  end

  puts ary_type

end

# >> [String, Fixnum]
# >> [String, String]
# >> [String]
# >> no match
Improve this answer

5 Comments

+1 This is definitely cleaner than my second answer, but isn't modifying the built-in classes somewhat discouraged? That's a genuine question; I'm new to Ruby.
Also, why are you making a copy of other? Will shift affect the array passed as the parameter otherwise? I suppose I'll update my example to reflect that (I already stole Array.all?, which I didn't know about...
I think it's safe modifying Array this way, since Array doesn't implement ===. You get into potentially unsafe waters when you override a base class in a way that breaks expected behavior.
I went ahead and deleted my second answer. For those who were curious, it was a Match class that implemented operator ===. An array could be passed to its constructor with Match.new([String, 1..10]), so it could be used after when.
Do not monkey patch core classes for "convenience" like this, it is a bad practice. At best, it is confusing to people reading your code. At worst, === may be added in the future, or someone else is overriding it expecting a different behaviour. If you really want to do this, wrap your arrays in a custom class that implements === (such as the BiPartite class below).
3

If this pattern is common enough in your code to warrant economical expression, you can do it yourself:

class BiPartite
  attr_reader :x, :y

  def self.[](x, y)
    BiPartite.new(x, y)
  end

  def initialize(x, y)
    @x, @y = x, y
  end

  def ===(other)
    x === other.x && y === other.y
  end
end

....

case BiPartite[x, y]
when BiPartite[SomeType, 1..10]
  puts "some_value"
when BiPartite[:some_symbol, 11..20]
  puts "some_other_value"
end
Improve this answer

1 Comment

+1 Is there a non-disgusting way to make this work with an arbitrary number of parameters? Actually, ideas are popping into my mind, and they don't involve altering the Array class...
2

Since Ruby's when keyword supports a comma separated list of values, you could use the splat * operator. This is, of course, assuming that you're referring to a set of discrete values that are in or could become an array.

The splat operator converts a list of arguments into an array, as frequently seen in

def method_missing(method, *args, &block)

Less well known is the fact that it also performs the inverse operation - turning an array into a list of arguments.

So in this case, you could do something like

passing_grades = ['b','c']
case grade
when 'a'
  puts 'great job!'
when *passing_grades
  puts 'you passed'
else
  puts 'you failed'
end
Improve this answer

1 Comment

After re-reading this, I may mave mis-read the original question - I thought the comparison was between one variable and an array of possible matching values for it.
0

My not battled tested solution is to call .map(&:class) and then is the array in the when statements

def foo(a, b)
  case [a,b].map(&:class)
  when [Integer, Integer]
    puts "Integer"
  when [String, String]
    puts "String"
  else 
    puts "otherwise"
  end
end
Improve this answer

Comments

0

If you're working with strings, or something that converts to strings easily, you might like this solution:

case [city, country].join(", ")
when "San Jose, Costa Rica"
  # ...
when "San Jose, USA"
  # ...
when "Boston, USA"
  # ...
else
  # ...
end
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.