Re: Array of Variant Records Question...

["Matthew Heaney" <matthew_heaney@acm.org>]

In article <Pine.BSF.4.10.9909091910250.12989-100000@shell5.ba.best.com> ,
Brian Rogoff <bpr@shell5.ba.best.com>  wrote:

> Matt, can you give examples where you find that explicit conversions are
> painful, or damage readability?

Consider the Interpreter pattern.  An And_Exp is a Bool_Exp object with two
components, a left exp and a right exp.

The spec looks like this:


package Bool_Exps.And_Exps is

   type And_Exp is new Bool_Exp with private;

   function New_And
     (L, R : access Bool_Exp'Class)
      return Bool_Exp_Access;

    ...

private

   type And_Exp is
     new Bool_Exp with record
        L, R : Bool_Exp_Access;
     end record;

end Bool_Exps.And_Exps;


As you can see above, the constructor for the type accepts two access
parameters, and returns a pointer to the class-wide root type, which is
defined as

  type Bool_Exp_Access is access all Bool_Exp'Class;


Here's the implementation of the constructor:

   function New_And
     (L, R : access Bool_Exp'Class)
      return Bool_Exp_Access is

      use And_Exp_Storage;

      Exp : constant Exp_Access := New_Exp;
      -- type Exp_Access is access all And_Exp;
   begin
      Exp.L := Bool_Exp_Access (L);    -- (1)
      Exp.R := Bool_Exp_Access (R);    -- (2)

      return Bool_Exp_Access (Exp);    -- (3)
   end New_And;


Observe the following:

(1) L is an access parameter.  I have to manually convert

  L : access Bool_Exp'Class

to an access value of type

  type Bool_Exp_Access is access all Bool_Exp'Class;

What's the point?


(2) Same for R as for L in (1).

(3) Exp is an access object designating an And_Exp value.  I have to
manually convert an access value from

  type Exp_Access is access all And_Exp;

to an access value of

  type Bool_Exp_Access is access all Bool_Exp'Class;

But what's the point?  An And_Exp value is in And_Exp, but it's also in
Bool_Exp'Class.

The issue is that a tagged object kinda sorta has potentially many types:
it's own specific type, and the class-wide type of each of its ancestors.

I would prefer that all these manually conversions be done implicitly, so I
could just write:

   function New_And
     (L, R : access Bool_Exp'Class)
      return Bool_Exp_Access is

      use And_Exp_Storage;

      Exp : constant Exp_Access := New_Exp;
   begin
      Exp.L := L;
      Exp.R := R;

      return Exp;
   end New_And;


It's not a show-stopper though...