Re: Looping over a tagged record?

["M. A. Alves" <maa@liacc.up.pt>]

> > Often I also want to merge record and array i.e. have named _and_
> > iteratable "components". Theoretically this comes down to "types as
> > objects", which Ada doesn't have. Practically, a "standard" Ada idiom for
> > this is an heterogenous array indexed on an enumeration e.g. (not tested):
> 
> Could you please elaborate on exactly what you mean by "types as objects"?

Essentialy that you can manipulate types as you do objects.  A language
with less basic semantic devices.  Types would be an elaboration of the
programmer.  A reflexive tower of 2 or 3 levels.  Hardly a software
engineering language.  Roughly approximative model in Ada:

  type Object is ...
  procedure Add_Property(O: Object; Name: String);
  procedure Add_Property(O: Object; Name, Value: String);
  procedure Add_Property(O: Object; Name: String; Value: Object);
  ...

  Record_Type: Object;
  Add_Property(Record_Type, "type", Type_Definition);
  Add_Property(Record_Type, "is a", "list");
  Add_Property(Record_Type, "named components");
  Add_Property(Record_Type, "iteratable");

  A_Record: Object;
  Add_Property(A_Record, "type", Record_Type);

  Field_1, Field_2, Field_3: Object;
  Add_Property(Field_1, "name", "Field_1");
  Add_Property(Field_1, "type", "A");
  Add_Property(Field_1, "name", "Field_2");                                     
  Add_Property(Field_2, "type", "A");
  Add_Property(Field_1, "name", "Field_2");
  Add_Property(Field_3, "type", "B");

  Add_Property(A_Record, "component", Field_1);
  Add_Property(A_Record, "component", Field_2);
  Add_Property(A_Record, "component", Field_3);

Iterating:

  for I in 1 .. Length(A_Record) loop
    Do_Someting(Component(A_Record, I));
  end loop;

Selecting by name:

  Do_Somenthing(Component(A_Record, "Field_1"));

> >
> >   ...
> >   type Field_Ptr is access Field'Class;
> >   type Field_Names is (Field_1, Field_2, Field_3);
> >   type Record_Type is array(Field_Names) of Field_Ptr;
> >   A_Record: Record_Type := (
> >     Field_1 => Field_Constructor_A(...),
> >     Field_2 => Field_Constructor_A(...),
> >     Field_3 => Field_Constructor_B(...));
> >
> > Now we have a record-like object A_Record with "components" Field_1,
> > Field_2 of "type" A and Field_3 of "type" B. This example assumes
> > class-wide programming (including dispatching), with (tagged) type Field
> > being the root of some derivation class. Iterating over A_Record's
> > "components":
> >
> >   for I in A_Record'Range loop
> >     Do_Something(A_Record(I).all); -- dispatching call
> >   end loop;
> >
> > Accessing "components" by name:
> >
> >   Do_Something(A_Record(Field_1).all);

-- 
   ,
 M A R I O   data miner, LIACC, room 221   tel 351+226078830, ext 121
 A M A D O   Rua Campo Alegre, 823         fax 351+226003654
 A L V E S   P-4150 PORTO, Portugal        mob 351+939354002