Booleans & conditionals

Booleans

True is spelled #true or #t. False is spelled #false or #f. When used in a condi­tional expres­sion, every value other than #false counts as true. There are no “falsish” values.

That was easy.

If you need to flip a Boolean from true to false or vice versa, use not.

and and or work in the usual short-circuiting way. That is, they stop when they reach a false or true value, respec­tively. So nothing bad will happen when you run these, because the second condi­tion on each line is never reached:

andmap and ormap will apply a pred­i­cate to every member of a list, so these:

Can be written more compactly:

See loops for other conve­nient forms of and and or.

Condi­tionals

if has one condi­tional expres­sion followed by two result expres­sions—the first is eval­u­ated if the condi­tion is true, other­wise the second is eval­u­ated. If you need multiple expres­sions in a branch, you can put them inside an empty let.

If you only need one branch, use when.  + Or its logical inverse, unless. Like if, when starts with a condi­tional expres­sion. Unlike if, the body of when can contain any number of expres­sions. If the condi­tion is true, the last body expres­sion is returned as the result. If the condi­tion is false, the whole when expres­sion returns <#void>, a special constant used to signal the absence of a result.

cond supports any number of condi­tion branches, and an optional else branch. cond eval­u­ates the condi­tion on the left side of each branch, and stops at the first one that eval­u­ates as true (precisely, the first one that’s not #false). Then it eval­u­ates the right side of the branch. Like when, the right side can have any number of expres­sions, and only the last expres­sion is returned as the result. If no branches match, you get <#void>.

cond offers a couple of tricks that if and when do not.

First, if you omit the right side of a cond branch, the value of the condi­tional will be used as the return value:

Second, you can capture the condi­tional value and use it on the right side of the branch with the => oper­ator. The right side of the branch must be a func­tion that accepts one argu­ment. The return value of the cond is the func­tion applied to the condi­tional value. This is useful when the condi­tional relies on an oper­a­tion that’s expen­sive, or can only be done once.

Case

case creates a condi­tional that compares a value against lists of literal values. At the top is the value to be compared. Like cond, a series of branches follow. If the value is equal? to one of the items in the list on the left, then the right side of the branch is eval­u­ated and returned as the result. An optional else branch catches anything else:

For reasons unclear, the left-hand lists don’t use a ' prefix; they simply behave as if there were one already there.

Match

match is a more general version of case. The basic form is the same: the value to be matched goes at the top, and a series of branches follow. If the value matches the pattern on the left-hand side of a branch, the right-hand side is eval­u­ated and returned as the result.

Unlike case, match supports a wider pattern vocab­u­lary that can match literal values, but also pred­i­cates, lists, pairs, struc­ture types, and other values. More­over, match can also assign elements of the match to internal vari­ables for further processing:

Further