procedure Make_File_Gone (Name : in String);

procedure Make_File_Gone (Name : in String);

[tmoran]

What's a good name for a procedure that does an
Ada.Directories.Delete_File if the file exists, and silently returns if
the file is already gone.

Re: procedure Make_File_Gone (Name : in String);

[Oliver Kleinke]

Am Wed, 20 Jul 2011 06:04:18 +0000 (UTC)
schrieb tmoran@acm.org:

> What's a good name for a procedure that does an
> Ada.Directories.Delete_File if the file exists, and silently returns
> if the file is already gone.

Unlink, Remove, Delete, ... Silent_Unlink, ... or maybe Unlink (Silent
=> True), ...

Re: procedure Make_File_Gone (Name : in String);

[Niklas Holsti]

tmoran@acm.org wrote:
> What's a good name for a procedure that does an
> Ada.Directories.Delete_File if the file exists, and silently returns if
> the file is already gone.

Difficult question. In a multi-process system the procedure cannot, of 
course, guarantee that the file does not (again) exist when the 
procedure returns, so "Make_File_Gone" promises too much.

Perhaps Delete_Possibly_Existing_File.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
       .      @       .

Re: procedure Make_File_Gone (Name : in String);

[Martin]

On Jul 20, 7:04 am, tmo...@acm.org wrote:
> What's a good name for a procedure that does an
> Ada.Directories.Delete_File if the file exists, and silently returns if
> the file is already gone.

Delete_File_If_Present?

-- Martin

Re: procedure Make_File_Gone (Name : in String);

[Jeffrey Carter]

On 07/19/2011 11:04 PM, tmoran@acm.org wrote:
> What's a good name for a procedure that does an
> Ada.Directories.Delete_File if the file exists, and silently returns if
> the file is already gone.

Delete.

-- 
Jeff Carter
"He didn't get that nose from playing ping-pong."
Never Give a Sucker an Even Break
110

Re: procedure Make_File_Gone (Name : in String);

[Stephen Leake]

tmoran@acm.org writes:

> What's a good name for a procedure that does an
> Ada.Directories.Delete_File if the file exists, and silently returns if
> the file is already gone.

Delete_File.

I'm assuming you are declaring this in a package that is not
Ada.Directories, so overloading is perfectly appropriate.

The detailed semantics are in the comments, not the name.

-- 
-- Stephe

Re: procedure Make_File_Gone (Name : in String);

[Randy Brukardt]

<tmoran@acm.org> wrote in message news:j05r52$1h8$1@speranza.aioe.org...
> What's a good name for a procedure that does an
> Ada.Directories.Delete_File if the file exists, and silently returns if
> the file is already gone.

I'm of course partial to Purge for this use. :-)

[Background to the uninitiated: I had suggested to Tom and other Janus/Ada 
customers that they consider using Ada.Directories operations rather than 
the implementation-defined ones in Ada.Text_IO.Extensions as those are more 
portable; specifically replacing Ada.Text_IO.Extensions.Purge with 
Ada.Directories.Delete_File. Tom had followed that advice, except that it 
was causing random failures to his application -- which eventually turned 
out to be caused by the different behavior of Purge (do nothing) and 
Delete_File (raise an exception) if the file does not exist.]

                                         Randy.

Re: procedure Make_File_Gone (Name : in String);

[tmoran]

> I'm of course partial to Purge for this use. :-)

Another verb.  Both the phrase Delete_File and the word Purge say "go
do something" and they leave unclear what to do if you can't do the
action. I'd like to concisely make clear the post condition I'm trying
to achieve - in this case, the absence of a file of the given name.
Ideally this should be clear from the procedure name without having
to look in the ARM or depend on a comment of uncertain modernity.

And yes, there could be a race where someone created a new file of that
name immediately afterward, but avoiding such races is part of the
higher level design.

Re: procedure Make_File_Gone (Name : in String);

[Robert A Duff]

tmoran@acm.org writes:

>> I'm of course partial to Purge for this use. :-)
>
> Another verb.  Both the phrase Delete_File and the word Purge say "go
> do something" and they leave unclear what to do if you can't do the
> action. I'd like to concisely make clear the post condition I'm trying
> to achieve - in this case, the absence of a file of the given name.

I think you mean precondition.  The postcondition of the two is
the same -- the file isn't there.

I think distinguishing Delete_File and Delete would be confusing.
How would you remember which is which?

I'd say Delete_File should raise an exception if the file doesn't
exist, and Maybe_Delete_File should silently do nothing in that case.

> Ideally this should be clear from the procedure name without having
> to look in the ARM or depend on a comment of uncertain modernity.
>
> And yes, there could be a race where someone created a new file of that
> name immediately afterward, but avoiding such races is part of the
> higher level design.

Sure, that's true of pretty-much all file operations.

- Bob

Re: procedure Make_File_Gone (Name : in String);

[tmoran]

> The postcondition of the two is the same -- the file isn't there.

  I understand a postcondition to be true just after execution of
something.  The postcondition for an execution of
Ada_Directories.Delete_File is

"(the file isn't there and a Name_Error may or may not have been raised),
or a Use_Error has been raised"

I want a routine where the postcondition is

"the file isn't there, or a Use_Error has been raised"

(In my programming a Use_Error is exceptional, but trying to ensure
that a certain file no longer exists is not all that unusual.)

I'm looking for a good name for such a routine, where "good" means
short and clear to a maintenance programmer scanning the code.  Perhaps
English doesn't have a nice way of making such an imperative->declarative
phrase.

Re: procedure Make_File_Gone (Name : in String);

[Dmitry A. Kazakov]

On Sat, 23 Jul 2011 19:05:02 +0000 (UTC), tmoran@acm.org wrote:

> I'm looking for a good name for such a routine, where "good" means
> short and clear to a maintenance programmer scanning the code.  Perhaps
> English doesn't have a nice way of making such an imperative->declarative
> phrase.

   procedure Delete_File (File : String; Existing : Boolean := True);

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: procedure Make_File_Gone (Name : in String);

[Simon Wright]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

> On Sat, 23 Jul 2011 19:05:02 +0000 (UTC), tmoran@acm.org wrote:
>
>> I'm looking for a good name for such a routine, where "good" means
>> short and clear to a maintenance programmer scanning the code.  Perhaps
>> English doesn't have a nice way of making such an imperative->declarative
>> phrase.
>
>    procedure Delete_File (File : String; Existing : Boolean := True);

   procedure Delete_File (File : String; 
                          Only_If_Existing : Boolean := True);

Re: procedure Make_File_Gone (Name : in String);

[Adam Beneschan]

On Jul 23, 2:08 pm, Simon Wright <si...@pushface.org> wrote:
> "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de> writes:
>
> > On Sat, 23 Jul 2011 19:05:02 +0000 (UTC), tmo...@acm.org wrote:
>
> >> I'm looking for a good name for such a routine, where "good" means
> >> short and clear to a maintenance programmer scanning the code.  Perhaps
> >> English doesn't have a nice way of making such an imperative->declarative
> >> phrase.
>
> >    procedure Delete_File (File : String; Existing : Boolean := True);
>
>    procedure Delete_File (File : String;
>                           Only_If_Existing : Boolean := True);

Or you could go the other way:

   procedure Delete_File (File : String;
                          OK_If_File_Doesnt_Exist : Boolean := False);

The parameter name is clunky.  Still, I think I'd slightly prefer
something along those lines because I tried to read a call that looks
like this:

   Delete_File (F, Only_If_Existing => False);

I'd be scratching my head trying to figure out what it meant.  It's
probably better to use names that mean nothing:

   Delete_File (F, Glarfspoogl => False);

than to use names that look like they're intended to convey meaning
but actually are just confusing.  The former at least will force
readers to go back and look at the documentation.  (I'm only half-
serious here.  I don't recommending using ridiculous names like
Glarfspoogl.)

                              -- Adam

Re: procedure Make_File_Gone (Name : in String);

[Simon Wright]

Adam Beneschan <adam@irvine.com> writes:

> On Jul 23, 2:08 pm, Simon Wright <si...@pushface.org> wrote:
>> "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de> writes:
>>
>> > On Sat, 23 Jul 2011 19:05:02 +0000 (UTC), tmo...@acm.org wrote:
>>
>> >> I'm looking for a good name for such a routine, where "good" means
>> >> short and clear to a maintenance programmer scanning the code.  Perhaps
>> >> English doesn't have a nice way of making such an imperative->declarative
>> >> phrase.
>>
>> >    procedure Delete_File (File : String; Existing : Boolean := True);
>>
>>    procedure Delete_File (File : String;
>>                           Only_If_Existing : Boolean := True);
>
> Or you could go the other way:
>
>    procedure Delete_File (File : String;
>                           OK_If_File_Doesnt_Exist : Boolean := False);
>
> The parameter name is clunky.  Still, I think I'd slightly prefer
> something along those lines because I tried to read a call that looks
> like this:
>
>    Delete_File (F, Only_If_Existing => False);
>
> I'd be scratching my head trying to figure out what it meant.  It's
> probably better to use names that mean nothing:
>
>    Delete_File (F, Glarfspoogl => False);
>
> than to use names that look like they're intended to convey meaning
> but actually are just confusing.  The former at least will force
> readers to go back and look at the documentation.  (I'm only half-
> serious here.  I don't recommending using ridiculous names like
> Glarfspoogl.)

I take your point.

  With_Exception_If_Not_Found : Boolean := True

(we could argue this one for a long time if we had nothing better to
do!)

Re: procedure Make_File_Gone (Name : in String);

[marius63]

On Jul 20, 7:04 am, tmo...@acm.org wrote:
> What's a good name for a procedure that does an
> Ada.Directories.Delete_File if the file exists, and silently returns if
> the file is already gone.

I have seen "ensure" used around lately. So, Ensure_Deleted.

OTOH, Ada parlance has "unchecked". So, Unchecked_Delete_File.

Re: procedure Make_File_Gone (Name : in String);

[tmoran]

> I have seen "ensure" used around lately. So, Ensure_Deleted.

I like it.  Thanks.