boot.janet on line 522, column 1
(loop head & body)
A general purpose loop macro. This macro is similar to the Common
Lisp loop macro, although intentionally much smaller in scope. The
head of the loop should be a tuple that contains a sequence of either
bindings or conditionals. A binding is a sequence of three values
that define something to loop over. They are formatted like:
binding :verb object/expression
Where `binding` is a binding as passed to def, `:verb` is one of a
set of keywords, and `object` is any expression. The available verbs
* :iterate -- repeatedly evaluate and bind to the expression while it
* :range -- loop over a range. The object should be a two-element
tuple with a start and end value, and an optional positive step.
The range is half open, [start, end).
* :range-to -- same as :range, but the range is inclusive [start,
* :down -- loop over a range, stepping downwards. The object should
be a two-element tuple with a start and (exclusive) end value, and
an optional (positive!) step size.
* :down-to -- same as :down, but the range is inclusive [start, end].
* :keys -- iterate over the keys in a data structure.
* :pairs -- iterate over the key-value pairs as tuples in a data
* :in -- iterate over the values in a data structure or fiber.
`loop` also accepts conditionals to refine the looping further.
Conditionals are of the form:
where `:modifier` is one of a set of keywords, and `argument` is
keyword-dependent. `:modifier` can be one of:
* `:while expression` - breaks from the loop if `expression` is
* `:until expression` - breaks from the loop if `expression` is
* `:let bindings` - defines bindings inside the loop as passed to the
* `:before form` - evaluates a form for a side effect before the next
* `:after form` - same as `:before`, but the side effect happens
after the next inner loop.
* `:repeat n` - repeats the next inner loop `n` times.
* `:when condition` - only evaluates the loop body when condition is
The `loop` macro always evaluates to nil.