Re: on the need to duplicate code for procedure signature in both body and interface files

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Jeffrey Carter <spam.jrcarter.not@spam.not.acm.org> writes:

> Consider the following:
>
> package P is
>    function F (I : Integer) return Integer;
>
>    type Integer_List is array (Integer range <>) of Integer;
>
>    function F return Integer_List;
> end P;
>
> How are you going to write the body of P so the compiler knows which
> body implements which function F without repeating the parameter list
> and return type profile, which is what distinguishes these 2 overloaded
> functions?

Well, that wouldn't be too hard of a problem to solve.
I think the real reason for duplicating the information
is readability.

For example, you could require that two functions in the same scope
have different names.  You could still use overloading via
renames:

   function F_Integer (I : Integer) return Integer;
   function F (I : Integer) return Integer renames F_Integer;
   ...
   function F_Integer_List return Integer_List;
   function F return Integer_List renames F_Integer_List;

I tend to use this style anyway, because then the debugger
tells me which function I'm in.  Also, if this were the rule,
the compiler could more easily give good error messages.
Consider:

    procedure P (X : Integer);
    ...
    procedure P (X : Long_Integer) is -- Wrong.
    begin
        ...
    end P;

where the mistake is that I changed Integer to Long_Integer
in one place but forgot the other.  A typical compiler will
complain incorrectly that P doesn't have a body.

One could facilitate the above renamings with a shorthand:

   function F_Integer, F (I : Integer) return Integer;
   function F_Integer_List, F return Integer_List;

- Bob