On Thu, 8 Jul 2004, Austin Ziegler wrote:

> On Thu, 8 Jul 2004 02:32:36 +0900, Charles Comstock <cc1 / cec.wustl.edu> wrote:
> > At what point does it cause trouble for it to also return true if the
> > class matches?  Can someone give me an example of why it must match an
> > instance and couldn't match the exact class?  I understand it's only
> > matching instances of the class, I just don't follow the logic behind
> > why this is the default.  Is there example code that uses this assumption?
>
> Class === Array

Which works because array is a descendent of class.  I understand that.  I'm
getting the impression that people aren't following why this doesn't make sense
to me so perhaps I can clarify:

------------------------------------------------------------- Module#===
     mod === obj    => true or false
------------------------------------------------------------------------
     Case Equality---Returns +true+ if _anObject_ is an instance of
     _mod_ or one of _mod_'s descendents. Of limited use for modules,
     but can be used in +case+ statements to classify objects by class.


Why is that this is defined like that and not like this:

  Case Equality --- Returns true if anObject is an instance of mod, one of mod's
descendents or _is mod_.

I understand what it matches, that is not the purpose of my line of questions, I
am asking why it doesn't also match itself, and for what reason you would want
to match descendents of x but not x itself.  Does anyone have a logical reason
why this is the case?

Charles Comstock