The following syntax can be obtained with
(use-modules (srfi srfi-2))
(use-modules (ice-9 and-let-star))
A combination of
Each clause is evaluated in turn, and if
#f is obtained
then evaluation stops and
#f is returned. If all are
#f then body is evaluated and the last form gives the
return value, or if body is empty then the result is
Each clause should be one of the following,
Evaluate expr, check for
#f, and bind it to symbol.
let*, that binding is available to subsequent clauses.
Evaluate expr and check for
Get the value bound to symbol and check for
(expr) has an “extra” pair of parentheses, for
((eq? x y)). One way to remember this is to imagine
(symbol expr) is omitted.
and-let* is good for calculations where a
#f value means
termination, but where a non-
#f value is going to be needed in
The following illustrates this, it returns text between brackets
‘[...]’ in a string, or
#f if there are no such brackets
(define (extract-brackets str) (and-let* ((start (string-index str #\[)) (end (string-index str #\] start))) (substring str (1+ start) end)))
The following shows plain variables and expressions tested too.
diagnostic-levels is taken to be an alist associating a
diagnostic type with a level.
str is printed only if the type
is known and its level is high enough.
(define (show-diagnostic type str) (and-let* (want-diagnostics (level (assq-ref diagnostic-levels type)) ((>= level current-diagnostic-level))) (display str)))
The advantage of
and-let* is that an extended sequence of
expressions and tests doesn’t require lots of nesting as would arise
let*, or from