Re: Real syntax problems in Ada

[stefan-lucks@see-the.signature]

On Wed, 29 Aug 2012, Dmitry A. Kazakov wrote:

> No, I meant rather this:
> 
>    generic package P (Foo : function return Integer; Q : package...) is ...

Indeed, the syntax for declaring a generic something (after the keyword 
"generic" the parameters come first, and the something and its name comes 
last) is counter-intuitive, different from any other declarations, and 
hurts readability. Consider the following simple example:

   generic
      type Item is private;
      type Many_Items is array(Positive range <>) of Item;
      with function "<"(Left, Right: Item) return Boolean is <>;
   function Minimum(List: Many_Items) return Item;

Ask programmers without Ada experience what this is. Most would read this 
as a generic declaration of something -- but how many would read this as 
the generic declaration of a function called "Minimum"?

If the indention is lost, even Ada-programmers would have problems to find 
out *what* is generically declared (a function) and what its name is 
("Minimum").

Your idea seems to be to alternatively write the above declaration as 

  generic function Minimum
      (type Item is private; 
       type Many_Items is Array (Natural Range <>) of Item; 
       function "<"(Left, Right: Item) return Boolean is <>)
   (List: Many_Items) return Item;

This would be a lot more readable.

> The problem with that could be distinguishing generic and non-generic
> signatures of generic subroutines:
> 
>    generic procedure Baz (X : Integer);
> 
> Is X here a generic formal object or a plain argument of Baz?

Here we are hurt by another minor but annoying inconsistency of the Ada 
syntax. Almost everywhere, we have to write "null" to make it explicit if 
we ask for nothing, or for nothing additional. E.g., we must write

  type X is new Tagged_Type with null record;

instead of 

  type X is new Tagged_Type;

Similarly, we write "if B then null; else Do_Something end if;" instead of 
"if B then else Do_Something end if;". This is an advantage of Ada that 
improves readability and helps to catch flaws.  

Back to the issue you raised! 

If we introduce the notation "(null)" for empty parameter lists, we can 
easily solve your issue:

   generic procedure Baz_1 (with X: Integer) (null);
     -- X is a generic formal object, 
     -- (I am not sure if we should allow or even require "with" here.)

   generic procedure Baz_2 (null) (X: Integer);
     -- X is a plain argument



-- 
---- Stefan.Lucks (at) uni-weimar.de, University of Weimar, Germany  ----
    <http://www.uni-weimar.de/cms/medien/mediensicherheit/home.html>
------  I  love  the  taste  of  Cryptanalysis  in  the  morning!  ------