Re: Q: access to subprogram

[wolff@inf.fu-berlin.de (Thomas Wolff)]

Adam Beneschan: >>>Q: access to subprogram
 : It should be noted that the new object-oriented features of Ada 95
 : should make subprogram accesses less necessary than before.  Abstract
I don't agree with this view, see below.

 : types inherently possess subprogram pointers, so it should be possible
 : to take advantage of this feature as an alternative to explicit
 : subprogram accesses.
 : 
 : In Ada 83, I missed being able to do things like this:
 : 
 :     with Pack1;
 :     procedure P1 is
 :         Error_File : Text_IO.File_Type;
 : 
 :         procedure Report_Error (Message : string) is
 :         begin
 :             Text_IO.Put_Line (Error_File, Message);
 :         end Report_Error;
 : 
 :     begin
 :         Text_IO.Create (Error_File, ...
 :         ...
 :         Pack1.Do_Some_Big_Procedure_That_Can_Report_Errors (Report_Error);
 :             -- some people would fire me for using a name like this  :)
 :         ...
 :     end P1;
 : 
 : The purpose is to call a procedure that can generate error messages,
 : and to tell it what I want done with those error messages.  Things
 : can't be done this way in Ada 83.  The problem can be solved using
 : generics in Ada 83, but I've always thought of this as a strange
 : reason for using generics, and it can get hairy (suppose, for example,
 : that the big procedure calls another procedure that also reports
 : errors; now that procedure has to be turned into a generic also, and
 : so on).
Yes, and the same way you think it's a strange way of employing generics, 
I'd also say it's a strange thing to employ objects (of abstract types) 
for this simple (!) purpose alone as you propose below.

 : In Ada 95, you can accomplish this with a subprogram access, but you
 : have to make Report_Error global, and therefore Error_File has to be
 : made global also.  So doing things this way forces you to give up some
 : of the design advantages of using local variables.  (It isn't too big
 : a problem in the above example, but in more complicated situations,
 : making things global can be a real pain.)  This is also one of the
 : things I missed when I was programming in C, since C doesn't have
 : nested procedures.
 : 
 : Another way to do this is with an abstract type.  (PLEASE NOTE: I
 : don't guarantee that my Ada 95 syntax is correct!)  You can declare an
 : "error handler" in some global package like this:

Compare my other response in this thread for remarks about the 
implementation of the discussed language feature.

Thomas Wolff