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

[Dennis Lee Bieber <wlfraed@ix.netcom.com>]

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.

	From "Programming in Modula-2: 3rd, corrected edition" [N. Wirth; 1985
Springer-Verlag], page 169:

"""
Definition modules imply the use of qualified export. Type definitions may
consist of the full specification of the type (in this case its export is
said to be transparent), or they may consist of the type identifier only.
In this case the full specification must appear in the corresponding
implementation module, and its export is said to be /opaque/. The type is
known in the importing client modules by its name only, and all its
properties are hidden. Therefore,  procedures operating on operands of this
type, and in particular operating on its components, must be defined in the
same implementation module which hides the type's properties. Opaque export
is restricted to pointers. Assignment and test for equality are applicable
to all opaque types.
"""

	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.

	The use of a Modula-2 opaque export doesn't see it as a pointer -- it
just a variable of the named type; the implementation module is where it is
defined a pointer to some structure. Note that a strict reading of PiM-2 is
not defining an "opaque type" but rather an "opaque export" <G>.
-- 
	Wulfraed                 Dennis Lee Bieber         AF6VN
    wlfraed@ix.netcom.com    HTTP://wlfraed.home.netcom.com/