From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: 
X-Spam-Status: No, score=-0.8 required=5.0 tests=BAYES_00,INVALID_DATE
	autolearn=no autolearn_force=no version=3.4.4
Path: utzoo!mnetor!tmsoft!torsqnt!news-server.csri.toronto.edu!cs.utexas.edu!ut-emx!emx.utexas.edu
From: hasan@emx.utexas.edu (David A. Hasan)
Newsgroups: comp.lang.ada
Subject: layered packages
Keywords: layering reuse factoring
Message-ID: <44213@ut-emx.uucp>
Date: 15 Feb 91 16:18:21 GMT
Sender: hasan@ut-emx.uucp
Organization: UTexas Center for Space Research
List-Id: <comp.lang.ada>

I am having some trouble building generic components in layers.
My motivation is to contruct layers as *independent* generic packages 
by WITHing low layers into higher layers and then adding additional 
features and "reexporting" some of the old features.  I would certainly
appreciate any insight you expreienced Ada folks can give me.

My question is best asked in the context of an example.  Suppose 
I have the following package which exports a primitive
ADT and some fundamental operations on the ADT:

   GENERIC
      TYPE item IS PRIVATE;
      TYPE coord IS (<>);
   PACKAGE grid IS
      TYPE adt IS PRIVATE;
      FUNCTION fetch( from_adt   : IN adt;
                      at_y, at_x : IN coord ) RETURN item;
      PROCEDURE store( the_item   : IN item;
                       in_adt     : IN OUT adt;
                       at_y, at_x : IN coord );
   PRIVATE
      TYPE adt IS ...whatever...;
   END grid;

"grid.adt" could be used for a number of things, but suppose I want 
to build a numerical matrix layer on top.  Here's my attempt:

   WITH grid;
   GENERIC
      TYPE scalar IS PRIVATE;
      -- WITH "+", "-" etc...
      TYPE index  IS (<>);
   PACKAGE matrix IS
      TYPE adt IS PRIVATE;
      FUNCTION fetch( from_adt       : IN adt;
                      at_row, at_col : IN index  ) RETURN scalar;
      PROCEDURE store( in_adt         : IN OUT adt;
                       at_row, at_col : IN index  );
      FUNCTION invert( the_matrix : IN adt ) RETURN adt;
      -- etc...
   PRIVATE
      PACKAGE low_level IS NEW grid(scalar,index);
      TYPE adt IS NEW low_level.adt;
      -- the derived type comes complete with  of low_level
      --    subprograms "fetch" and "store"
   END matrix;

How can one implement "matrix.fetch" and "matrix.store" so that
they are the *same* as the derived subprograms fetch and store visible at the 
end of the PRIVATE part of the package (i.e., how do I reexport them)?
For that matter, how can they be implemented to *call* the derived subprograms?

Should I perhaps use a SUBTYPE instead of a derived type?

----------------------------------------------------------------
: david a hasan -- Univ. of Texas Ctr. for Space Research
:               -- hasan@emx.cc.utexas.edu