Re: Ada202X: Easy to use "UML private"-like components

[Niklas Holsti <niklas.holsti@tidorum.invalid>]

On 13-06-22 22:05 , Dennis Lee Bieber wrote:
> On Sat, 22 Jun 2013 19:41:00 +0300, Niklas Holsti
> <niklas.holsti@tidorum.invalid> declaimed the following:
> 
>>
>> "The corresponding implementation module must contain a full type
>> declaration for any opaque types declared in the definition module.  The
>> full type declaration must define a pointer type."
>>
>> I take this to mean that a Modula-2 opaque type uses indirection through
>> a pointer type, just as the "stt access types" in Ada, and unlike Ada
>> private types in general.
> 
> 	I suspect that limitation comes about as lacking any knowledge of a
> structure, only the type name, the compiler doing the import has to make
> assumptions about the storage space of the type -- only a pointer would
> have a common, preknown, storage size for all imported opaque types.

Of course. The same consideration applies to the Ada "stt access type".

> 	Ada puts the details of the "hidden" part into the specification, where
> the compiler is capable of determining required space and generating
> instructions to copy (assign) or otherwise manipulate the structure -- even
> while preventing the programmer importing the specification from taking
> advantage of that knowledge.

For private types, yes; for "stt access types", the details of the
accessed type are deferred to the package body, as for Modula-2 opaque
types/exports.

> 	The use of a Modula-2 opaque export doesn't see it as a pointer -- it
> just a variable of the named type;

Just as for an Ada private type which (in the private part of the spec)
is completed as an "stt access type". I think this is the usual way in
which "stt access types" are used in Ada: their "access" nature is not
made public.

> the implementation module is where it is
> defined a pointer to some structure.

But, since Modula-2 allows only pointer types to be opaque, the Modula-2
compiler knows that the type is a pointer even when compiling the
definition module and before compiling the implementation module. Just
as for Ada "stt access types".

Maybe my post was unclear: I tried to contradict Bob Duff's recollection
that an opaque type in Modula-2 is more like an Ada private type than
like an "stt access type". I think that a Modula-2 opaque type is very
similar to an "stt access type". Do you agree with me?

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .