factoring with generics

factoring with generics

[David A. Hasan]

I have a question that deals with using generic subprograms
inside packages as a means of factoring out common implementation
details of the subprograms exported by the package.

Consider a package that exports similar subprograms to its clients:

PACKAGE p IS
   TYPE someType IS ...;
   FUNCTION f1(arg1,arg2 : IN someType) RETURN someType;
   FUNCTION f2(arg1,arg2 : IN someType) RETURN someType;
END p;

and suppose further that the implementations <f1> and <f2> are the same 
except for one subprogram call.  (For example, elementwise addition 
and subtraction of vectors.)

It occurs to me that it might be wise to implement these
as instances of one generic function (<g_f>, say) which takes the 
crucial differing subprogram as a generic parameter.  
To do this, I could:

   1) put the GENERIC DECLARATION and BODY of <g_f> in the body of <p>.
      In this case, the implementations of <f1> & <f2> would 
      instantiate <g_f>.

      But of course, this is hogwash:  generic instantiations
      are *declarations* and cannot be used to define the
      implementation.  So, as an alternative...

   2) put the GENERIC DECLARATION in the package spec and put the
      BODY in the body of package <p>.  <f1> & <f2> could then
      be declared as instances of <g_f>.  This has the pleasant
      side effect of exporting to my clients a generic function
      which they might find useful.

      This works fine until runtime:  when package <p> is elaborated,
      the instantiations for <f1> and <f2> raise PROGRAM_ERROR,
      since the package body (and therefore the body of <g_f>) has 
      not yet been elaborated.

   3) Implement <f1> and <f2> as "skin" routines which simply
      call two internal (to the body of <p>) instances of <g_f>.

      At this point, the simplicity of it all has been lost.


One additional solution might be to factor <g_f> outside of the package
altogether.  However, <f1> and <f2> are fundamentally part of the
abstraction provided by package <p> and cannot be implemented independently.

Is there some way that I have missed to use generics to factor out common
elements of implementations?
--
 :   David A. Hasan
 :   WRW 402 Univ. of Texas at Austin, Austin TX 78712
 :   internet: hasan@emx.cc.utexas.edu 

Re: factoring with generics

[David A. Hasan]

In article <45358@ut-emx.uucp> I wrote:

>PACKAGE p IS
>   TYPE someType IS ...;
>   FUNCTION f1(arg1,arg2 : IN someType) RETURN someType;
>   FUNCTION f2(arg1,arg2 : IN someType) RETURN someType;
>END p;

[ where <f1> & <f2> differ only in one subprogram call ]

>It occurs to me that it might be wise to implement these
>as instances of one generic function (<g_f>, say) which takes the 
>crucial differing subprogram as a generic parameter.  
>To do this, I could:

>   1) put the GENERIC DECLARATION and BODY of <g_f> in the body of <p>.
>      In this case, the implementations of <f1> & <f2> would 
>      instantiate <g_f>.

>      But of course, this is hogwash:  generic instantiations
>      are *declarations* and cannot be used to define the
>      implementation.  So, as an alternative...

Or *is* it hogwash?  This technique is used by Habermann & Perry
in their book "Ada for Experienced Programmers".  In fact, the
LRM seems to indicate that a generic instantiation can be used
as the implementation of a subprogram.  (I reached this
conclusion by threading my way through the BNF -- a technique
I often use when I can't find an explicit discussion of my
problems.)

The DEC compiler objects to the presence of generic
instantiations such as

   FUNCTION f1 is NEW g_f( ... );

on the basis that it constitutes a redclaration of <f1> as it
appears in the package spec.

Anyone know whether this is legal or not?
-- 
 |   David A. Hasan
 |   hasan@emx.utexas.edu 

Re: factoring with generics

[William Loftus]

In article <45441@ut-emx.uucp> hasan@ut-emx.uucp (David A. Hasan) writes:
>In article <45358@ut-emx.uucp> I wrote:
>
>>PACKAGE p IS
>>   TYPE someType IS ...;
>>   FUNCTION f1(arg1,arg2 : IN someType) RETURN someType;
>>   FUNCTION f2(arg1,arg2 : IN someType) RETURN someType;
>>END p;
>
>[ where <f1> & <f2> differ only in one subprogram call ]
>
>>It occurs to me that it might be wise to implement these
>>as instances of one generic function (<g_f>, say) which takes the 
>>crucial differing subprogram as a generic parameter.  
>>To do this, I could:
>
>>   1) put the GENERIC DECLARATION and BODY of <g_f> in the body of <p>.
>>      In this case, the implementations of <f1> & <f2> would 
>>      instantiate <g_f>.
>
>>      But of course, this is hogwash:  generic instantiations
>>      are *declarations* and cannot be used to define the
>>      implementation.  So, as an alternative...
>
>Or *is* it hogwash?  This technique is used by Habermann & Perry
>in their book "Ada for Experienced Programmers".  In fact, the
>LRM seems to indicate that a generic instantiation can be used
>as the implementation of a subprogram.  (I reached this
>conclusion by threading my way through the BNF -- a technique
>I often use when I can't find an explicit discussion of my
>problems.)
>
>The DEC compiler objects to the presence of generic
>instantiations such as
>
>   FUNCTION f1 is NEW g_f( ... );
>
>on the basis that it constitutes a redclaration of <f1> as it
>appears in the package spec.
>
>Anyone know whether this is legal or not?

It is not legal.  A generic instantiation introduces both a spec and body
(see 12.2(1) and 12.2(2)).  A generic instantiation of a procedure in a
package body introduces a spec and body for that routine into the package
body.  If there is a specification of a homograph in the package
specification then there is a redeclaring of the specification of the
subprogram in the package body, and therefore is illegal.  However, this
has been submitted by ALWG as a consideration for Ada 9x.

Also notice that you cannot use a renames solely as an implemenation,
either.
--
William Loftus                   (215) 668 3661
WPL Laboratories, Inc.           UUCP: loftus@wpllabs.UUCP
P.O. Box 111                     ARPA: loftus!wpllabs@prc.unisys.com
216 Wynne Lane
Penn Valley, PA 19072            Ada and Unix Software Consultants

Re: factoring with generics

[David A. Hasan]

In response to a question I asked about using a generic
subprogram in the body of a package to implement the bodies of
various subprograms exported by that package,

loftus@wpllabs.UUCP (William Loftus) writes:

>A generic instantiation introduces both a spec and body
                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                                   (I see...)
>(see 12.2(1) and 12.2(2)).  A generic instantiation of a procedure in a
>package body introduces a spec and body for that routine into the package
>body.  If there is a specification of a homograph in the package
>specification then there is a redeclaring of the specification of the
>subprogram in the package body, and therefore is illegal.  However, this
>has been submitted by ALWG as a consideration for Ada 9x.
>

Thank you.  The answers my question exactly.  I must admit,
however, that I still can't see how those two paragraphs of
the LRM tell me this.  Do you perhaps mean 12(1) and 12(2)?
When it says "An instance of a generic subprogram is a
subprogram", is it really telling me that a spec and body are
generated?

My confusion was doubled by the fact that the Meridian
compiler which I also use actually compiled what DEC's
wouldn't (although I did get a runtime PROGRAM_ERROR).

>Also notice that you cannot use a renames solely as an implemenation,
>either.

Yes, I've tried that in the past and had to mend my ways,
also.  Is there a 9X consideration of that?

Anyway, thanks for the help!

-- 
 |   David A. Hasan
 |   hasan@emx.utexas.edu