Ada202X: Easy to use "UML private"-like components

[Martin <martin@thedowies.com>]

I occasionally have the need to explain to people that Ada can support UML public, protected, private class data member scoping but to say it's confusing and clunky would be putting it mildly...

Firstly, I have to public - that's easy:

package CLA is
   type UML_Public is tagged record
      I : Integer; -- public to all, UML "public"
      F : Float;
   end record;
end CLA;


Secondly, I have to explain that using Ada "private" gives you "UML protected":

package CLA is
   type UML_Protected is tagged private;
private
   type UML_Protected is tagged record
      I : Integer; -- private to everyone excepted derived, UML "protected"
      F : Float;
   end record;
end CLA;

Finally, I have to explain that to get "UML private", you need to use an "opaque type" and and "access type":

package CLA is
   type UML_Private is tagged private;
private
   type Opaque;
   type UML_Private is tagged record
      I : Integer; -- private to everyone excepted derived, UML "protected"
      O : access Opaque;  -- has to be access, as compiler doesn't
                          -- know what Opaque is!
   end record;
end CLA;

package body CLA is
   type Opaque is record
      I : Integer; -- private to everyone, UML "private"
      F : Float;
   end record;
end CLA;




By now, the other person is usually rolling their eyes in disbelief and I'm nearly joining them...



There's nothing we can do about Ada "private" v UML "protected" but I think there is a relatively small addition that could be made to the language that would at least avoid the embarrassment of the third part.



My proposal would be to allow an optional "private component list" to record definitions, e.g.

package CLA is
   type UML_Private is tagged private;
private
   type UML_Private is tagged record
      I : Integer; -- private to everyone excepted derived, UML "protected"
   private
      F : Float; -- private to everyone - even derived, UML "private"
   end record;
end CLA;


Where a record had nothing but private components, it could either use:

Option 1:
   type T is tagged record
   private
      F : Float;
   end record;

or

Option 2:
   type T is tagged record
      null;
   private
      F : Float;
   end record;


I prefer Option 2.

Thoughts?

-- Martin