When I have a method that is applied to instances of a class X that do
not depend on
the values of the instances themselves I place those methods on the
class side.
For the problem at hand the method takes as input a collection of the
instances of
the class and rearranges them in some way:
Such a method might be called:

    rearrange:  aCollection

(Actually I lied; the rearrange method depends upon probability
values stored in instances of  X)
To get an instance of the object to do the rearranging (i.e.  X) on the
instance side of  X  I have a method:

    rearranger
        ^self class

This works fine so far but in this particular case  X
has subclasses and the collection passed to the method
"rearrange:"  is not impacted by the fact that instances of
the subclasses of  X  may  be in the Collection;  i.e. everything
still works.

However, if I send the "rearranger" message to an instance of
a subclass  Y  of X  then -- well ok;  everything still works.
Everything still works because the "rearranger" message now
returns a subclass of  X  which in turn inherits
the  "rearrange:"  method from  class  X.

My only complaint then is that every time the "rearrange:"
message is sent inheritance must now be used to find the
"rearrange:"  method.
This seems inefficient to me (I know  Squeak is 50 slower than
C so who cares) so to fix this I can change method  "rearranger"
to:

  rearranger
        ^X        "the class X that is"

Problem fixed.
However, I have been taught that now the code is written in
a brittle i.e. bad way.  That is, if I now rename class  X  to
Z  then the  "rearranger" method becomes broken.

Finally, a question:
How do I write the method  "rearranger"  so that it returns
the class in which the method is defined rather than the class
of the object that received the "rearranger" message?
I am looking for something clean here;  I can think of some
convoluted ways of doing this.

I admit that even if this can be done cleanly the code remains
more brittle than the original solution.  This is because
if a subclass of  X  wants to override  method  "rearrange:"
it must now also override method  "rearranger"  which was
not necessary with the original solution.

I am also aware that optimizations are done by the VM to
avoid method lookups but I am not sure of the details.
Do the details mean that after the first send of  "rearrange:"
to  class  Y  no further lookups are needed on subsequent
sends?  to  Y.
What if  "rearrange"  is  sent to  Y  from multiple
locations in some method  or from multiple methods in some class
all sending to the same instance variable holding  Y?


Regards,

Ralph Boland