Re: labeling (was: partitioning (was: Future))

[Richard Riehle <richard@adaworks.com>]

In my original comment about the value of labels for
many Ada constructs, I did not anticipate the many
variations on the theme that might be concocted.

My comments were a complaint that curly braces in
the C family of languages would be more useful if they
permitted scope delimiting labels that could be checked
by the compiler.    We wouldn't need these everywhere,
only where they would add clarity.

Ada already provides this feature for adding clarity.
And we can insert it anywhere we wish in long blocks
of code (not that I am recommending long blocks of code).
It is nice that the labels are checked by the compiler as
well as improving readability by humans, programmers
included.

I really don't think it is necessary to add new labeling
features to the language for selection statements, as
some have suggested.   For me, end case and end if
are quite enough.

However, it is sometimes useful to create a begin..end
block with a label for especially long constructs.   For
example,

        case X is
             when Sigma => Sigma_Process:
                                       begin
                                            sequence-of-statements
                                       end Sigma_Process;
            when Theta =>  Theta_Process:
                                      begin
                                           handled-sequence-of-statements
                                      exception
                                           sequence-of-statements
                                      end Theta_Process;
        end case;

If it is a really long case statement, the case statement can
be wrapped in a labeled begin..end block.

However, I don't favor this for compilers that support pragma
inline well.   Instead, the above code can be made more effective
by promoting it to a private child package, or enclosing the long
begin..end statements into nested inlined procedures.  Even the
case statement itself can be promoted to an inlined procedure.

        procedure P is
             -- local declarations
             procedure Theta_Process is ... begin ... end Theta_Process;
             pragma Inline(Theta_Process);
             procedure Sigma_Process is ... begin ... end Sigma_Process;
             pragma Inline(Sigma_Process);
             -- more declarations
       begin
            case X is
                when Sigma => Sigma_Process;
                when Theta =>  Theta_Process;
            end case;
      end P;