Does Ada have any idiomatic rules on when to use a function versus a procedure with an output parameter?

Question

You can assign to a variable by having a function return a value to it:

My_Int : Integer := My_Math_Func [(optional params)];

Or you can do it like this with a procedure (assuming My_Int has already been declared):

My_Math_Proc ([optional params;] [in] out My_Int);

Obviously a procedure can't initialize a variable like the function does in the first example, but I'm hoping for some concrete, practical rules on when and why to pick one over the other.

Answer 1

Two to get you started...

When more than one result is to be returned, a procedure with several OUT parameters is often a good choice.

When the size of the object is unknown prior to the subprogram call, an OUT parameter cannot be used because it would have to be declared precisely the right size, but a function return can set the size by initialising the variable in the caller. This is commonly used with a variable declared in a Declare block, which can hold a different sized string each time it is invoked.

This example shows the variable "text" initialised by calling a Read_File function, to hold the contents of a different file on each iteration of the loop. Safe, no "malloc" or "free" or pointers necessary. (Filename is an array of filenames in this example)

for i in 1 .. last_file loop
   declare
      text : String := Read_File(Filename(i));
      -- the size of "text" is determined by the file contents
   begin
      --   process the text here. 
      for j in text'range loop
         if text(j) = '*' then 
         ...
      end loop;
   end
end loop;

Edit : And I suppose I'd better mention the underlying mathematical principle, since Ada is based more closely on mathematical logic than many other languages.

Functions and procedures are both subprograms, but for different purposes:

• a function is an abstraction over an expression : like a mathematical operator (and an operator in Ada is just a function). Ideally, it provides a result from a number of operands and nothing else, leaving them unchanged and having no state and no side effects. This ideal is called a "pure function" (and applying "pragma pure" asks the compiler to check its purity) - similar restrictions apply in functional programming (FP) languages. Pure functions allow a whole bunch of optimisation (because reordering them doesn't change results). In practice Ada is not that strict, allowing impure functions too.

• a procedure is an abstraction over a statement. It generally has some physical effect (such as changing state) since it doesn't deliver a result.

So the logical separation between expressions and statements is carried over into subprograms (abstractions) as the separation between functions and procedures.

And this is probably the best way to decide which to use.