Loops

The basic for loop has two manda­tory ingre­di­ents: an iter­ator binding, consisting of an iden­ti­fier and a sequence of values, and a body of one or more expres­sions. On each pass of the loop, the next value from the sequence is assigned to the iden­ti­fier, and the body of the loop is eval­u­ated. The loop exits when the iter­ator runs out of values:

A loop can have more than one iter­ator binding. In that case, the iter­a­tors are assigned in parallel, and the loop exits when any iter­ator runs out of values:

A for loop discards the results of eval­u­ating the body. Thus, it’s mostly useful for func­tions that rely on side effects, like println. But as an expres­sion, it eval­u­ates to void:

By contrast, the for/list and for/vector vari­ants don’t discard the results of eval­u­ating the body. Instead, they gather these values into a new list or vector:

for/hash follows the same idea, but expects the body to return two values on each pass, repre­senting a key–value pair:

for/fold is the most flex­ible of these vari­ants. It allows any number of accu­mu­la­tors, of any type, and expects the body to return the same number of values on each pass:

See the Racket docu­men­ta­tion for details on other conve­nience vari­ants like for/sum, for/product, for/and, for/or, and for/first.

Sequences

Any value that counts as a sequence—including posi­tive inte­gers, lists, and strings—can be used directly as a source of iter­a­tion values in any loop:

Note that a string used as a sequence becomes a series of raw char­ac­ters, not substrings. For that, use a list of one-char­acter strings as the sequence:

Though a sequence can be used directly as the right side of an iter­ator binding, the best perfor­mance comes from using sequence construc­tors like in-range, in-list, and in-string:  + Using a constructor tips off the compiler about what kind of sequence will be in the iter­ator posi­tion, so access to the sequence can be opti­mized at compile time.

Special­ized construc­tors handle other sequence types, like in-hash, in-port, and in-directory.

The in-naturals constructor creates an unending stream of inte­gers. Use this if you need an infi­nite loop:

Guards & breaks

A guard expres­sion limits the eval­u­a­tion of the body based on a condi­tion. Possi­bil­i­ties include #:when or its inverse, #:unless:

A break expres­sion can be used to exit the loop early based on a condi­tion. Possi­bil­i­ties include #:break, which exits the loop imme­di­ately, and #:final, which allows one more eval­u­a­tion of the body before exiting:

Parallel vs. nested

By default, a loop with multiple iter­a­tors assigns them in parallel. To assign iter­a­tors in a nested way, use the for* variant of any loop form (so the nested version of for/list is called for*/list):

Loops as an alter­na­tive to map & filter

map and filter are the idiomatic func­tions for performing oper­a­tions on lists. Still, it can some­times be more read­able to put these oper­a­tions in terms of for/list. For instance, these two expres­sions make the same list:

Further