Re: Preventing type extensions

[Ludovic Brenta <ludovic@ludovic-brenta.org>]

Ludovic Brenta wrote on comp.lang.ada:
> Pascal Obry writes on comp.lang.ada:
>
>> Ludovic,
>
>>> And people not knowing Ada and thinking that the only OO language was
>>> C++.  I totally agree with Jean-Pierre that Ada has made a very
>>> important contribution to OO technology in distinguishing class-wide
>>> from specific types;
>
>> Well this was part of Smalltalk since the beginning. Not sure Ada has
>> invented anything there :)
>
> I do not remember anything in Smalltalk resembling class-wide types;
> could you please send me an URL? I'm curious.

In fact, after reading up a little bit on Smalltalk, it seems that
every message sent to an object (i.e. primitive operation call)
dispatches dynamically; the programmer does not seem to have a way to
prevent that. As a consequence, a method that sends a message to
"self" redispatches dynamically, every time. This leads to what
Smalltalk programmers call "the yo-yo problem" whereby a single
message (primitive operation call) can in turn cause multiple calls up
and down the inheritance tree; this makes it difficult for programmers
to follow the flow of control. I believe this is exactly the reason
why Dmitry hates redispatching so much.

Ada lets programmers choose whether a primitive operation call
dispatches statically or dynamically, at the call site. To redispatch
dynamically, you do a view conversion to the class-wide type; this is
why class-wide types exist in the first place. Also, during code
review, you can easily see distinguish dynamic calls from static
calls.

I believe that, if Smalltalk had class-wide types, it would be able to
prevent "the yo-yo problem" just like Ada does.

This "yo-yo problem" also exists in Objective-C. In C++, you can force
static calls by qualifying the call, e.g.

void T::method1 () {
  this->method2(); // dynamic redispatch: "this" is of a class-wide
pointer type
  this->T::method2(); // static call due to explicit qualifier
}

--
Ludovic Brenta.