In Ruby, how do I switch on a variable containing a class object?

I agree that === (the test used by case) can be confusing.

It's often called "case equality operator", but === is neither reflexive nor symmetric nor transitive, so it doesn't behave like an equality at all :

String === "test" # true "test" === String # false String === String # false String === Class # false Class === String # true Class === Class # true 

The best description I've read for a === b is from @JörgWMittag's answer :

"If I have a drawer labelled a would it make sense to put b in that drawer?"

For your problem, you could write :

v = String case v when Class puts "#{v} is a Class, let's investigate some more" # another case, if statements or hash lookup... else puts :other end 

How am I supposed to 'switch' on a variable containing one of several class objects?

With Module#<=:

case v when String then "instance of string" when ->(c) { c <= String } then "class derived from String" end 

How does this honour the well-established computing principle of 'least surprise'?

Perfectly.

You can use case without an object:

case when v == String puts 'v is String class' when v.is_a?(String) puts 'v is an instance of String' else puts 'v is something else' end 

This resembles an if-elsif-else expression.

Case expressions in ruby and some other functional languages are quite different from their imperative switch statement cousins.

As others have mentioned, case expressions use the === method, which is a pattern-defining method. In the a === b paradigm, a is a pattern which describes a collection of possible instances. b is an instance which potentially fits into that pattern / collection. Think of a === b as:

does 'a' describe 'b'?

or

does 'a' contain 'b'?

Once you understand this, String === String #=> false is not so surprising because String is an instance of Class so it fits into the Class pattern.

The other unique distinction between case expressions and switch statements is that case expressions are just that: expressions. Which means you can do cool stuff like this:

puts case v.name when "String" :String else :other end if v.is_a? Class 

This code executes only if v is a class, then switches on v.name and puts whatever you want, based on the name of the class.

Because of ruby's nature as a duck-typed language, it's exceedingly rare to have a class in a variable and need to switch on it. If you're frustrated that case isn't as elegant as you had hoped, give us more context about your goal and we might be able to come up with an elegant solution which avoids switch all together.