Re: Derived private interface

[Jeffrey Carter <spam.jrcarter.not@spam.not.acm.org>]

On 07/22/2011 03:59 PM, Randy Brukardt wrote:
>
> Given that the problem in question is related to dynamic dispatching and has
> nothing in particular to do with extensions, this is an amazing statement.

My statement was tongue in cheek, intended to express my dislike for tagged 
types. Their only value seems to be all the traffic here from people who run 
into problems trying to use them; this would be a much quieter place without them.

Maybe I'm missing something, but it seems to me that all dispatching in Ada is 
related to extensions. If you have

type T is tagged ...

procedure P (V : in out T);

and you never extend T, then you never get dispatching (in the sense that a call 
to P results in something other than this P being called). To get dispatching, 
you have to extend T

type T2 is new T with ...

overriding procedure P (V : in out T2);

Then you can get a single call that sometimes calls P for T and other times P 
for T2; that's dispatching. I don't know what dispatching means without an 
extension and an overridden subprogram to dispatch to.

> OTOH, programming by composition would provide nothing, in that there would
> be no way to change the handlers for the base type. One could graft some
> sort of unstructured mechanism on top of the objects (possibly using
> access-to-subprograms), but this would provide many more opportunities for
> mistakes (if you forget to set the access-to-subprogram value, the routine
> might as well not exist).

The equivalent of dispatching in programming by composition is a subprogram that 
contains a case statement that contains calls to other subprograms. No 
access-to-subprogram values involved. It does the exact same thing as 
dispatching, except that it's easier to read and understand and doesn't result 
in large numbers of "what am I doing wrong?" posts to c.l.a.

> Remember that there are four legs to the OOP stool: strong typing,
> encapsulation, extension, and dynamic dispatching -- and each of these is
> orthogonal to the others (shown by the fact that Ada has the first two
> without even using tagged types, that is OOP). So there is no necessary
> relationship between extension and dispatching (and working around the one
> does nothing to solve a problem that mainly depends on the other).

Again, I have no idea what dispatching even means in the absence of extension.

In Ada, "programming by extension" is achieved by the use of tagged types; it 
includes dispatching. I have never seen anything implemented using tagged types 
that could not also be implemented using programming by composition. It follows 
that if there is a case where tagged types cause a problem, the equivalent 
solution without tagged types is an effective work around to the problem.

Of course, in the case where there is no solution using tagged types, there may 
also be no solution without using them.

-- 
Jeff Carter
"If you think you got a nasty taunting this time,
you ain't heard nothing yet!"
Monty Python and the Holy Grail
23