Re: Files and controlled types

[Maciej Sobczak <see.my.homepage@gmail.com>]

On 10 Mar, 16:37, Adam Beneschan <a...@irvine.com> wrote:

> I'm not so sure.  What happens here?
>
>     procedure New_File (I : in Integer) is
>        Name : String := "temp/" & Integer'Image (I) & ".txt";
>        F : Ada.Text_IO.File_Type;
>     begin
>        Ada.Text_IO.Put_Line ("Opening " & Name);
>        Ada.Text_IO.Create (F, Ada.Text_IO.Out_File, Name);
>        Ada.Text_IO.Set_Output (F);
>     end New_File;
>
>     procedure Proc is
>     begin
>        New_File (-17);
>        Ada.Text_IO.Put_Line ("This is written to default output");
>     end Proc;

I will describe what I expect it to do (instead of guessing around the
AARM).

The F object in New_File, when going out of scope, is finalized and it
is when it is discovered that the file reference was "leaked" outside.
The exception is raised at this point.

Now consider the following extension to the library and the change in
behavior:

Ada.Text_IO.Set_Output (Ada.Text_IO.Release (F));

where Release is a hypothetical function that removes the ownership
from F and is used *exactly* to transfer the resource to other
managing object. Then, the F is finalized but this has no effect (F is
no longer an owner of the resource).
Note that Release can return a type that is different from File_Type
to actually enforce this protocol at compile time (no way to pass F
directly to Set_Output).

> The bottom line is that things just aren't so simple, and it's not
> obvious whether a File_Type "should" cause a Close when the File_Type
> is finalized.

From my perspective, this part of the library is half-baked.
Note also that ownership transfer is a very rarely used operation when
compared to regular file usage. I believe that language should make
that more frequent use case more intuitive and idiot-proof at the cost
of making the less frequent use cases more verbose.

--
Maciej Sobczak * www.msobczak.com * www.inspirel.com