Problems using Generic_Dispatching_Constructor

Problems using Generic_Dispatching_Constructor

[Mark Lorenzen]

The generic function Ada.Tags.Generic_Dispatching_Constructor is defined as:

generic
   type T (<>) is abstract tagged limited private;
   type Parameters (<>) is limited private;
   with function Constructor (Params : not null access Parameters) return T is abstract;

function Ada.Tags.Generic_Dispatching_Constructor (The_Tag : Tag; Params  : not null access Parameters) return T'Class;

This gives us some problems when calling an instance of Ada.Tags.Generic_Dispatching_Constructor when the Params parameter is an in-mode parameter of a function e.g.:

function Make (From_Params : in P) return T'Class
   is
      function Make_T_Class is new Ada.Tags.Ada.Tags.Generic_Dispatching_Constructor (T => T, Parameters => P, Constructor => ...);
   begin
   ...
   return Make_T_Class (Some_Tag, P'Access);
   end Make;

This results in a compile-time error:
error: access-to-variable designates constant

Why is function Ada.Tags.Generic_Dispatching_Constructor defined as:
function Ada.Tags.Generic_Dispatching_Constructor (The_Tag : Tag; Params  : not null access Parameters) return T'Class;

and not as e.g (note the access-to-constant type):
function Ada.Tags.Generic_Dispatching_Constructor (The_Tag : Tag; Params  : not null access constant Parameters) return T'Class;

I guess we could declare function Make as (note the in-out mode):
function Make (From_Params : in out P) return T'Class
But this is horrible as functions should never ever have in-out or out-mode parameters (or side effects in general).

Why are access types used at all?

Is there another workaround?

Regards,
Mark L

Re: Problems using Generic_Dispatching_Constructor

[Dmitry A. Kazakov]

On 2022-06-01 13:36, Mark Lorenzen wrote:

> Why are access types used at all?

Parameters are kind of factory object, you want to have the factory mutable.

> Is there another workaround?

In my practice I never had a case when I could obtain the tag needed for 
generic dispatching constructor. All my designs ended up with a mapping

    key -> constructing function

with an explicit registering the type in the mapping.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Problems using Generic_Dispatching_Constructor

[Randy Brukardt]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:t77mrv$1e20$1@gioia.aioe.org...
> On 2022-06-01 13:36, Mark Lorenzen wrote:
>
>> Why are access types used at all?

We needed this usable to implement dispatching stream attributes (the 
generic dispatching constructor was intended to be a user-definable 
generalization of the mechanism of the class-wide stream attribute). The 
stream attributes probably used access types because "in out" parameters 
were not allowed for functions when they were invented. (So mistakes piled 
on mistakes. :-)

> Parameters are kind of factory object, you want to have the factory 
> mutable.

Right. For instance, consider a factory where each object gets a unique ids 
while being constructed. You would want to update the Next_Id component at 
the end of each construction.

>> Is there another workaround?
>
> In my practice I never had a case when I could obtain the tag needed for 
> generic dispatching constructor. All my designs ended up with a mapping
>
>    key -> constructing function
>
> with an explicit registering the type in the mapping.

Right. Generally, one uses a mapping of some sort of key or menu choice or 
whatever to tags. If you aren't adverse to a giant case statement, then you 
might as well call the constructor directly. (And if you are willing to use 
access-to-functions, you don't need OOP at all.) So this "factory" is mostly 
a bone for OOP purists.

The one exception is the case where you have an external tag as the key, 
since you can get the tag from that directly. But even that is really a 
mapping (one built by the implementation).

                          Randy.