case

A case is a control expression which functions a bit like pattern matching. It allows writing a chain of if-else-if with a small change in semantic and some more powerful constructs.

In its basic form, it allows matching a value against other values:

  1. case exp
  2. when value1, value2
  3.   do_something
  4. when value3
  5.   do_something_else
  6. else
  7.   do_another_thing
  8. end
  10. # The above is the same as:
  11. tmp = exp
  12. if value1 === tmp || value2 === tmp
  13.   do_something
  14. elsif value3 === tmp
  15.   do_something_else
  16. else
  17.   do_another_thing
  18. end

For comparing an expression against a case‘s value the case equality operator === is used. It is defined as a method on Object and can be overridden by subclasses to provide meaningful semantics in case statements. For example, Class defines case equality as when an object is an instance of that class, Regex as when the value matches the regular expression and Range as when the value is included in that range.

If a when‘s expression is a type, is_a? is used. Additionally, if the case expression is a variable or a variable assignment the type of the variable is restricted:

  1. case var
  2. when String
  3.   # var : String
  4.   do_something
  5. when Int32
  6.   # var : Int32
  7.   do_something_else
  8. else
  9.   # here var is neither a String nor an Int32
  10.   do_another_thing
  11. end
  13. # The above is the same as:
  14. if var.is_a?(String)
  15.   do_something
  16. elsif var.is_a?(Int32)
  17.   do_something_else
  18. else
  19.   do_another_thing
  20. end

You can invoke a method on the case‘s expression in a when by using the implicit-object syntax:

  1. case num
  2. when .even?
  3.   do_something
  4. when .odd?
  5.   do_something_else
  6. end
  8. # The above is the same as:
  9. tmp = num
  10. if tmp.even?
  11.   do_something
  12. elsif tmp.odd?
  13.   do_something_else
  14. end

You may use then after the when condition to place the body on a single line.

  1. case exp
  2. when value1, value2 then do_something
  3. when value3         then do_something_else
  4. else                     do_another_thing
  5. end

Finally, you can omit the case‘s value:

  1. case
  2. when cond1, cond2
  3.   do_something
  4. when cond3
  5.   do_something_else
  6. end
  8. # The above is the same as:
  9. if cond1 || cond2
  10.   do_something
  11. elsif cond3
  12.   do_something_else
  13. end

This sometimes leads to code that is more natural to read.

Tuple literal

When a case expression is a tuple literal there are a few semantic differences if a when condition is also a tuple literal.

Tuple size must match

  1. case {value1, value2}
  2. when {0, 0} # OK, 2 elements
  3.   # ...
  4. when {1, 2, 3} # Compiler error, because it will never match
  5.   # ...
  6. end

Underscore allowed

  1. case {value1, value2}
  2. when {0, _}
  3.   # Matches if 0 === value1, no test done against value2
  4. when {_, 0}
  5.   # Matches if 0 === value2, no test done against value1
  6. end

Implicit-object allowed

  1. case {value1, value2}
  2. when {.even?, .odd?}
  3.   # Matches if value1.even? && value2.odd?
  4. end

Comparing against a type will perform an is_a? check

  1. case {value1, value2}
  2. when {String, Int32}
  3.   # Matches if value1.is_a?(String) && value2.is_a?(Int32)
  4.   # The type of value1 is known to be a String by the compiler,
  5.   # and the type of value2 is known to be an Int32
  6. end