From: hal9000@...
Date: 2000-09-27T05:10:02+09:00
Subject: [ruby-talk:5141] Re: Types and ===


>
> class String
>         private
>         OldString = String.dup
>         public
>         def ===(other)
>                 if other.is_a? Regexp
>                         return other === self
>                 end
>                 return OldString.new(self) === other
>         end
> end
>
> --
>  Brian Fundakowski Feldman           \  FreeBSD: The Power to Serve!

Yes, this works.

This whole discussion raises some questions in my mind, though.

(By the way, I've enjoyed it. I like theoretical discussions very
much, though I have a practical side, too.)

First of all, I think I disagree with the assertion that the case
statement is usually used in non-commutative situations. I think
the most common use (this is just my first thought) is when the
tested expression is the same type as the case limb expressions,
in which case it becomes a simple equality test.

Second of all, I think it's worth noting that the meaning of
"receiver === other" doesn't just depend on the type of receiver,
but also on the type of other.

Therefore, isn't it conceivable that the === operator could be *made*
to be commutative in all circumstances? It seems to me this could be
done without violating any OOP principles.

Are there any two types X and Y such that  x===y and y===x both have
meaning, and mean different things?

Hal

--
Hal Fulton


Sent via Deja.com http://www.deja.com/
Before you buy.