► |  | Reference: Racket

1 | Language Model
2 | Syntactic Forms
3 | Datatypes
4 | Structures
5 | Classes and Objects
6 | Units
7 | Contracts
8 | Pattern Matching
9 | Control Flow
10 | Concurrency
11 | Macros
12 | Input and Output
13 | Reflection and Security
14 | Operating System
15 | Memory Management
16 | Unsafe Operations
17 | Running Racket
| Bibliography
| Index

▼ | 3 | Datatypes

3.1 | Booleans and Equality
3.2 | Numbers
3.3 | Strings
3.4 | Byte Strings
3.5 | Characters
3.6 | Symbols
3.7 | Regular Expressions
3.8 | Keywords
3.9 | Pairs and Lists
3.10 | Mutable Pairs and Lists
3.11 | Vectors
3.12 | Boxes
3.13 | Hash Tables
3.14 | Sequences
3.15 | Dictionaries
3.16 | Sets
3.17 | Procedures
3.18 | Void and Undefined

► | 3.1 | Booleans and Equality

3.1.1 | Boolean Synonyms

On this page:

boolean?
not
equal?
eqv?
eq?
equal?/ recur
immutable?
prop: equal+ hash
3.1.1`` Boolean Synonyms
true
false
symbol=?
boolean=?
false?

top ← prev up next →

#### 3.1`` Booleans and Equality

True and false booleans are represented by the values #t and #f, respectively, though operations that depend a boolean value typically treat anything other than #f as true.

See also: and, or, andmap, ormap.

( 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

( 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

( equal? v1 v2) → boolean?
v1 : any/c
v2 : any/c

Two values are equal? if and only if they are eqv?, unless otherwise specified for a particular datatype.

Datatypes with further specification of equal? include strings, byte strings, numbers, pairs, mutable pairs, vectors, boxes, hash tables, and inspectable structures. In the last five cases, equality is recursively defined; if both v1 and v2 contain reference cycles, they are equal when the infinite unfoldings of the values would be equal. See also prop:equal+hash and prop:proxy-of.

Examples:
> ( equal? 'yes 'yes)
#t
> ( equal? 'yes 'no)
#f
> ( equal? ( expt 2 100) ( expt 2 100))
#t
> ( equal? 2 2.0)
#f
> ( equal? ( make-string 3 #\z) ( make-string 3 #\z))
#t

( eqv? v1 v2) → boolean?
v1 : any/c
v2 : any/c

Two values are eqv? if and only if they are eq?, unless otherwise specified for a particular datatype.

The number and character datatypes are the only ones for which eqv? differs from eq?.

Examples:
> ( eqv? 'yes 'yes)
#t
> ( eqv? 'yes 'no)
#f
> ( eqv? ( expt 2 100) ( expt 2 100))
#t
> ( eqv? 2 2.0)
#f
> ( eqv? ( integer->char 955) ( integer->char 955))
#t
> ( eqv? ( make-string 3 #\z) ( make-string 3 #\z))
#f

( eq? v1 v2) → boolean?
v1 : any/c
v2 : any/c

Return #t if v1 and v2 refer to the same object, #f otherwise. See also Object Identity and Comparisons.

Examples:
> ( eq? 'yes 'yes)
#t
> ( eq? 'yes 'no)
#f
> ( let ([v ( mcons 1 2)]) ( eq? v v))
#t
> ( eq? ( mcons 1 2) ( mcons 1 2))
#f
> ( eq? ( make-string 3 #\z) ( make-string 3 #\z))
#f

( equal?/recur v1 v2 recur-proc) → boolean?
v1 : any/c
v2 : any/c
recur-proc : ( any/c any/c -> any/c )

Like equal?, but using recur-proc for recursive comparisons (which means that reference cycles are not handled automatically). Non-#f results from recur-proc are converted to #t before being returned by equal?/recur.

Examples:
> ( equal?/recur 1 1 ( lambda (a b) #f))
#t
> ( equal?/recur '(1) '(1) ( lambda (a b) #f))
#f

> ( equal?/recur '#(1 1 1) '#(1 1.2 3/4)
( lambda (a b) ( <= ( abs ( - a b)) 0.25)))

#t

( immutable? v) → boolean?
v : any/c

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

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

prop:equal+hash : struct-type-property?

A structure type property (see Structure Type Properties) that supplies an equality predicate and hashing functions for a structure type. The property value must be a list of three procedures:

- equal-proc : ( -> any/c any/c ( -> any/c any/c boolean? ) any/c ) – tests whether the first two arguments are equal, where both values are instances of the structure type to which the property is associated (or a subtype of the structure type).

  The third argument is an equal? predicate to use for recursive equality checks; use the given predicate instead of equal? to ensure that data cycles are handled properly and to work with equal?/recur (but beware that an arbitrary function can be provided to equal?/recur for recursive checks, which means that arguments provided to the predicate might be exposed to arbitrary code).

  The equal-proc is called for a pair of structures only when they are not eq?, and only when they both have a prop:equal+hash value inherited from the same structure type. With this strategy, the order in which equal? receives two structures does not matter. It also means that, by default, a structure sub-type inherits the equality predicate of its parent, if any.

- hash-proc : ( -> any/c ( -> any/c exact-integer? ) exact-integer? ) – computes a hash code for the given structure, like equal-hash-code. The first argument is an instance of the structure type (or one of its subtypes) to which the property is associated.

  The second argument is a equal-hash-code-like procedure to use for recursive hash-code computation; use the given procedure instead of equal-hash-code to ensure that data cycles are handled properly.

- hash2-proc : ( -> any/c ( -> any/c exact-integer? ) exact-integer? ) – computes a secondary hash code for the given structure. This procedure is like hash-proc, but analogous to equal-secondary-hash-code.

Take care to ensure that hash-proc and hash2-proc are consistent with equal-proc. Specifically, hash-proc and hash2-proc should produce the same value for any two structures for which equal-proc produces a true value.

When a structure type has no prop:equal+hash property, then transparent structures (i.e., structures with an inspector that is controlled by the current inspector) are equal? when they are instances of the same structure type (not counting sub-types), and when they have equal? field values. For transparent structures, equal-hash-code and equal-secondary-hash-code derive hash code using the field values. For opaque structure types, equal? is the same as eq?, and equal-hash-code and equal-secondary-hash-code results are based only on eq-hash-code. If a structure has a prop:proxy-of property, then the prop:proxy-of property takes precedence over prop:equal+hash if the property value’s procedure returns a non-#f value when applied to the structure.

Examples:

> ( define (farm=? farm1 farm2 recursive-equal?)
( and ( = (farm-apples farm1)
(farm-apples farm2))
( = (farm-oranges farm1)
(farm-oranges farm2))
( = (farm-sheep farm1)
(farm-sheep farm2))))

> ( define (farm-hash-1 farm recursive-equal-hash)
( + ( * 10000 (farm-apples farm))
( * 100 (farm-oranges farm))
( * 1 (farm-sheep farm))))

> ( define (farm-hash-2 farm recursive-equal-hash)
( + ( * 10000 (farm-sheep farm))
( * 100 (farm-apples farm))
( * 1 (farm-oranges farm))))

> ( define-struct farm (apples oranges sheep)
#:property prop:equal+hash
( list farm=? farm-hash-1 farm-hash-2))

> ( define east (make-farm 5 2 20))
> ( define west (make-farm 18 6 14))
> ( define north (make-farm 5 20 20))
> ( define south (make-farm 18 6 14))
> ( equal? east west)
#f
> ( equal? east north)
#f
> ( equal? west south)
#t

##### 3.1.1`` Boolean Synonyms

( require racket/bool )

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

true : boolean?

A synonym for #t.

false : boolean?

A synonym for #f.

( symbol=? a b) → boolean?
a : symbol?
b : symbol?

Returns ( equal? a b).

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

Returns ( equal? a b).

( false? v) → boolean?
v : any/c

Returns ( not v).
top ← prev up next →