Re: Real syntax problems in Ada

[Niklas Holsti <niklas.holsti@tidorum.invalid>]

On 12-08-29 13:43 , stefan-lucks@see-the.signature wrote:
> 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"?

You may be right, but surely the syntax is very easy to teach and learn:
if you want to make a subprogram or a package generic, stick "generic"
and the list of generic formals in front of the "package", "procedure"
or "function".

> If the indention is lost,

An artificial assumption.

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

Not really. Start from the end and scan backwards until you find
"package", "procedure", or "function". Or start from the beginning and
find "package", "procedure", or "function" that is not immediately
preceded by "with".

> 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.

There is always a different opinion... I think it is much less readable,
because the separation between the list of generic formals and
subprogram formals is much less visible.

If Ada syntax is changed to put the name of the generic unit before the
formal parameters, I should want to require "with" before every generic
formal, and all within a single set of parentheses. Like this:

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

But as I said, I much prefer the current syntax.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .