Re: Seeking for papers about tagged types vs access to subprograms

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

On Tue, 7 May 2013 15:27:58 -0500, Jacob Sparre Andersen news wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
> news:1luaso698dpcc$.rrv8385qwl92.dlg@40tude.net...
>>> On Mon, 6 May 2013 20:09:46 -0500, Randy Brukardt wrote:
>>>
>>>>The idea of indexing a numeric type is silly,
>>>
>>> Not at all, consider Unit type declared modular because it has to be used
>>> as a discriminant. At the same time Unit is a composite of powers for mass,
>>> time, current, temperature etc. One would like to have it indexed (viewed
>>> as an array or as a record).
> 
> It might make sense to view it as a record (a capability not in Ada 2012), 
> but it makes little sense to view it as an array (a list of identical 
> components indexed by a potentially *computed* index).

The index could be enumeration.

> There are a lot of 
> abuses of arrays out there that would be much better written as records.

Yes, but the point is that whether array or record interface there could be
reasons for the programmer to add that interface to any type he wished. It
is not the language business to dictate me if I may index or "dismember"
anything. 

>> Another problem is that you cannot make everything Controlled without MD.
>> Because otherwise you will permanently run into problems with primitive
>> operations of multiple types, multi-methods etc.
> 
> Say what? Making everything controlled simply means that every type has a 
> Finalize operation. Dispatching *within* a Finalize operation is usually a 
> disaster (you don't want to redispatch as you might be finalizing the parent 
> part of some child type), so what that has to do with MD is beyond my 
> comprehension.

That is a different issue. I meant that if A and B are controlled/tagged
you will have troubles in using them as parameters of same subprogram. Even
two parameters of same type is a problem already. Only MD can resolve that.

Regarding dispatching Finalize, the thing is broken. The only model of
destruction I know, which would allow dispatching is having class-wide
destructors called prior to specific destructors. You would be able to
dispatch from the former.

And, yes, re-dispatch is a great evil and should never be in the language
in first place. At least class-wide view conversions in Finalize should be
made illegal. But that is too late.

Though Finalize is irrelevant anyway because if constructors/destructors
will ever added to the language that will not happen on the basis of
primitive operations. So Finalize could be left as is.

> I suppose you might get into trouble if you mistakenly try to declare 
> multiple tagged types in a package, but that's always a bad idea and should 
> be avoidable in almost all cases (possibly with careful use of limited 
> with).

I don't see why is it a bad idea to have related types declared in one
package. On the contrary it is a good idea to group related things in a way
making it easer to use. I am glad that Ada does not tie types to packages.

> If you really need multiple types in a package, you have too much 
> coupling between "objects" (in an OO sense), and coupling is always 
> something to be minimized.

Declaration scope is not automatically coupling. But otherwise, yes, index
type is coupled to the array type. Sometimes decoupling is a bad idea
because it leads to weaker typing. E.g. if you wanted to decouple array
index you would end up indexing all arrays by one integer type. Welcome to
C.

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