Re: XML DOM Binding for Ada 95 - matter of style

["Matthew Heaney" <matthewjheaney@earthlink.net>]

"Georg Bauhaus" <sb463ba@d2-hrz.uni-duisburg.de> wrote in message
news:bgoboh$pae$1@a1-hrz.uni-duisburg.de...
> Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>
> You don't need to know about them during the design process,
> but you can construct "signature instances" like so:
>
> generic
>   type X is private;
>   function count(thing: X) return Natural;
>   procedure stretch(thing: in out X);
> ...
>
> and then instantiate "..." with whatever actuals seem fit.

This is exactly how the generic algorithms in Charles work.  Something like:

generic
   type Iterator_Type is private;
   with function Succ (I : Iterator_Type) return Iterator_Type is <>;
   with function Is_Less (L, R : Iterator_Type) return Boolean is <>;
  ...
function Generic_O (First, Back : Iterator_Type)
  return Iterator_Type;

There are only a few algorithms in there, because I'm still busy working on
the containers.


> This doesn't require that the provider of the units from which
> X, count, etc. are taken, has to know beforehand that his/her types,
> functions, or whatever will be used this way.

To a point.  But often, you design a type anticipating that that type will
the used as a generic actual.  For example, in Charles, all the iterator
types (indeed, all the containers) have an identical interface (meaning that
all the operation names are the same).  This allows you pass "default"
subprogram actuals, e.g.

function Op is new Generic_Op (Iterator_Type);
--This works because Succ and Is_Less are directly
--visible at the point of instantiation.


> Actually, you can pass operations of a tagged type as actuals.
> Can this be done with virtual member functions in C++?

Well, yes and no.  You can dispatch on the operation, which would be the
only point of doing it, e.g.

generic
   type T (<>) is abstract tagged limited private;
   with function Op (O : in T) is <>;
procedure Generic_Dispatch (O : in T'Class);

procedure Generic_Dispatch (O : in T'Class) is
begin
  Op (O);   --illegal
end;

To do generic dispatching, you have to use a trick, um, I mean "technique,"
which involves passing a class-wide operation instead:

generic
   type T (<>) is limited private;
   with procedure Op (O : in T) is <>;
procedure Generic_Dispatch (O : in T) is
begin
   Op (O);
end;

Now suppose we have a tagged type:

package P is
   type T is tagged limited null record;
   procedure Op (O : T); --primitive
end;

Somehow we'd like to pass an object of type T'Class as a parameter to the
instantion, and dispatch Op.  The way to do this is create a little wrapper
subprogram for Op:

procedure P.Call_Op (O : in T'Class) is
begin
   Op (O); --dispatches
end;

Now we have everything we need to instantiation generic op.  The solution to
the problem is to pass type T'Class as the generic actual type:

procedure Dispatch is
   new Generic_Dispatch (T => T'Class, Op => Call_Op);

Now when we do this:

procedure Op2 (O : T'Class) is
begin
   Dispatch (O);
end;

then the primitive operation Op will dispatch according to the tag of O.