Re: Derived private interface

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Tue, 2 Aug 2011 16:16:27 -0500, Randy Brukardt wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
> news:1nvqqny2226ro$.1ixvoiht8zu8l$.dlg@40tude.net...
>> On Mon, 1 Aug 2011 16:56:17 -0500, Randy Brukardt wrote:
>>
>>> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
>>> news:1rlxo1uthv5xt.1agapd9q0mek4$.dlg@40tude.net...
>>> ...
>>>> BTW, Generic_Dispatching_Constructor of Ada 2005 did not change much to
>>>> Ada
>>>> 95 because of tags. You still need a registering layer to maintain
>>>> external name to tag mapping.
>>>
>>> It did eliminate one thing, the need to have a scheme to create an object 
>>> of
>>> each tagged type. That forced the use of either a case statement or an
>>> access-to-subprogram, either of which is error-prone.
>>
>> I don't consider the case statement because it is just a wrong pattern.
>> Regarding mappings type ID to either a constructing function or tag, they
>> are equivalent. Both require the same amount of maintenance.
> 
> There are more sources of error when using access-to-subprogram; it's easy 
> to forget to create a routine or use the wrong one.

Yes there is some advantage that the function in dispatching constructor is
primitive:

   function Create (...) return T;

For access-to-subprogram it is class-wide:

   function Create (...) return T'Class;

As for using a wrong subprogram you can also register a wrong tag. That is
same.

BTW, the patterns are:

      -- with generic dispatching constructor
   type T is tagged ...;
   function Create (...) return T;
   procedure Register (ID : ID_Type; Construct : Tag);

   --- Usage:

   package P is
      type S is new T with ...;
      overriding function Create (...) return S;
   end P;

   package body P is
      ...
   begin
      Register (S_ID, S'Tag);
   end P;

vs.

      -- Ada 95 access-to-subprogram solution
   type T is tagged ...;
   type Factory is access function Create (...) return T'Class;
   procedure Register (ID : ID_Type; Constructor : Factory);

   -- Usage:

   package P is
      type S is new T with ...;
   end P;

   package body P is
      function Create (...) return T'Class is
         ...
      end Create;
      ...
   begin
      Register (S_ID, Create'Access);
   end P;
   
>>> There is no possibility of eliminating the need for some sort of registry --
>>> although in some cases you can use the one built-into the language (the
>>> External_Tag). There has to be a mapping somewhere of some sort of key to a
>>> tag, since it isn't possible to export tags to the "real world".
>>
>> It is possible, and even required for distributed weakly coupled
>> applications, but in order to do that you have to export the types
>> themselves rather than their tags.
> 
> It might be possible for some non-Ada language, but it's not possible for 
> Ada (and this is an Ada site and I was only talking about Ada here).

Well, if Ada designers are serious about addressing distributed systems
(Annex E), that has to happen. Either a kind of IDL must be put into the
Ada standard (highly undesired) or some other, more reasonable, means must
be provided to populate types. [Of course the type system must be brought
in order before even considering this sort of issues.]

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