Re: Elimination of "use" clauses

[Richard D Riehle <laoXhai@ix.netcom.com>]

In article <FF2ECA.76@stuyts.nl>,
	jerry@jvdsys.stuyts.nl wrote:

>I am unfamiliar with the term 'opaque type', perhaps because I never looked
>at Modula-3. Can you explain what it means ?

I will answer this question with the warning that my examples
are simply a repetition of already well-known coding practices. 
Also, even though the Ada code will seem slightly longer than
the Modula-3, there are good reasons to prefer the Ada.  Even
so, the ease of creating opaque types in Modula-3 is an attractive
features of that language.

An "opaque type" is a type in which all the details of the type are
encapsulated in an implementation part of a module.  This is required
in Modula-3.  Ada allows us to promote some of the definition to the
private part of the specification.   Ada also allows us to defer the
details to the pacakge body. 

The opaque type is commonly used in Modula-3 where we would use a [limited]
private type in Ada.  

The Modula-3 equivalent of a package specification is now called 
the INTERFACE and equivalent of the package body is called
a MODULE.  Modula-3 does not have a private part in the INTERFACE.
Consider classic generic Stack example in  Modula-3,

GENERIC INTERFACE Stack (SomeElementType);
  TYPE Stack_Type <: REFANY;
  (* procedures for push and pop);
END Stack;

GENERIC MODULE Stack(SomeElementType);
 REVEAL Stack_Type = more details for the stack type
 implementation of push, pop, etc.
END Stack;

My appreciation to MODULA-3 experts who might notice some syntatic
error in my example.  The REVEAL command gives the full definition of
the type from the INTERFACE.
 
In Ada, a generic stack might be designed several ways. We first show the
common textbook example. 

generic
  type StackElementType is private;
  Max  : Positive := 100;
package Stack is
  type Stack_Type is limited private;
  -- declarations for push, pop, etc.
private
  type Stack_Array is array(Positive range <>) of StackElementType;
  type Stack is record
     Top : Natural := 0;
     Data : Stack_Array(1..Max);
  end record;
end Stack;
 
In this example, the private part contains all the information about 
the structure of the stack.  The second Ada example is designed as an 
"opaque type".  

generic
  type StackElementType is private;
  Max  : Positive := 100;
package Stack is
  type Stack_Type is limited private;
  -- declarations for push, pop, etc.
private
  type Stack_Data;
  type Stack is access all Stack_Data;  
end Stack;

where there is no information about the structure of the stack,
even in the private part.  The details of the stack are deferred
to the package body.  For example,

package body Stack is
  type Stack_Array is array(1..Max) of StackElementType;
  subtype Stack_Index is range 0..Max;
  type Stack_Item is record
    Top : Stack_Index := 0;
    Data : Stack_Array;
  end record;
  -- implement push, pop, etc. 
end Stack;

Richard Riehle
richard@adaworks.com
http://www.adaworks.com