How does Integer === 3 work?

ruby

Solution

`Integer` is a class, which (at least in Ruby) means that it is just a boring old normal object like any other object, which just happens to be an instance of the `Class` class (instead of, say, `Object` or `String` or `MyWhateverFoo`).

`Class` in turn is a subclass of `Module` (although arguably it shouldn't be, because it violates the Liskov Substition Principle, but that is a discussion for another forum, and is also a dead horse that has already been beaten many many times). And in `Module#===` you will find the definition you are looking for, which `Class` inherits from `Module` and instances of `Class` (like `Integer`) understand.

`Module#===` is basically defined symmetric to `Object#kind_of?`, it returns `true` if its argument is an instance of itself. So, `3` is an instance of `Integer`, therefore `Integer === 3` returns `true`, just as `3.kind_of?(Integer)` would.

So as I understand it, the `===` operator tests to see if the RHS object is a member of the LHS object.

Not necessarily. `===` is a method, just like any other method. It does whatever I want it to do. And in some cases the "is member of" analogy breaks down. In this case it is already pretty hard to swallow. If you are a hardcore type theory freak, then viewing a type as a set and instances of that type as members of a set is totally natural. And of course for `Array` and `Hash` the definition of "member" is also obvious.

But what about `Regexp`? Again, if you are formal languages buff and know your Chomsky backwards, then interpreting a `Regexp` as an infinite set of words and `String`s as members of that set feels completely natural, but if not, then it sounds kind of weird.

So far, I have failed to come up with a concise description of precisely what `===` means. In fact, I haven't even come up with a good name for it. It is usually called the triple equals operator, threequals operator or case equality operator, but I strongly dislike those names, because it has absolutely nothing to do with equality.

So, what does it do? The best I have come up with is: imagine you are making a table, and one of the column headers is `Integer`. Would it make sense to write `3` in that column? If one of the column headers is `/ab*a/`, would it make sense to write `'abbbba'` in that column?

Based on that definition, it could be called the subsumption operator, but that's even worse than the other examples ...

Problem

Original source