I read a paper recently that described a new looping construct. This
is admittedly pretty weird: we've pretty much settled on looping
constructs in imperative languages by now, and with a few exceptions
I don't see much change. You've got your `while` and (increasingly
rarely) your `do while` loop, which moves the test around:

~~~~
                     cond -> true
-----------------------------------------------------------
  while (cond) { body }   ->   body; while (cond) { body }

          cond -> false
-------------------------------------
  while (cond) { body }   ->   ()


                        cond -> true
------------------------------------------------------------------
  do { body } while (cond)   ->   body; do { body } while (cond)

              cond -> false
------------------------------------------
  do { body } while (cond)   ->   body
~~~~

We also have the nice scaffolding provided to us by `for` loops, which
are nice sugar for `while` loops:

~~~~
for (init, iter, cond) { body } => init; do { body; iter } while (cond)
~~~~

and we have flavors of `foreach` loops, which add awareness of some
underlying iterator protocol or collection type, which introduces an
element of binding

~~~~
foreach (x in coll) { body } => coll.iter(); while (coll.has_next()) { x = coll.next(); body }
~~~~
