Re: Signature Package With Generic Proceedure

[Keean Schupke <keean.schupke@googlemail.com>]

On Saturday, 21 July 2012 23:22:36 UTC+1, Adam Beneschan  wrote:
> On Saturday, July 21, 2012 10:22:25 AM UTC-7, Keean Schupke wrote:
> > If I have a package which defines a procedure like:
> > 
> > 
> > generic
> >     with procedure Process(Set : in out Set_Type);
> > procedure Update(Set : in out Set_Type);
> > 
> > 
> > How do a declare a Signature package that includes this?
> > 
> > 
> > generic
> >     with generic
> >         with procedure Process(Set : in out Set_Type);
> >     procedure Update(Set : in out Set_Type);
> > package Set_Signature is end;
> > 
> > 
> > Is not allowed. Is there some way to do this with nested packages?
> 
> There's no such thing as "with generic" in Ada.  That is, there is no way to set things up so that you can instantiate a generic like this:
> 
>    package An_Instantiation is new A_Generic (G1);
> 
> where G1 is the name of a *generic* subprogram or package.  Nor can I think of a reason why you'd want to.  Perhaps if you gave us an example of what you're trying to accomplish?
> 
>                               -- Adam


Why would you want to? Easy... You use signature packages to decouple the implementation from the interface, so that other packages can decide which implementation to use.

Lets say we have two disjoint-set implementations, an Eager_Disjointset and a WUQPC_Disjointset. Both of these share a common interface, which we want to enforce so we declare a separate signature package Disjointset_Signature to describe this common interface.

The algorithms that use Disjointset are written using 


generic
    with package Disjointset is new Disjointset_Signature (<>);
package X is begin


So they can be compiled only 'with' the Disjointset_Signature package.


The final code which uses the algorithm can choose which container implementation to use by:

    package My_Disjointset is new Eager_Disjointset;
    use My_Disjointset;
    package My_Disjointset_Spec is new Disjointset_Signature(
        Set_Type => My_Disjointset.Set_Type
    );
    procedure My_Algorithm is new Algorithm(
        Disjointset_Spec => My_Disjointset_Spec
    );

But another part of the code could use the same algorithm with a different implementation of the container.


The problem comes implementing a function to mutate (update in place) data stored in the container. Maybe we want to implement:

procedure Update(
    Set : in out Set_Type;
    Index : in Index_Type;
    Process : access procedure(
        Element : in out Element_Type
    )
);

But this is slow because the procedure has to be passed as an access and cannot be inlined. So instead we try:

generic
    with procedure Process(
        Element : in out Element_Type;
    );
procedure Update(
    Set : in out Set_Type;
    Index : in Set_Index
);

This is good because 'Process' can be inlined, however how do we express this in the Signature package that represents the interface to these packages?


In the code that uses this we want to instantiate the generic with the relevant Process procedure, without referencing which implementation of Disjointset will eventually be used.

procedure Algorithm(Set : in out Set_Type) is
    procedure My_Process(Element : in out Element_Type) (
        ...
    );
    My_Update is new Update(Process => My_Process);
begin
    for J of Set loop
        My_Update(Set, J);
    end loop;
end Algorithm;


Cheers,
Keean.