Gem #10: Limited Types in Ada 2005 — Extended Return Statements

by Bob Duff —AdaCore

Let's get started…

A common idiom in Ada 95 is to build up a function result in a local object, and then return that object:

   function Sum (A : Array_Of_Natural) return Natural is
      Result : Natural := 0;
   begin
      for Index in A'Range loop
         Result := Result + A (Index);
      end loop;
      return Result;
   end Sum;

Ada 2005 allows a notation called the extended_return_statement, which allows you to declare the result object and return it as part of one statement. It looks like this:

   function Sum (A : Array_Of_Natural) return Natural is
   begin
      return Result : Natural := 0 do
         for Index in A'Range loop
            Result := Result + A (Index);
         end loop;
      end return;
   end Sum;

The return statement here creates Result, initializes it to 0, and executes the code between “do” and “end return”. When “end return” is reached, Result is automatically returned as the function result.

For most types, this is no big deal — it's just syntactic sugar. But for limited types, this syntax is almost essential:

   function Make_Task (Val : Integer) return Task_Type is
      Result : Task_Type (Discriminant => Val * 3);
   begin
      … -- some statements
      return Result; -- Illegal!
   end Make_Task;

The return statement here is illegal, because Result is local to Make_Task, and returning it would involve a copy, which makes no sense (which is why task types are limited). In Ada 2005, we can write constructor functions for task types:

   function Make_Task (Val : Integer) return Task_Type is
   begin
      return Result : Task_Type (Discriminant => Val * 3) do
         … -- some statements
      end return;
   end Make_Task;

If we call it like this:

    My_Task : Task_Type := Make_Task (Val => 42);

Result is created “in place” in My_Task. Result is temporarily considered local to Make_Task during the “… -- some statements” part, but as soon as Make_Task returns, the task becomes more global. Result and My_Task really are one and the same object.

When returning a task from a function, it is activated after the function returns. The “… -- some statements” part had better not try to call one of the task's entries, because that would deadlock. That is, the entry call would wait until the task reaches an accept statement, which will never happen, because the task will never be activated.

While the extended_return_statement was added to the language specifically to support limited constructor functions, it comes in handy whenever you want a local name for the function result:

   function Make_String (…) return String is
      Length : Natural := 10;
   begin
      if … then
         Length := 12;
      end if;
      return Result : String (1..Length) do
         … -- fill in the characters
         pragma Assert (Is_Good (Result)); null;
      end return;
   end Make_String;