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 read ing booleans and Printing Booleans for information on print ing 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.

See also immutable-string? , mutable-string? , etc.

Examples:

> (immutable? 'hello)

#f
> (immutable? "a string")

#t
> (immutable? (box 5))

#f
> (immutable? #(0123))

#t
> (immutable? (make-hash ))

#f
> (immutable? (make-immutable-hash '([ab])))

#t
> (immutable? #t)

#f

4.2.1Boolean Aliases🔗 i

(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=? ab)→boolean?
a:symbol?
b:symbol?

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

procedure
( boolean=? ab)→boolean?
a:boolean?
b:boolean?

Returns (equal? ab) (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 expr1expr2)

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

Same as (if expr1expr2#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 b1b2)→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 #f22)

22
> (xor 1122)

#f
> (xor #f#f)

#f

4.2.2Mutability Predicates🔗 i

(require racket/mutability ) package: base

The bindings documented in this section are provided by the racket/mutability library, not racket/base or racket.

Added in version 8.9.0.3 of package base.

procedure
( mutable-string? v)→boolean?
v:any/c

procedure
( immutable-string? v)→boolean?
v:any/c

procedure
( mutable-bytes? v)→boolean?
v:any/c

procedure
( immutable-bytes? v)→boolean?
v:any/c

procedure
( mutable-vector? v)→boolean?
v:any/c

procedure
( immutable-vector? v)→boolean?
v:any/c

procedure
( mutable-box? v)→boolean?
v:any/c

procedure
( immutable-box? v)→boolean?
v:any/c

procedure
( mutable-hash? v)→boolean?
v:any/c

procedure
( immutable-hash? v)→boolean?
v:any/c

Predicates that combine string? , bytes? , vector? , box? , and hash? with immutable? or its inverse. The predicates are potentially faster than using immutable? and other predicates separately.

top ← prev up next →