"while" with condition at end?

"while" with condition at end?

[Markus Mottl]

Hello!

I have just found out that there is no loop construct that checks the
termination condition at the end of the block. Is there some special
reason to this?

I'd like to write something like e.g.

  do
    ();
    ...;
  while (some_condition);

The only work-around is to either double the code and execute it once
before a "normal" while-loop (not elegant). The other option is to put
the block into a unit-function (a bit less efficient) and use it once
before and than in the loop (also not very elegant).
A construct of this kind would probably make the imperative features
more complete.

Best regards,
Markus Mottl

-- 
Markus Mottl, mottl@miss.wu-wien.ac.at, http://miss.wu-wien.ac.at/~mottl

Re: "while" with condition at end?

[Pierre Weis]

> Hello!
> 
> I have just found out that there is no loop construct that checks the
> termination condition at the end of the block. Is there some special
> reason to this?
> 
> I'd like to write something like e.g.
> 
>   do
>     ();
>     ...;
>   while (some_condition);
> 
> The only work-around is to either double the code and execute it once
> before a "normal" while-loop (not elegant). The other option is to put
> the block into a unit-function (a bit less efficient) and use it once
> before and than in the loop (also not very elegant).
> A construct of this kind would probably make the imperative features
> more complete.
> 
> Best regards,
> Markus Mottl
> 
> -- 
> Markus Mottl, mottl@miss.wu-wien.ac.at, http://miss.wu-wien.ac.at/~mottl

The introduction of a ``do ... while ...'' construct would introduce
ambiguities in the Caml grammar. It would be preferable to
introduce a new keyword for the new kind of loop, for instance

repeat
 actions
until
 cond
done

Or may be better, just change the keyword ``while'' into the keyword
``until'' to reflect the symetry between the two syntactic constructs
for imperative loops:

until cond
do
 actions
done

For the time being, there is a simple workaround (admittedly not as
nice as desirable): merge the ``actions'' and the ``condition'' into a
single sequence within a while loop with an empty body. In effect,

until cond
do 
 actions
done

is equivalent to

while actions; cond do () done

Alternatively, you may define your loop via a recursive function:

let rec repeat_loop () =
 actions;
 if not cond then repeat_loop () in
repeat_loop ()

Best regards,

Pierre Weis

INRIA, Projet Cristal, Pierre.Weis@inria.fr, http://cristal.inria.fr/~weis/