Re: procedural variables

[madmats@elcgl.epfl.ch]

In my opinion, procedure variables were not included in Ada because of the
restrictions that must be placed upon them, making the feature non-ortho-
gonal. Most languages that have procedure variables allow only top-level
(i.e. declared as library units or immediately within library packages)
procedures as their values. This is the case of Modula-2 for instance.
The reason for this restriction is obvious: otherwiswe, a local procedure
might be called in a situation where its context is not present, as in the
following example written in PV-Ada (Ada with proc. variables):

   ...                       

   type Proc is procedure;  -- parameterless

   X : Proc;

   procedure P is

      A : Integer;

      procedure Q is
      begin
         A := A + 1;
      end;
   
   begin
      X := Q;
   end P;

   ...

   P;
   X;  -- this should be a call to P.Q, which makes no sense.

Now one might argue that it is easy to check (at runtime) if X's context 
is present at the moment X is called, but this is not so true because a 
simple check that P is currently being called is not sufficient as
different invocations of P may create different contexts for Q, for 
instance by declaring subtypes with non-static bounds.
This issue of 'dangling subprograms' is treated in more detail in the
context of an object-oriented extension to Ada in Norman Cohen's
report "Ada subtypes as subclasses", which I recommend.

For Ada-9X, I would much prefer an object-oriented extension than support
for procedure variables, because this would greatly extend the expressive
power of the language and would simultaneoulsy provide support for
procedure variables for those who really want them: a procedure value 
would be an object with no data and only one method. To me, a procedure
value not tied to an object does not make much sense.

After all, the 'need' for procedure variables has only
become serious since people have been trying to interface x-toolkits
with Ada (callbacks), but does that mean that callbacks are the right
way of doing it ?

Mats Weber