Re: Preventing type extensions

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Fri, 8 Oct 2010 06:58:14 -0700 (PDT), Cyrille wrote:

>> Not at all, in other languages either a subprogram is a method (part of
>> the dispatch table), or it applies to a single type. Class-wide
>> operations are not dispatched, but still can be applied to a whole
>> hierarchy. OK, I dismiss "void *" parameters...
> 
> Looks to me this is the other way around. for instance, in C++ either
> a subprogram is a method or it is what you call a class-wide
> operation.

or a free function.

1. method = polymorphic on the class (=primitive in Ada)
2. class-wide = non-polymorphic on the class (=class-wide in Ada)
3. free = non-polymorphic on the type (=other in Ada)

> That is to say, when your subprogram has a (ref) parameter
> of class C, you can pass it an object of any subclass of C and natural
> calls to method of that object will dispatch to the appropriate one.

True, but it is not T, it is T&. Just like T'Class is not T in Ada, T& is
not T in C++.

It is rather so that C++ does not have specific types for dispatching
(covariant) operations. Except than in constructors and destructors,
implicit "*this" is "class-wide". In constructor and destructor "*this" is
type-specific. Explicit arguments and results are class-wide when
references. They are type-specific otherwise. I.e. the behavior is
determined not only by the type but also by the context... Isn't Ada's
model much more simple and consistent than the above mess?

> Note also that C++ offers a choice between static dispatch and dynamic
> dispatch.

I find it misleading. IMO there is only one dispatch, that is when the
method's implementation is selected according to the type tag. Whether the
tag is statically known or not is IMO irrelevant. An explicit call to a
function in the form T::f() is not dispatch to me, it is a call to a free
function named T::f().

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de