Re: Array of Variant Records Question...

["Matthew Heaney" <matthew_heaney@acm.org>]

In article <37D96965.81045235@rational.com> , Mark Lundquist 
<mark@rational.com>  wrote:

>> That seems just *too* kludgy to me, and very implemention
>> dependent, wouldn't it be better to just introduce in out
>> and out parameters for functions (but we know that one won't
>> fly ...)
>>
>
> Why would that be necessary, since functions already can have access
> parameters?  OK, the actual must denote an aliased view...


It's like I said in another post: sometimes you have an operation that is
publicly in-mode, but privately in-out.

The function Random is declared this way:

  function Random (G : in Generator) return Result_Subtype;

From an abstract point of view, Generator provides a stream of random
numbers, and function Random simply returns successive values from this
stream.  The stream is just out there, in the ether, and no modification of
this stream is required.

From an implementation point of view, however, invoking the function Random
changes the state of the Generator.  That's why you need a way to "cast away
const," to be able to change state of an object whose parameter mode is in.

The AARM suggests a way to implement this type, by using a level of
indirection.  However, this means allocating the internal state on the heap,
and implementing Generator by privately deriving from Limited_Controlled (to
reclaim the memory).  This is an awfully heavy solution, compared to the
alternative.

Now you're right, you could declare Random this way:

  function Random (G : access Generator) return Result_Subtype;

and everything would be hunky-dory.

But how would you feel about actually using that function:

  declare
    G : aliased Generator;
  begin
    ... Random (G'Access) ...
  end;

Compare that to:

  declare
    G : Generator;
  begin
    ... Random (G) ...
  end;