Racket programmers prefer to write programs with as few side-effects as possible, since purely functional code is more easily tested and composed into larger programs. Interaction with the external environment, however, requires sequencing, such as when writing to a display, opening a graphical window, or manipulating a file on disk.
4.8.1 Effects Before: begin
A begin expression sequences expressions:
(begin expr ...+)
The exprs are evaluated in order, and the result of all but the last expr is ignored. The result from the last expr is the result of the begin form, and it is in tail position with respect to the begin form.
The begin form is special at the top level, at module level, or as a body after only internal definitions. In those positions, instead of forming an expression, the content of begin is spliced into the surrounding context.
This splicing behavior is mainly useful for macros, as we discuss later in Macros.
4.8.2 Effects After: begin0
(begin0 expr ...+)
The difference is that begin0 returns the result of the first expr, instead of the result of the last expr. The begin0 form is useful for implementing side-effects that happen after a computation, especially in the case where the computation produces an unknown number of results.
(define (log-times thunk) (printf "Start: ~s\n" (current-inexact-milliseconds)) (begin0 (thunk) (printf "End..: ~s\n" (current-inexact-milliseconds))))
> (log-times (lambda () (sleep 0.1) 0))
> (log-times (lambda () (values 1 2)))
(when test-expr then-body ...+)
If test-expr produces a true value, then all of the then-bodys are evaluated. The result of the last then-body is the result of the when form. Otherwise, no then-bodys are evaluated and the result is #<void>.
The unless form is similar:
(unless test-expr then-body ...+)
The difference is that the test-expr result is inverted: the then-bodys are evaluated only if the test-expr result is #f.