Re: Parameterless generic instance in place of opaque type instance

["Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr>]

Le Sun, 28 Jul 2013 09:02:22 +0200, Yannick Duchêne (Hibou57)  
<yannick_duchene@yahoo.fr> a écrit:
> Say a GADO still defines an ADT, with an unknown discriminant, so that  
> it cannot be instantiated without initialization. What the private  
> declares, is just an access type to a deferred type (defined in the  
> body). The body defines an instance of the type it fully defines. The  
> package offers a single function returning an (opaque) access to this  
> unique and per‑paquage instance, instance. The function could be named  
> `Instance_Reference`, to clearly show it's always the same behind,  
> however a new distinct one per generic instance (not strictly a  
> singleton, a per‑package singleton).

I should have posted an Ada sample, to be more meaningful. Here is:


     generic
     package Samples is
        type Reference_Type (<>)
           is private;
        function Reference
           return Reference_Type;
        procedure Operation
          (Reference : Reference_Type);
     private
        type Data_Type;
        type Reference_Type
           is not null access all Data_Type;
     end;

     package body Samples is
        type Data_Type
           is record
              null;
           end record;
        Data : aliased Data_Type;
        function Reference
           return Reference_Type
           is (Data'Access);
        procedure Operation
          (Reference : Reference_Type)
        is begin
           null;
        end;
     end;

     procedure Use_A_Sample
     is
        package Sample
           is new Samples;
        Reference :
           Sample.Reference_Type :=
             (Sample.Reference);
        procedure Receive_A_Parameter
          (Reference : Sample.Reference_Type)
        is begin
           Sample.Operation (Reference);
        end;
     begin
        Receive_A_Parameter (Reference);
     end;


-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: Epigrams on Programming — Alan J. — P. Yale University