Re: Ada OO Mechanism

[Samuel Mize <smize@imagin.net>]

Hyman Rosen <hymie@prolifics.com> wrote:
> Samuel Mize <smize@imagin.net> writes:
>>   -- This dispatches on both parameters, so they have to match
>>   -- at run-time
>>   procedure Operation_4 (A: A_Type; B: B_Type);
> 
> (Do you mean B: A_Type ?)
> 
> Thanks, this is the kind of example I meant! This is something that
> C++ can't do by itself. When you say "match at runtime" do you mean
> that their dynamic types must be the same? Does the code raise an
> exception if they happen not to match?

Yep.

I said elsewhere I'd bone up on this and explain it.  Here goes.  I
haven't been actually using this for a couple of years (dang it), so
everybody else backstop me and catch any errors.

In a call on a potentially dispatching function or procedure, all the
tags of the controlling parameter values have to match, or you get a
constraint error at run-time.  And, they must be all statically tagged
or all dynamically tagged.

A value can be statically tagged, dynamically tagged, or tag
indeterminate.

- It's statically tagged if it is of a specific tagged type.

- It's dynamically tagged if it's of a class-wide type.

- It's tag indeterminate ONLY if it's a function call, AND its
  parameters (if any) don't determine its tag.  (Such a function call
  must be able to determine the tag to use for its result from the
  context of the call.)

Note that the tag of a function call depends on the tags of its
parameters.  It's statically or dynamically tagged, whichever the
parameters are.  If there are no statically or dynamically tagged
parameters, the call is tag indeterminate, and you have to be able to
tell from the context of the call what tag to use.

Here is a little example code.  Given the package:

    package T_Types is
      type T1 is tagged null record;

      procedure Op1 (P1: T1; P2: T1);

      type T1_Class_Access is access T1'Class;

      type T1_1 is new T1 with null record;
      -- implicit op1 declared here

      type T2 is tagged null record;

      procedure Op1 (P1: T1'class; P2: T2);

    end t_types;

And the following data items:

    V1: T1;
    V1_1: T1_1;
    V1_Class_Access: T1_Class_Access := new T1;

    V2: T2;

Then we can have the following calls, some of which are illegal
at compile time and one of which raises Constraint_Error at
run time:

    ---------
    -- DISPATCHING TO SUBTYPES OF T1
    ---------

    -- legal -- static call to T1.op1
    op1 (V1, V1);

    -- not legal, tags must match
    --op1 (V1, V1_1);

    -- not legal, must both be either static or dynamic tagged
    --op1 (V1, V1_Class_Access.all);

    -- legal -- dispatching call to op1 in some descendant of T1
    op1 (V1_Class_Access.all, V1_Class_Access.all);

    -- legal -- both are now dynamically tagged
    op1 (T1'Class (V1), V1_Class_Access.all);

    -- legal at compile time, but fails at run time because the
    -- tags don't match
    --op1 (T1'Class (V1_1), V1_Class_Access.all);

    ---------
    -- DISPATCHING TO SUBTYPES OF T2
    ---------

    -- all legal
    op1 (V1, V2);
    op1 (V1_1, V2);
    op1 (V1_Class_Access.all, V2);

I hope you find this of some interest.

Best,
Sam Mize

-- 
Samuel Mize -- smize@imagin.net (home email) -- Team Ada
Fight Spam: see http://www.cauce.org/ \\\ Smert Spamonam