Re: [OT] interesting reason why a language is considered good

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

On 17.04.12 05:43, Randy Brukardt wrote:
>  Ada requires the names of the parameters to be
> those used in *calls*.

Yes. In case there is a callable.

> ...  The solution is to define the
> parameter names as needed for readability in calls, and then (if those names
> are problematic in the body), rename them for use in the body:
>
>       Exit_Time : Time renames When;
>
> ...
>> begin
>>     while Now<  Scheduled_Departure loop
>>        delay Pausing_Time;
>>        Now := Clock;
>>     end loop;
>>     Actual_Departure (Minute_Of (Scheduled_Departure)) := Now;
>> end Leave;
>
> Unfortunately, this solution makes insanely wordy calls:
>
>      Leave (Scheduled_Departure =>  Now);
>
> In many cases, the parameter names overwhelm the actual values.

So, if Exit_Time is what you'd choose to denote the kind of time
you have in mind, what about

   Leave (Exit_Time => Now) ?

To me, "Exit_Time" says a lot more than "when" in any case!
Why this insistence on "when"?

There is an curious phenomenon here: everyone seems to be
concentrating on parameter names. A case in which there is
context. So there is

- a unanimous vote in case of parameters: "when" is great!
- a workaround for some other cases (but not aggregates, ...)
- thoughtful considerations

Still no answer to the question about a fraction of programs
profiting from identifiers "when" and "others", so much that
they should be allowed. I'd challenge, if I may, the compiler
writers:  Would you compiler writers honestly prefer to write
code like

   for some access in record =>
      when(access) = array(of);

   when when > at =>
   accept record (type) do
      task.type := type;
   done;

Trying to understand the source text requires constantly
switching levels of meanings of the words. Does it really
help?

Nevertheless, I'd add expression functions to the set of
solutions, which now only includes (re)naming of objects.
A kind of the LET expressions:

   function Outer (par1, par2: T) return T is

      function flap return T is
          (par1 + globalN);

      function fluff return T is
          (((par2 + par1)) / 2 * flap);

   begin
      return flap * fluff;
   end Outer