On this page:
boolean?
not
immutable?
4.2.1 Boolean Aliases
true
false
symbol=?
boolean=?
false?
nand
nor
implies
xor

4.2 Booleans

True and false booleans are represented by the values #t and #f, respectively, though operations that depend on a boolean value typically treat anything other than #f as true. The #t value is always eq? to itself, and #f is always eq? to itself.

See Reading Booleans for information on reading booleans and Printing Booleans for information on printing booleans.

See also and, or, andmap, and ormap.

procedure

(boolean? v) → boolean?

  v : any/c
Returns #t if v is #t or #f, #f otherwise.

Examples:
> (boolean? #f)

#t

> (boolean? #t)

#t

> (boolean? 'true)

#f

procedure

(not v) → boolean?

  v : any/c
Returns #t if v is #f, #f otherwise.

Examples:
> (not #f)

#t

> (not #t)

#f

> (not 'we-have-no-bananas)

#f

procedure

(immutable? v) → boolean?

  v : any/c
Returns #t if v is an immutable string, byte string, vector, hash table, or box, #f otherwise.

Note that immutable? is not a general predicate for immutability (despite its name). It works only for a handful of datatypes for which a single predicate—string?, vector?, etc.—recognizes both mutable and immutable variants of the datatype. In particular, immutable? produces #f for a pair, even though pairs are immutable, since pair? implies immutability.

Examples:
> (immutable? 'hello)

#f

> (immutable? "a string")

#t

> (immutable? (box 5))

#f

> (immutable? #(0 1 2 3))

#t

> (immutable? (make-hash))

#f

> (immutable? (make-immutable-hash '([a b])))

#t

> (immutable? #t)

#f

4.2.1 Boolean Aliases

 (require racket/bool) package: base
The bindings documented in this section are provided by the racket/bool and racket libraries, but not racket/base.

value

true : boolean?

An alias for #t.

value

false : boolean?

An alias for #f.

procedure

(symbol=? a b) → boolean?

  a : symbol?
  b : symbol?
Returns (equal? a b) (if a and b are symbols).

procedure

(boolean=? a b) → boolean?

  a : boolean?
  b : boolean?
Returns (equal? a b) (if a and b are booleans).

procedure

(false? v) → boolean?

  v : any/c
Returns (not v).

syntax

(nand expr ...)

Same as (not (and expr ...)).

Examples:
> (nand #f #t)

#t

> (nand #f (error 'ack "we don't get here"))

#t

syntax

(nor expr ...)

Same as (not (or expr ...)).

In the two argument case, returns #t if neither of the arguments is a true value.

Examples:
> (nor #f #t)

#f

> (nor #t (error 'ack "we don't get here"))

#f

syntax

(implies expr1 expr2)

Checks to be sure that the first expression implies the second.

Same as (if expr1 expr2 #t).

Examples:
> (implies #f #t)

#t

> (implies #f #f)

#t

> (implies #t #f)

#f

> (implies #f (error 'ack "we don't get here"))

#t

procedure

(xor b1 b2) → any

  b1 : any/c
  b2 : any/c
Returns the exclusive or of b1 and b2.

If exactly one of b1 and b2 is not #f, then return it. Otherwise, returns #f.

Examples:
> (xor 11 #f)

11

> (xor #f 22)

22

> (xor 11 22)

#f

> (xor #f #f)

#f