I Like Infinite Loops

I know many different programming languages, most having looping constructs, and, without exception,
like when the infinite loop has a special form, not necessarily by fiat, but merely by happenstance.
It's nice if a language has a generalized looping construct, which can be merely left bare for this.

Firstly, Common Lisp has several looping constructs, and those which iterate over a list can be made
to loop indefinitely by merely making the list circular, but I prefer the LOOP macro over such forms
for any infinite loop; this variant of LOOP looks identical to the primary variant, but accepts only
normal Common Lisp code and isn't anything but a BLOCK named NIL that executes a TAGBODY repeatedly:

(LOOP ...)

Any Common Lisp code can be placed in such an infinite loop, so long as bare symbols confusable with
LOOP keywords in any way aren't used; when in doubt, a PROGN or some other such form should be used.

Secondly, Ada also has several looping constructs, but all sans few modify this bare loop construct:

loop
   ...
end loop;

There are variant forms that modify a basic loop by adding conditional or range code before the loop
itself, and there are variant ways to exit any loop.  The simplicity of this looping construct is in
line with the rest of Ada, for which most decisions have been made carefully to retain its elegance.

Thirdly, APL is a language which lacks any dedicated loop construct.  In an ideal APL function there
are no explicit loops.  Accordingly, the only way to have such unbounded computation is by recursion
or through arbitrary flow control with the right arrow, an equivalent to a line-based goto operator.

Lastly, each machine code I've used features jump instructions as the primary means of flow control,
with call and return instructions for subprograms also available, but call and return aren't usually
suited to implementing loops.  That most pure infinite loop is an instruction which jumps to itself.

I've yet to use the Idris language, but I'm to understand it distinguishes heavily between functions
which must terminate and those which may terminate, but know little beyond this.  The idea of taking
a common control flow pattern and enshrining it in stone with a special mechanism and perhaps even a
name is almost certainly the future of programming.  Almost all programs use a mere fistful of such,
and the more which is proven correct and heavily-scrutinized, the more which will be easily correct.
.