Racket

DSSL: Data Structures Student Language🔗ℹ

Jesse A. Tov <jesse@eecs.northwestern.edu>

package: dssl

The DSSL language is substantially similar to Advanced Student Language. In particular, it provides the same functions and values (except for hash tables).

In addition to the special forms documented below, DSSL includes for (and friends).

program

def-or-expr ...

def-or-expr

definition

expr

test-case

definition

(define (name variable ...) expr)

(define name expr)

(define-struct name (name ...))

expr

(expr expr ...)

(begin expr expr ...)

(begin0 expr expr ...)

(lambda (variable ...) expr ...)

(λ (variable ...) expr ...)

(local [definition ...] expr ...)

(let ([name expr] ...) expr ...)

(let* ([name expr] ...) expr ...)

(recur name ([name expr] ...) expr ...)

(letrec ([name expr] ...) expr ...)

(shared ([name expr] ...) expr ...)

(set! name expr)

(cond [expr expr ...] ... [expr expr ...])

(cond [expr expr ...] ... [else expr ...])

(case expr [(choice choice ...) expr ...] ...

[(choice choice ...) expr ...])

(case expr [(choice choice ...) expr ...] ...

[else expr ...])

(match expr [pattern expr ...] ...)

(if expr expr expr)

(when expr expr ...)

(unless expr expr ...)

(and expr expr expr ...)

(or expr expr expr ...)

(while expr expr ...)

(until expr expr ...)

for-loop

(time expr ...)

(delay expr)

name

’quoted

‘quasiquoted

’()

number

boolean

string

character

choice

name

number

pattern

name

number

true

false

string

character

’quoted

‘quasiquoted-pattern

(cons pattern pattern)

(list pattern ...)

(list* pattern ...)

(struct id (pattern ...))

(vector pattern ...)

(box pattern)

quasiquoted-pattern

name

number

string

character

(quasiquoted-pattern ...)

’quasiquoted-pattern

‘quasiquoted-pattern

,pattern

,@pattern

test-case

(check-expect expr expr)

(check-error expr expr ...)

(check-within expr expr expr)

(check-random expr expr)

(check-satisfied expr expr)

(check-member-of expr expr ...)

(check-range expr expr expr)

A name or a variable is a sequence of characters not including a space or one of the following:

" , ' ` ( ) [ ] { } | ; #

A number is a number such as 123, 3/2, or 5.5.

A boolean is one of: #true or #false. Alternative spellings for the #true constant are #t, true, and #T. Similarly, #f, false, or #F are also recognized as #false.

A symbol is a quote character followed by a name. A symbol is a value, just like 42, '(), or #false.

A string is a sequence of characters enclosed by a pair of ". Unlike symbols, strings may be split into characters and manipulated by a variety of functions. For example, "abcdef", "This is a string", and "This is a string with \" inside" are all strings.

A character begins with #\ and has the name of the character. For example, #\a, #\b, and #\space are characters.

In function calls, the function appearing immediately after the open parenthesis can be any functions defined with define or define-struct, or any one of the pre-defined functions.

1 Pre-defined Variables🔗ℹ

value
empty : empty?

The empty list.

value
true : boolean?

The #true value.

value
false : boolean?

The #false value.

2 Syntax for DSSL🔗ℹ

2.1 Definition Forms🔗ℹ

syntax
(define (name variable ...) expression ...)

Defines a function named name. The expressions are the body of the function. When the function is called, the values of the arguments are inserted into the body in place of the variables. The function returns the value of the last expression in the sequence.

The function name’s cannot be the same as that of another function or variable.

syntax
(define name expression)

Defines a variable called name with the the value of expression. The variable’s name cannot be the same as that of another function or variable, and name itself must not appear in expression.

2.2 Expression Forms🔗ℹ

syntax
(expression expression ...)

Calls the function that results from evaluating the first expression. The value of the call is the value of function’s body when every instance of name’s variables are replaced by the values of the corresponding expressions.

The function being called must come from either a definition appearing before the function call, or from a lambda expression. The number of argument expressions must be the same as the number of arguments expected by the function.

syntax
(begin expression expression ...)

Evaluates the expressions in order from left to right. The value of the begin expression is the value of the last expression.

syntax
(begin0 expression expression ...)

Evaluates the expressions in order from left to right. The value of the begin expression is the value of the first expression.

syntax
(set! variable expression)

Evaluates expression, and then mutates the variable to have expression’s value. The variable must be defined by define, letrec, let*, or let.

syntax
(lambda (variable ...) expression ...)

Creates a function that takes as many arguments as given variables, and whose body is a sequence of expressions. The result of the function is the result of the last expression.

syntax
(λ (variable ...) expression ...)

The Greek letter λ is a synonym for lambda.

syntax
(case expression [(choice ...) expression ...]
...
[(choice ...) expression ...])

A case form contains one or more clauses. Each clause contains a choices (in parentheses)—either numbers or names—and an answer expression. The initial expression is evaluated, and its value is compared to the choices in each clause, where the lines are considered in order. The first line that contains a matching choice provides an answer expression whose value is the result of the whole case expression. Numbers match with the numbers in the choices, and symbols match with the names. If none of the lines contains a matching choice, it is an error.

syntax
(case expression [(choice ...) expression ...]
...
[else expression ...])

This form of case is similar to the prior one, except that the final else clause is taken if no clause contains a choice matching the value of the initial expression.

syntax
(match expression [pattern expression ...] ...)

A match form contains one or more clauses that are surrounded by square brackets. Each clause contains a pattern—a description of a value—and an answer expression. The initial expression is evaluated, and its value is matched against the pattern in each clause, where the clauses are considered in order. The first clause that contains a matching pattern provides an answer expression whose value is the result of the whole match expression. This expression may reference identifiers defined in the matching pattern. If none of the clauses contains a matching pattern, it is an error.

syntax
(when test-expression body-expression ...)

If test-expression evaluates to true, the body-expressions are evaluated in order, an the result is the result of the last body-expression. Otherwise the result is (void) and the body-expression is not evaluated. If the result of evaluating the test-expression is neither true nor false, it is an error.

syntax
(unless test-expression body-expression ...)

Like when, but the body-expressions are evaluated when the test-expression produces false instead of true.

syntax
(delay expression)

Produces a “promise” to evaluate expression. The expression is not evaluated until the promise is forced with force; when the promise is forced, the result is recorded, so that any further force of the promise immediately produces the remembered value.

syntax
(local [definition ...] expression)

Groups related definitions for use in expression. Each definition can be either a define or a define-struct.

When evaluating local, each definition is evaluated in order, and finally the body expression is evaluated. Only the expressions within the local (including the right-hand-sides of the definitions and the expression) may refer to the names defined by the definitions. If a name defined in the local is the same as a top-level binding, the inner one “shadows” the outer one. That is, inside the local, any references to that name refer to the inner one.

syntax
(letrec ([name expr-for-let] ...) expression)

Like local, but with a simpler syntax. Each name defines a variable (or a function) with the value of the corresponding expr-for-let. If expr-for-let is a lambda, letrec defines a function, otherwise it defines a variable.

syntax
(let* ([name expr-for-let] ...) expression)

Like letrec, but each name can only be used in expression, and in expr-for-lets occuring after that name.

syntax
(let ([name expr-for-let] ...) expression)

Like letrec, but the defined names can be used only in the last expression, not the expr-for-lets next to the names.

syntax
(time expression)

Measures the time taken to evaluate expression. After evaluating expression, time prints out the time taken by the evaluation (including real time, time taken by the CPU, and the time spent collecting free memory). The value of time is the same as that of expression.

syntax
(shared ([name expr-for-shared] ...) expression)

Like letrec, but when an expression next to an id is a cons, list, vector, quasiquoted expression, or make-struct-name from a define-struct, the expression can refer directly to any name, not just names defined earlier. Thus, shared can be used to create cyclic data structures.

syntax
(recur loop-name ([name expr-for-recur] ...) expression)

A short-hand syntax for recursive loops. The first name corresponds to the name of the recursive function. The names in the parenthesis are the function’s arguments, and each corresponding expression is a value supplied for that argument in an initial starting call of the function. The last expression is the body of the function.

More precisely, the following recur:·

(recur func-name ([arg-name arg-expression] ...)
body-expression)

is equivalent to:

(local [(define (func-name arg-name ...) body-expression)]
(func-name arg-expression ...))

syntax
(while test-expression body-expression ...)

If test-expression evaluates to true, the body-expressions are evaluated in order, and then the loop starts over by testing test-expression again. When test-expression is false, the loop terminates and returns (void). If the result of evaluating the test-expression is neither true nor false, it is an error.

syntax
(until test-expression body-expression ...)

Like while, except the loop continutes so long as test-expression evalutes to false.

syntax
(define-struct structure-name (field-name ...))

Defines a new structure called structure-name. The structure’s fields are named by the field-names. After the define-struct, the following new functions are available:

make-structure-name : takes a number of arguments equal to the number of fields in the structure, and creates a new instance of that structure.
structure-name-field-name : takes an instance of the structure and returns the value in the field named by field-name.
structure-name? : takes any value, and returns #true if the value is an instance of the structure.

The name of the new functions introduced by define-struct must not be the same as that of other functions or variables, otherwise define-struct reports an error.

In DSSL, define-struct introduces one additional function:

set-structure-name-field-name! : takes an instance of the structure and a value, and mutates the instance’s field to the given value.

syntax
(cond [question-expression answer-expression ...] ...)
(cond [question-expression answer-expression ...]
...
[else answer-expression ...])

Chooses a clause based on some condition. cond finds the first question-expression that evaluates to #true, then evaluates the corresponding answer-expression.

If none of the question-expressions evaluates to #true, cond’s value is the answer-expression of the else clause. If there is no else, cond reports an error. If the result of a question-expression is neither #true nor #false, cond also reports an error.

else cannot be used outside of cond.

syntax
(if test-expression then-expression else-expression)

When the value of the test-expression is #true, if evaluates the then-expression. When the test is #false, if evaluates the else-expression.

If the test-expression is neither #true nor #false, if reports an error.

syntax
(and expression expression expression ...)

Evaluates to #true if all the expressions are #true. If any expression is #false, the and expression evaluates to #false (and the expressions to the right of that expression are not evaluated.)

If any of the expressions evaluate to a value other than #true or #false, and reports an error.

syntax
(or expression expression expression ...)

Evaluates to #true as soon as one of the expressions is #true (and the expressions to the right of that expression are not evaluated.) If all of the expressions are #false, the or expression evaluates to #false.

If any of the expressions evaluate to a value other than #true or #false, or reports an error.

syntax
(check-expect expression expected-expression)

Checks that the first expression evaluates to the same value as the expected-expression.

(check-expect (fahrenheit->celsius 212) 100)
(check-expect (fahrenheit->celsius -40) -40)

(define (fahrenheit->celsius f)
(* 5/9 (- f 32)))

A check-expect expression must be placed at the top-level of a student program. Also it may show up anywhere in the program, including ahead of the tested function definition. By placing check-expects there, a programmer conveys to a future reader the intention behind the program with working examples, thus making it often superfluous to read the function definition proper.

It is an error for expr or expected-expr to produce an inexact number or a function value. As for inexact numbers, it is morally wrong to compare them for plain equality. Instead one tests whether they are both within a small interval; see check-within. As for functions (see Intermediate and up), it is provably impossible to compare functions.

syntax
(check-random expression expected-expression)

Checks that the first expression evaluates to the same value as the expected-expression.

The form supplies the same random-number generator to both parts. If both parts request random numbers from the same interval in the same order, they receive the same random numbers.

Here is a simple example of where check-random is useful:

(define WIDTH 100)
(define HEIGHT (* 2 WIDTH))

(define-struct player (name x y))
; A Player is (make-player String Nat Nat)

; String -> Player

(check-random (create-randomly-placed-player "David Van Horn")
(make-player "David Van Horn" (random WIDTH) (random HEIGHT)))

(define (create-randomly-placed-player name)
(make-player name (random WIDTH) (random HEIGHT)))

Note how random is called on the same numbers in the same order in both parts of check-random. If the two parts call random for different intervals, they are likely to fail:

; String -> Player

(check-random (create-randomly-placed-player "David Van Horn")
              (make-player "David Van Horn" (random WIDTH) (random HEIGHT)))

(define (create-randomly-placed-player name)
  (local ((define h (random HEIGHT))
          (define w (random WIDTH)))
    (make-player name w h)))

It is an error for expr or expected-expr to produce a function value or an inexact number; see note on check-expect for details.

syntax
(check-satisfied expression predicate)

Checks that the first expression satisfies the named predicate (function of one argument). Recall that “satisfies” means “the function produces a value other than false.”

Here are simple examples for check-satisfied:

> (check-satisfied 1 odd?)
The test passed!

> (check-satisfied 1 even?)
Ran 1 test.
0 tests passed.
Check failures:
                     ┌───┐
        Actual value │ 1 │ does not satisfy even?.
                     └───┘
at line 3, column 0

In general check-satisfied empowers program designers to use defined functions to formulate test suites:

; [cons Number [List-of Number]] -> Boolean
; a function for testing htdp-sort

(check-expect (sorted? (list 1 2 3)) #true)
(check-expect (sorted? (list 2 1 3)) #false)

(define (sorted? l)
  (cond
    [(empty? (rest l)) #true]
    [else (and (<= (first l) (second l)) (sorted? (rest l)))]))

; [List-of Number] -> [List-of Number]
; create a sorted version of the given list of numbers

(check-satisfied (htdp-sort (list 1 2 0 3)) sorted?)

(define (htdp-sort l)
  (cond
    [(empty? l) l]
    [else (insert (first l) (htdp-sort (rest l)))]))

; Number [List-of Number] -> [List-of Number]
; insert x into l at proper place
; assume l is arranged in ascending order
; the result is sorted in the same way
(define (insert x l)
  (cond
    [(empty? l) (list x)]
    [else (if (<= x (first l)) (cons x l) (cons (first l) (insert x (rest l))))]))

And yes, the results of htdp-sort satisfy the sorted? predicate:

> (check-satisfied (htdp-sort (list 1 2 0 3)) sorted?)
The test passed!

syntax
(check-within expression expected-expression delta)

Checks whether the value of the expression expression is structurally equal to the value produced by the expected-expression expression; every number in the first expression must be within delta of the corresponding number in the second expression.

(define-struct roots (x sqrt))
; RT is [List-of (make-roots Number Number)]

(define (roots-table xs)
(map (lambda (a) (make-roots a (sqrt a))) xs))

Due to the presence of inexact numbers in nested data, check-within is the correct choice for testing, and the test succeeds if delta is reasonably large:

Example:

> (check-within (roots-table (list 1.0 2.0 3.0))
                (list
                  (make-roots 1.0 1.0)
                  (make-roots 2  1.414)
                  (make-roots 3  1.713))
                0.1)
The test passed!

In contrast, when delta is small, the test fails:

Example:

> (check-within (roots-table (list 2.0))
                (list
                  (make-roots 2  1.414))
                #i1e-5)
Ran 1 test.
0 tests passed.
Check failures:
                     ┌────────────────────────────────────────┐                                      ┌─────────────────────────┐
        Actual value │ '((make-roots 2.0 1.4142135623730951)) │ is not within 1e-5 of expected value │ '((make-roots 2 1.414)) │.
                     └────────────────────────────────────────┘                                      └─────────────────────────┘
at line 5, column 0

It is an error for expressions or expected-expression to produce a function value; see note on check-expect for details.

If delta is not a number, check-within reports an error.

syntax
(check-error expression expected-error-message)
(check-error expression)

Checks that the expression reports an error, where the error messages matches the value of expected-error-message, if it is present.

Here is a typical beginner example that calls for a use of check-error:

(define sample-table
  '(("matthias" 10)
    ("matthew"  20)
    ("robby"    -1)
    ("shriram"  18)))

; [List-of [list String Number]] String -> Number
; determine the number associated with s in table

(define (lookup table s)
  (cond
    [(empty? table) (error (string-append s " not found"))]
    [else (if (string=? (first (first table)) s)
              (second (first table))
              (lookup (rest table)))]))

Consider the following two examples in this context:

Example:

> (check-expect (lookup sample-table "matthew") 20)
The test passed!

Example:

> (check-error (lookup sample-table "kathi") "kathi not found")
The test passed!

syntax
(check-member-of expression expression expression ...)

Checks that the value of the first expression is that of one of the following expressions.

; [List-of X] -> X
; pick a random element from the given list l
(define (pick-one l)
(list-ref l (random (length l))))

Example:

> (check-member-of (pick-one '("a" "b" "c")) "a" "b" "c")
The test passed!

It is an error for any of expressions to produce a function value; see note on check-expect for details.

syntax
(check-range expression low-expression high-expression)

Checks that the value of the first expression is a number in between the value of the low-expression and the high-expression, inclusive.

A check-range form is best used to delimit the possible results of functions that compute inexact numbers:

; [Real -> Real] Real -> Real
; what is the slope of f at x?
(define (differentiate f x)
  (local ((define epsilon 0.001)
          (define left (- x epsilon))
          (define right (+ x epsilon))
          (define slope
            (/ (- (f right) (f left))
               2 epsilon)))
    slope))

(check-range (differentiate sin 0) 0.99 1.0)

It is an error for expression, low-expression, or high-expression to produce a function value or an inexact number; see note on check-expect for details.

3 Pre-Defined Functions🔗ℹ

The remaining subsections list those functions that are built into the programming language. All other functions must be defined in the program.

4 Numbers: Integers, Rationals, Reals, Complex, Exacts, Inexacts🔗ℹ

procedure
(- x y ...) → number
x : number
y : number

Subtracts the second (and following) number(s) from the first ; negates the number if there is only one argument.

> (- 5)
image? is used here before its definition
> (- 5 3)
image? is used here before its definition
> (- 5 3 1)
image? is used here before its definition

procedure
(< x y z ...) → boolean?
  x : real
  y : real
  z : real

Compares two or more (real) numbers for less-than.

> (< 42 2/5)
image? is used here before its definition

procedure
(<= x y z ...) → boolean?
  x : real
  y : real
  z : real

Compares two or more (real) numbers for less-than or equality.

> (<= 42 2/5)
image? is used here before its definition

procedure
(> x y z ...) → boolean?
  x : real
  y : real
  z : real

Compares two or more (real) numbers for greater-than.

> (> 42 2/5)
image? is used here before its definition

procedure
(>= x y z ...) → boolean?
  x : real
  y : real
  z : real

Compares two or more (real) numbers for greater-than or equality.

> (>= 42 42)
image? is used here before its definition

procedure
(abs x) → real
x : real

Determines the absolute value of a real number.

> (abs -12)
image? is used here before its definition

procedure
(acos x) → number
x : number

Computes the arccosine (inverse of cos) of a number.

> (acos 0)
image? is used here before its definition

procedure
(add1 x) → number
x : number

Increments the given number.

> (add1 2)
image? is used here before its definition

procedure
(angle x) → real
x : number

Extracts the angle from a complex number.

> (angle (make-polar 3 4))
image? is used here before its definition

procedure
(asin x) → number
x : number

Computes the arcsine (inverse of sin) of a number.

> (asin 0)
image? is used here before its definition

procedure
(atan x) → number
x : number

Computes the arctangent of the given number:

> (atan 0)
image? is used here before its definition
> (atan 0.5)
image? is used here before its definition

Also comes in a two-argument version where (atan y x) computes (atan (/ y x)) but the signs of y and x determine the quadrant of the result and the result tends to be more accurate than that of the 1-argument version in borderline cases:

> (atan 3 4)
image? is used here before its definition
> (atan -2 -1)
image? is used here before its definition

procedure
(ceiling x) → integer
x : real

Determines the closest integer (exact or inexact) above a real number. See round.

> (ceiling 12.3)
image? is used here before its definition

procedure
(complex? x) → boolean?
x : any/c

Determines whether some value is complex.

> (complex? 1-2i)
image? is used here before its definition

procedure
(conjugate x) → number
x : number

Flips the sign of the imaginary part of a complex number.

> (conjugate 3+4i)
conjugate is used here before its definition
> (conjugate -2-5i)
conjugate is used here before its definition
> (conjugate (make-polar 3 4))
conjugate is used here before its definition

procedure
(cos x) → number
x : number

Computes the cosine of a number (radians).

> (cos pi)
pi is used here before its definition

procedure
(cosh x) → number
x : number

Computes the hyperbolic cosine of a number.

> (cosh 10)
cosh is used here before its definition

procedure
(current-seconds) → integer

Determines the current time in seconds elapsed (since a platform-specific starting date).

> (current-seconds)
image? is used here before its definition

procedure
(denominator x) → integer
x : rational?

Computes the denominator of a rational.

> (denominator 2/3)
image? is used here before its definition

value
e : real

Euler’s number.

> e
e is used here before its definition

procedure
(even? x) → boolean?
x : integer

Determines if some integer (exact or inexact) is even or not.

> (even? 2)
image? is used here before its definition

procedure
(exact->inexact x) → number
x : number

Converts an exact number to an inexact one.

> (exact->inexact 12)
image? is used here before its definition

procedure
(exact? x) → boolean?
x : number

Determines whether some number is exact.

> (exact? (sqrt 2))
image? is used here before its definition

procedure
(exp x) → number
x : number

Determines e raised to a number.

> (exp -2)
image? is used here before its definition

procedure
(expt x y) → number
x : number
y : number

Computes the power of the first to the second number, which is to say, exponentiation.

> (expt 16 1/2)
image? is used here before its definition
> (expt 3 -4)
image? is used here before its definition

procedure
(floor x) → integer
x : real

Determines the closest integer (exact or inexact) below a real number. See round.

> (floor 12.3)
image? is used here before its definition

procedure
(gcd x y ...) → integer
x : integer
y : integer

Determines the greatest common divisor of two integers (exact or inexact).

> (gcd 6 12 8)
image? is used here before its definition

procedure
(imag-part x) → real
x : number

Extracts the imaginary part from a complex number.

> (imag-part 3+4i)
image? is used here before its definition

procedure
(inexact->exact x) → number
x : number

Approximates an inexact number by an exact one.

> (inexact->exact 12.0)
image? is used here before its definition

procedure
(inexact? x) → boolean?
x : number

Determines whether some number is inexact.

> (inexact? 1-2i)
image? is used here before its definition

procedure
(integer->char x) → char
x : exact-integer?

Looks up the character that corresponds to the given exact integer in the ASCII table (if any).

> (integer->char 42)
image? is used here before its definition

procedure
(integer-sqrt x) → complex
x : integer

Computes the integer or imaginary-integer square root of an integer.

> (integer-sqrt 11)
image? is used here before its definition
> (integer-sqrt -11)
image? is used here before its definition

procedure
(integer? x) → boolean?
x : any/c

Determines whether some value is an integer (exact or inexact).

> (integer? (sqrt 2))
image? is used here before its definition

procedure
(lcm x y ...) → integer
x : integer
y : integer

Determines the least common multiple of two integers (exact or inexact).

> (lcm 6 12 8)
image? is used here before its definition

procedure
(log x) → number
x : number

Determines the base-e logarithm of a number.

> (log 12)
image? is used here before its definition

procedure
(magnitude x) → real
x : number

Determines the magnitude of a complex number.

> (magnitude (make-polar 3 4))
image? is used here before its definition

procedure
(make-polar x y) → number
x : real
y : real

Creates a complex from a magnitude and angle.

> (make-polar 3 4)
image? is used here before its definition

procedure
(make-rectangular x y) → number
x : real
y : real

Creates a complex from a real and an imaginary part.

> (make-rectangular 3 4)
image? is used here before its definition

procedure
(max x y ...) → real
x : real
y : real

Determines the largest number—aka, the maximum.

> (max 3 2 8 7 2 9 0)
image? is used here before its definition

procedure
(min x y ...) → real
x : real
y : real

Determines the smallest number—aka, the minimum.

> (min 3 2 8 7 2 9 0)
image? is used here before its definition

procedure
(modulo x y) → integer
x : integer
y : integer

Finds the remainder of the division of the first number by the second:

> (modulo 9 2)
image? is used here before its definition
> (modulo 3 -4)
image? is used here before its definition

procedure
(negative? x) → boolean?
x : real

Determines if some real number is strictly smaller than zero.

> (negative? -2)
image? is used here before its definition

procedure
(number->string x) → string
x : number

Converts a number to a string.

> (number->string 42)
image? is used here before its definition

procedure
(number->string-digits x p) → string
x : number
p : posint

Converts a number x to a string with the specified number of digits.

> (number->string-digits 0.9 2)
number->string-digits is used here before its definition
> (number->string-digits pi 4)
number->string-digits is used here before its definition

procedure
(number? n) → boolean?
n : any/c

Determines whether some value is a number:

> (number? "hello world")
image? is used here before its definition
> (number? 42)
image? is used here before its definition

procedure
(numerator x) → integer
x : rational?

Computes the numerator of a rational.

> (numerator 2/3)
image? is used here before its definition

procedure
(odd? x) → boolean?
x : integer

Determines if some integer (exact or inexact) is odd or not.

> (odd? 2)
image? is used here before its definition

value
pi : real

The ratio of a circle’s circumference to its diameter.

> pi
pi is used here before its definition

procedure
(positive? x) → boolean?
x : real

Determines if some real number is strictly larger than zero.

> (positive? -2)
image? is used here before its definition

procedure
(quotient x y) → integer
x : integer
y : integer

Divides the first integer—also called dividend—by the second—known as divisor—to obtain the quotient.

> (quotient 9 2)
image? is used here before its definition
> (quotient 3 4)
image? is used here before its definition

procedure
(random x) → natural
x : natural

Generates a random number. If given one argument random returns a natural number less than the given natural. In ASL, if given no arguments, random generates a random inexact number between 0.0 and 1.0 exclusive.

> (random)
image? is used here before its definition

> (random 42)
image? is used here before its definition

procedure
(rational? x) → boolean?
x : any/c

Determines whether some value is a rational number.

> (rational? 1)
image? is used here before its definition
> (rational? -2.349)
image? is used here before its definition
> (rational? #i1.23456789)
image? is used here before its definition
> (rational? (sqrt -1))
image? is used here before its definition
> (rational? pi)
pi is used here before its definition
> (rational? e)
e is used here before its definition
> (rational? 1-2i)
image? is used here before its definition

As the interactions show, the teaching languages considers many more numbers as rationals than expected. In particular, pi is a rational number because it is only a finite approximation to the mathematical π. Think of rational? as a suggestion to think of these numbers as fractions.

procedure
(real-part x) → real
x : number

Extracts the real part from a complex number.

> (real-part 3+4i)
image? is used here before its definition

procedure
(real? x) → boolean?
x : any/c

Determines whether some value is a real number.

> (real? 1-2i)
image? is used here before its definition

procedure
(remainder x y) → integer
x : integer
y : integer

Determines the remainder of dividing the first by the second integer (exact or inexact).

> (remainder 9 2)
image? is used here before its definition
> (remainder 3 4)
image? is used here before its definition

procedure
(round x) → integer
x : real

Rounds a real number to an integer (rounds to even to break ties). See floor and ceiling.

> (round 12.3)
image? is used here before its definition

procedure
(sgn x) → (union 1 #i1.0 0 #i0.0 -1 #i-1.0)
x : real

Determines the sign of a real number.

> (sgn -12)
sgn is used here before its definition

procedure
(sin x) → number
x : number

Computes the sine of a number (radians).

> (sin pi)
pi is used here before its definition

procedure
(sinh x) → number
x : number

Computes the hyperbolic sine of a number.

> (sinh 10)
sinh is used here before its definition

procedure
(sqr x) → number
x : number

Computes the square of a number.

> (sqr 8)
image? is used here before its definition

procedure
(sqrt x) → number
x : number

Computes the square root of a number.

> (sqrt 9)
image? is used here before its definition
> (sqrt 2)
image? is used here before its definition

procedure
(sub1 x) → number
x : number

Decrements the given number.

> (sub1 2)
image? is used here before its definition

procedure
(tan x) → number
x : number

Computes the tangent of a number (radians).

> (tan pi)
pi is used here before its definition

procedure
(zero? x) → boolean?
x : number

Determines if some number is zero or not.

> (zero? 2)
image? is used here before its definition

5 Booleans🔗ℹ

procedure
(boolean->string x) → string
x : boolean?

Produces a string for the given boolean

> (boolean->string #false)
boolean->string is used here before its definition
> (boolean->string #true)
boolean->string is used here before its definition

procedure
(boolean=? x y) → boolean?
x : boolean?
y : boolean?

Determines whether two booleans are equal.

> (boolean=? #true #false)
boolean=? is used here before its definition

procedure
(boolean? x) → boolean?
x : any/c

Determines whether some value is a boolean.

> (boolean? 42)
image? is used here before its definition
> (boolean? #false)
image? is used here before its definition

procedure
(false? x) → boolean?
x : any/c

Determines whether a value is false.

> (false? #false)
false? is used here before its definition

procedure
(not x) → boolean?
x : boolean?

Negates a boolean value.

> (not #false)
image? is used here before its definition

6 Symbols🔗ℹ

procedure
(symbol->string x) → string
x : symbol

Converts a symbol to a string.

> (symbol->string 'c)
image? is used here before its definition

procedure
(symbol=? x y) → boolean?
x : symbol
y : symbol

Determines whether two symbols are equal.

> (symbol=? 'a 'b)
symbol=? is used here before its definition

procedure
(symbol? x) → boolean?
x : any/c

Determines whether some value is a symbol.

> (symbol? 'a)
image? is used here before its definition

7 Lists🔗ℹ

procedure
(append l ...) → (listof any)
l : (listof any)

Creates a single list from several. In ASL, list* also deals with cyclic lists.

procedure
(assoc x l) → (union (listof any) #false)
x : any/c
l : (listof any)

Produces the first pair on l whose first is equal? to x; otherwise it produces #false.

> (assoc "hello" '(("world" 2) ("hello" 3) ("good" 0)))
image? is used here before its definition

procedure
(assq x l) → (union #false cons?)
x : any/c
l : list?

Determines whether some item is the first item of a pair in a list of pairs. (It compares the items with eq?.)

> a
image? is used here before its definition
> (assq 'b a)
image? is used here before its definition

procedure
(caaar x) → any/c
x : list?

LISP-style selector: (car (car (car x))).

> w
image? is used here before its definition
> (caaar w)
image? is used here before its definition

procedure
(caadr x) → any/c
x : list?

LISP-style selector: (car (car (cdr x))).

> (caadr (cons 1 (cons (cons 'a '()) (cons (cons 'd '()) '()))))
image? is used here before its definition

procedure
(caar x) → any/c
x : list?

LISP-style selector: (car (car x)).

> y
image? is used here before its definition
> (caar y)
image? is used here before its definition

procedure
(cadar x) → any/c
x : list?

LISP-style selector: (car (cdr (car x))).

> w
image? is used here before its definition
> (cadar w)
image? is used here before its definition

procedure
(cadddr x) → any/c
x : list?

LISP-style selector: (car (cdr (cdr (cdr x)))).

> v
image? is used here before its definition
> (cadddr v)
image? is used here before its definition

procedure
(caddr x) → any/c
x : list?

LISP-style selector: (car (cdr (cdr x))).

> x
image? is used here before its definition
> (caddr x)
image? is used here before its definition

procedure
(cadr x) → any/c
x : list?

LISP-style selector: (car (cdr x)).

> x
image? is used here before its definition
> (cadr x)
image? is used here before its definition

procedure
(car x) → any/c
x : cons?

Selects the first item of a non-empty list.

> x
image? is used here before its definition
> (car x)
image? is used here before its definition

procedure
(cdaar x) → any/c
x : list?

LISP-style selector: (cdr (car (car x))).

> w
image? is used here before its definition
> (cdaar w)
image? is used here before its definition

procedure
(cdadr x) → any/c
x : list?

LISP-style selector: (cdr (car (cdr x))).

> (cdadr (list 1 (list 2 "a") 3))
image? is used here before its definition

procedure
(cdar x) → list?
x : list?

LISP-style selector: (cdr (car x)).

> y
image? is used here before its definition
> (cdar y)
image? is used here before its definition

procedure
(cddar x) → any/c
x : list?

LISP-style selector: (cdr (cdr (car x)))

> w
image? is used here before its definition
> (cddar w)
image? is used here before its definition

procedure
(cdddr x) → any/c
x : list?

LISP-style selector: (cdr (cdr (cdr x))).

> v
image? is used here before its definition
> (cdddr v)
image? is used here before its definition

procedure
(cddr x) → list?
x : list?

LISP-style selector: (cdr (cdr x)).

> x
image? is used here before its definition
> (cddr x)
image? is used here before its definition

procedure
(cdr x) → any/c
x : cons?

Selects the rest of a non-empty list.

> x
image? is used here before its definition
> (cdr x)
image? is used here before its definition

procedure
(cons x l) → (listof X)
x : X
l : (listof X)

Constructs a list. In ASL, cons creates a mutable list.

procedure
(cons? x) → boolean?
x : any/c

Determines whether some value is a constructed list.

> (cons? (cons 1 '()))
ffi-lib: could not load foreign library
  path: libfontconfig.so.1
  system error: libfontconfig.so.1: cannot open shared object file: No such file or directory
  context...:
   /home/root/racket/collects/ffi/unsafe/private/ffi-lib.rkt:18:0: get-ffi-lib*
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
   body of top-level
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet: mismatch;
reference to a variable that is uninitialized
  name: cairo-lib
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`
  context...:
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
   body of top-level
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet:mismatch;
reference to a variable that is uninitialized
name: CAIRO_OPERATOR_SOURCE
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/private/bitmap.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`image? is used here before its definitionimage? is used here before its definitionimage? is used here before its definition
> (cons? 42)
image? is used here before its definition

procedure
(eighth x) → any/c
x : list?

Selects the eighth item of a non-empty list.

> v
image? is used here before its definition
> (eighth v)
eighth is used here before its definition

procedure
(empty? x) → boolean?
x : any/c

Determines whether some value is the empty list.

> (empty? '())
image? is used here before its definition
> (empty? 42)
image? is used here before its definition

procedure
(fifth x) → any/c
x : list?

Selects the fifth item of a non-empty list.

> v
image? is used here before its definition
> (fifth v)
fifth is used here before its definition

procedure
(first x) → any/c
x : cons?

Selects the first item of a non-empty list.

> x
image? is used here before its definition
> (first x)
image? is used here before its definition

procedure
(for-each f l ...) → void?
f : (any ... -> any)
l : (listof any)

Applies a function to each item on one or more lists for effect only:

(for-each f (list x-1 ... x-n)) = (begin (f x-1) ... (f x-n))

> (for-each (lambda (x) (begin (display x) (newline))) '(1 2 3))
1
2
3
ffi-lib: could not load foreign library
  path: libfontconfig.so.1
  system error: libfontconfig.so.1: cannot open shared object file: No such file or directory
  context...:
   /home/root/racket/collects/ffi/unsafe/private/ffi-lib.rkt:18:0: get-ffi-lib*
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
   body of top-level
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet: mismatch;
reference to a variable that is uninitialized
  name: cairo-lib
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`
  context...:
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
   body of top-level
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet:mismatch;
reference to a variable that is uninitialized
name: CAIRO_OPERATOR_SOURCE
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/private/bitmap.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`image? is used here before its definitionimage? is used here before its definitionimage? is used here before its definition

procedure
(fourth x) → any/c
x : list?

Selects the fourth item of a non-empty list.

> v
image? is used here before its definition
> (fourth v)
fourth is used here before its definition

procedure
(length l) → natural?
l : list?

Evaluates the number of items on a list.

> x
image? is used here before its definition
> (length x)
image? is used here before its definition

procedure
(list x ...) → list?
x : any/c

Constructs a list of its arguments.

> (list 1 2 3 4 5 6 7 8 9 0)
ffi-lib: could not load foreign library
  path: libfontconfig.so.1
  system error: libfontconfig.so.1: cannot open shared object file: No such file or directory
  context...:
   /home/root/racket/collects/ffi/unsafe/private/ffi-lib.rkt:18:0: get-ffi-lib*
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
   body of top-level
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet: mismatch;
reference to a variable that is uninitialized
  name: cairo-lib
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`
  context...:
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
   body of top-level
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet:mismatch;
reference to a variable that is uninitialized
name: CAIRO_OPERATOR_SOURCE
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/private/bitmap.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`image? is used here before its definitionimage? is used here before its definitionimage? is used here before its definition

procedure
(list* x ... l) → (listof any)
x : any
l : (listof any)

Constructs a list by adding multiple items to a list. In ASL, list* also deals with cyclic lists.

procedure
(list-ref x i) → any/c
x : list?
i : natural?

Extracts the indexed item from the list.

> v
image? is used here before its definition
> (list-ref v 9)
image? is used here before its definition

procedure
(list? x) → boolean?
x : any/c

Checks whether the given value is a list.

> (list? 42)
image? is used here before its definition
> (list? '())
image? is used here before its definition
> (list? (cons 1 (cons 2 '())))
image? is used here before its definition

procedure
(make-list i x) → list?
i : natural?
x : any/c

Constructs a list of i copies of x.

> (make-list 3 "hello")
ffi-lib: could not load foreign library
  path: libfontconfig.so.1
  system error: libfontconfig.so.1: cannot open shared object file: No such file or directory
  context...:
   /home/root/racket/collects/ffi/unsafe/private/ffi-lib.rkt:18:0: get-ffi-lib*
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
   body of top-level
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet: mismatch;
reference to a variable that is uninitialized
  name: cairo-lib
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`
  context...:
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
   body of top-level
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet:mismatch;
reference to a variable that is uninitialized
name: CAIRO_OPERATOR_SOURCE
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/private/bitmap.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`image? is used here before its definitionimage? is used here before its definitionimage? is used here before its definition

procedure
(member x l) → boolean?
x : any/c
l : list?

Determines whether some value is on the list (comparing values with equal?).

> x
image? is used here before its definition
> (member "hello" x)
image? is used here before its definition

procedure
(member? x l) → boolean?
x : any/c
l : list?

Determines whether some value is on the list (comparing values with equal?).

> x
image? is used here before its definition
> (member? "hello" x)
member? is used here before its definition

procedure
(memq x l) → boolean?
x : any/c
l : list?

Determines whether some value x is on some list l, using eq? to compare x with items on l.

> x
image? is used here before its definition
> (memq (list (list 1 2 3)) x)
image? is used here before its definition

procedure
(memq? x l) → boolean?
x : any/c
l : list?

Determines whether some value x is on some list l, using eq? to compare x with items on l.

> x
image? is used here before its definition
> (memq? (list (list 1 2 3)) x)
memq? is used here before its definition

procedure
(memv x l) → (or/c #false list)
x : any/c
l : list?

Determines whether some value is on the list if so, it produces the suffix of the list that starts with x if not, it produces false. (It compares values with the eqv? predicate.)

> x
image? is used here before its definition
> (memv (list (list 1 2 3)) x)
image? is used here before its definition

value
null : list

Another name for the empty list

> null
image? is used here before its definition

procedure
(null? x) → boolean?
x : any/c

Determines whether some value is the empty list.

> (null? '())
image? is used here before its definition
> (null? 42)
image? is used here before its definition

procedure
(range start end step) → list?
  start : number
  end : number
  step : number

Constructs a list of numbers by stepping from start to end.

> (range 0 10 2)
ffi-lib: could not load foreign library
  path: libfontconfig.so.1
  system error: libfontconfig.so.1: cannot open shared object file: No such file or directory
  context...:
   /home/root/racket/collects/ffi/unsafe/private/ffi-lib.rkt:18:0: get-ffi-lib*
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
   body of top-level
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet: mismatch;
reference to a variable that is uninitialized
  name: cairo-lib
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`
  context...:
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
   body of top-level
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet:mismatch;
reference to a variable that is uninitialized
name: CAIRO_OPERATOR_SOURCE
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/private/bitmap.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`image? is used here before its definitionimage? is used here before its definitionimage? is used here before its definition

procedure
(remove x l) → list?
x : any/c
l : list?

Constructs a list like the given one, with the first occurrence of the given item removed (comparing values with equal?).

> x
image? is used here before its definition
> (remove "hello" x)
image? is used here before its definition
> hello-2
image? is used here before its definition
> (remove "hello" hello-2)
image? is used here before its definition

procedure
(remove-all x l) → list?
x : any/c
l : list?

Constructs a list like the given one, with all occurrences of the given item removed (comparing values with equal?).

> x
image? is used here before its definition
> (remove-all "hello" x)
remove-all is used here before its definition
> hello-2
image? is used here before its definition
> (remove-all "hello" hello-2)
remove-all is used here before its definition

procedure
(rest x) → any/c
x : cons?

Selects the rest of a non-empty list.

> x
image? is used here before its definition
> (rest x)
image? is used here before its definition

procedure
(reverse l) → list
l : list?

Creates a reversed version of a list.

> x
image? is used here before its definition
> (reverse x)
image? is used here before its definition

procedure
(second x) → any/c
x : list?

Selects the second item of a non-empty list.

> x
image? is used here before its definition
> (second x)
second is used here before its definition

procedure
(seventh x) → any/c
x : list?

Selects the seventh item of a non-empty list.

> v
image? is used here before its definition
> (seventh v)
seventh is used here before its definition

procedure
(sixth x) → any/c
x : list?

Selects the sixth item of a non-empty list.

> v
image? is used here before its definition
> (sixth v)
sixth is used here before its definition

procedure
(third x) → any/c
x : list?

Selects the third item of a non-empty list.

> x
image? is used here before its definition
> (third x)
third is used here before its definition

8 Posns🔗ℹ

procedure
(make-posn x y) → posn
x : any/c
y : any/c

Constructs a posn from two arbitrary values.

> (make-posn 3 3)
image? is used here before its definition
> (make-posn "hello" #true)
image? is used here before its definition

procedure
(posn-x p) → any/c
p : posn

Extracts the x component of a posn.

> p
image? is used here before its definition
> (posn-x p)
image? is used here before its definition

procedure
(posn-y p) → any/c
p : posn

Extracts the y component of a posn.

> p
image? is used here before its definition
> (posn-y p)
image? is used here before its definition

procedure
(posn? x) → boolean?
x : any/c

Determines if its input is a posn.

> q
image? is used here before its definition
> (posn? q)
image? is used here before its definition
> (posn? 42)
image? is used here before its definition

procedure
(set-posn-x! p x) → void?
p : posn
x : any

Updates the x component of a posn.

> p
image? is used here before its definition
> (set-posn-x! p 678)
image? is used here before its definition
> p
image? is used here before its definition

procedure
(set-posn-y! p x) → void
p : posn
x : any

Updates the y component of a posn.

> q
image? is used here before its definition
> (set-posn-y! q 678)
image? is used here before its definition
> q
image? is used here before its definition

9 Characters🔗ℹ

procedure
(char->integer c) → integer
c : char

Looks up the number that corresponds to the given character in the ASCII table (if any).

> (char->integer #\a)
image? is used here before its definition
> (char->integer #\z)
image? is used here before its definition

procedure
(char-alphabetic? c) → boolean?
c : char

Determines whether a character represents an alphabetic character.

> (char-alphabetic? #\Q)
image? is used here before its definition

procedure
(char-ci<=? c d e ...) → boolean?
  c : char
  d : char
  e : char

Determines whether the characters are ordered in an increasing and case-insensitive manner.

> (char-ci<=? #\b #\B)
image? is used here before its definition
> (char<=? #\b #\B)
image? is used here before its definition

procedure
(char-ci<? c d e ...) → boolean?
  c : char
  d : char
  e : char

Determines whether the characters are ordered in a strictly increasing and case-insensitive manner.

> (char-ci<? #\B #\c)
image? is used here before its definition
> (char<? #\b #\B)
image? is used here before its definition

procedure
(char-ci=? c d e ...) → boolean?
  c : char
  d : char
  e : char

Determines whether two characters are equal in a case-insensitive manner.

> (char-ci=? #\b #\B)
image? is used here before its definition

procedure
(char-ci>=? c d e ...) → boolean?
  c : char
  d : char
  e : char

Determines whether the characters are sorted in a decreasing and case-insensitive manner.

> (char-ci>=? #\b #\C)
image? is used here before its definition
> (char>=? #\b #\C)
image? is used here before its definition

procedure
(char-ci>? c d e ...) → boolean?
  c : char
  d : char
  e : char

Determines whether the characters are sorted in a strictly decreasing and case-insensitive manner.

> (char-ci>? #\b #\B)
image? is used here before its definition
> (char>? #\b #\B)
image? is used here before its definition

procedure
(char-downcase c) → char
c : char

Produces the equivalent lower-case character.

> (char-downcase #\T)
image? is used here before its definition

procedure
(char-lower-case? c) → boolean?
c : char

Determines whether a character is a lower-case character.

> (char-lower-case? #\T)
image? is used here before its definition

procedure
(char-numeric? c) → boolean?
c : char

Determines whether a character represents a digit.

> (char-numeric? #\9)
image? is used here before its definition

procedure
(char-upcase c) → char
c : char

Produces the equivalent upper-case character.

> (char-upcase #\t)
image? is used here before its definition

procedure
(char-upper-case? c) → boolean?
c : char

Determines whether a character is an upper-case character.

> (char-upper-case? #\T)
image? is used here before its definition

procedure
(char-whitespace? c) → boolean?
c : char

Determines whether a character represents space.

> (char-whitespace? #\tab)
image? is used here before its definition

procedure
(char<=? c d e ...) → boolean?
  c : char
  d : char
  e : char

Determines whether the characters are ordered in an increasing manner.

> (char<=? #\a #\a #\b)
image? is used here before its definition

procedure
(char<? x d e ...) → boolean?
  x : char
  d : char
  e : char

Determines whether the characters are ordered in a strictly increasing manner.

> (char<? #\a #\b #\c)
image? is used here before its definition

procedure
(char=? c d e ...) → boolean?
  c : char
  d : char
  e : char

Determines whether the characters are equal.

> (char=? #\b #\a)
image? is used here before its definition

procedure
(char>=? c d e ...) → boolean?
  c : char
  d : char
  e : char

Determines whether the characters are sorted in a decreasing manner.

> (char>=? #\b #\b #\a)
image? is used here before its definition

procedure
(char>? c d e ...) → boolean?
  c : char
  d : char
  e : char

Determines whether the characters are sorted in a strictly decreasing manner.

> (char>? #\A #\z #\a)
image? is used here before its definition

procedure
(char? x) → boolean?
x : any/c

Determines whether a value is a character.

> (char? "a")
image? is used here before its definition
> (char? #\a)
image? is used here before its definition

10 Strings🔗ℹ

procedure
(explode s) → (listof string)
s : string

Translates a string into a list of 1-letter strings.

> (explode "cat")
explode is used here before its definition

procedure
(format f x ...) → string
f : string
x : any/c

Formats a string, possibly embedding values.

> (format "Dear Dr. ~a:" "Flatt")
image? is used here before its definition
> (format "Dear Dr. ~s:" "Flatt")
image? is used here before its definition

procedure
(implode l) → string
l : list?

Concatenates the list of 1-letter strings into one string.

> (implode (cons "c" (cons "a" (cons "t" '()))))
implode is used here before its definition

procedure
(int->string i) → string
i : integer

Converts an integer in [0,55295] or [57344 1114111] to a 1-letter string.

> (int->string 65)
int->string is used here before its definition

procedure
(list->string l) → string
l : list?

Converts a s list of characters into a string.

> (list->string (cons #\c (cons #\a (cons #\t '()))))
image? is used here before its definition

procedure
(make-string i c) → string
i : natural?
c : char

Produces a string of length i from c.

> (make-string 3 #\d)
image? is used here before its definition

procedure
(replicate i s) → string
i : natural?
s : string

Replicates s i times.

> (replicate 3 "h")
replicate is used here before its definition

procedure
(string c ...) → string?
c : char

Builds a string of the given characters.

> (string #\d #\o #\g)
image? is used here before its definition

procedure
(string->int s) → integer
s : string

Converts a 1-letter string to an integer in [0,55295] or [57344, 1114111].

> (string->int "a")
string->int is used here before its definition

procedure
(string->list s) → (listof char)
s : string

Converts a string into a list of characters.

> (string->list "hello")
image? is used here before its definition

procedure
(string->number s) → (union number #false)
s : string

Converts a string into a number, produce false if impossible.

> (string->number "-2.03")
image? is used here before its definition
> (string->number "1-2i")
image? is used here before its definition

procedure
(string->symbol s) → symbol
s : string

Converts a string into a symbol.

> (string->symbol "hello")
image? is used here before its definition

procedure
(string-alphabetic? s) → boolean?
s : string

Determines whether all ’letters’ in the string are alphabetic.

> (string-alphabetic? "123")
string-alphabetic? is used here before its definition
> (string-alphabetic? "cat")
string-alphabetic? is used here before its definition

procedure
(string-contains-ci? s t) → boolean?
s : string
t : string

Determines whether the first string appears in the second one without regard to the case of the letters.

> (string-contains-ci? "At" "caT")
string-contains-ci? is used here before its definition

procedure
(string-contains? s t) → boolean?
s : string
t : string

Determines whether the first string appears literally in the second one.

> (string-contains? "at" "cat")
string-contains? is used here before its definition

procedure
(string-copy s) → string
s : string

Copies a string.

> (string-copy "hello")
image? is used here before its definition

procedure
(string-downcase s) → string
s : string

Produces a string like the given one with all ’letters’ as lower case.

> (string-downcase "CAT")
image? is used here before its definition
> (string-downcase "cAt")
image? is used here before its definition

procedure
(string-ith s i) → 1string?
s : string
i : natural?

Extracts the ith 1-letter substring from s.

> (string-ith "hello world" 1)
string-ith is used here before its definition

procedure
(string-length s) → nat
s : string

Determines the length of a string.

> (string-length "hello world")
image? is used here before its definition

procedure
(string-lower-case? s) → boolean?
s : string

Determines whether all ’letters’ in the string are lower case.

> (string-lower-case? "CAT")
string-lower-case? is used here before its definition

procedure
(string-numeric? s) → boolean?
s : string

Determines whether all ’letters’ in the string are numeric.

> (string-numeric? "123")
string-numeric? is used here before its definition
> (string-numeric? "1-2i")
string-numeric? is used here before its definition

procedure
(string-ref s i) → char
s : string
i : natural?

Extracts the ith character from s.

> (string-ref "cat" 2)
image? is used here before its definition

procedure
(string-upcase s) → string
s : string

Produces a string like the given one with all ’letters’ as upper case.

> (string-upcase "cat")
image? is used here before its definition
> (string-upcase "cAt")
image? is used here before its definition

procedure
(string-upper-case? s) → boolean?
s : string

Determines whether all ’letters’ in the string are upper case.

> (string-upper-case? "CAT")
string-upper-case? is used here before its definition

procedure
(string-whitespace? s) → boolean?
s : string

Determines whether all ’letters’ in the string are white space.

> (string-whitespace? (string-append " " (string #\tab #\newline #\return)))
string-whitespace? is used here before its definition

procedure
(string? x) → boolean?
x : any/c

Determines whether a value is a string.

> (string? "hello world")
image? is used here before its definition
> (string? 42)
image? is used here before its definition

procedure
(substring s i j) → string
  s : string
  i : natural?
  j : natural?

Extracts the substring starting at i up to j (or the end if j is not provided).

> (substring "hello world" 1 5)
image? is used here before its definition
> (substring "hello world" 1 8)
image? is used here before its definition
> (substring "hello world" 4)
image? is used here before its definition

11 Images🔗ℹ

procedure
(image=? i j) → boolean?
i : image
j : image

Determines whether two images are equal.

> c1
c1 is used here before its definition
> (image=? (circle 5 "solid" "green") c1)
image=? is used here before its definition
> (image=? (circle 10 "solid" "green") c1)
image=? is used here before its definition

procedure
(image? x) → boolean?
x : any/c

Determines whether a value is an image.

> c1
c1 is used here before its definition
> (image? c1)
image? is used here before its definition

12 Misc🔗ℹ

procedure
(=~ x y eps) → boolean?
  x : number
  y : number
  eps : non-negative-real

Checks whether x and y are within eps of either other.

> (=~ 1.01 1.0 0.1)
ffi-lib: could not load foreign library
  path: libfontconfig.so.1
  system error: libfontconfig.so.1: cannot open shared object file: No such file or directory
  context...:
   /home/root/racket/collects/ffi/unsafe/private/ffi-lib.rkt:18:0: get-ffi-lib*
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
   body of top-level
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet: mismatch;
reference to a variable that is uninitialized
  name: cairo-lib
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`
  context...:
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
   body of top-level
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet:mismatch;
reference to a variable that is uninitialized
name: CAIRO_OPERATOR_SOURCE
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/private/bitmap.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`image? is used here before its definitionimage? is used here before its definitioncircle is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definition=~ is used here before its definition
> (=~ 1.01 1.5 0.1)
=~ is used here before its definition

procedure
(current-milliseconds) → exact-integer

Returns the current “time” in fixnum milliseconds (possibly negative).

> (current-milliseconds)
image? is used here before its definition

value
eof : eof-object?

A value that represents the end of a file:

> eof
image? is used here before its definition

procedure
(eof-object? x) → boolean?
x : any/c

Determines whether some value is the end-of-file value.

> (eof-object? eof)
image? is used here before its definition
> (eof-object? 42)
image? is used here before its definition

procedure
(eq? x y) → boolean?
x : any/c
y : any/c

Determines whether two values are equivalent from the computer’s perspective (intensional).

> (eq? (cons 1 '()) (cons 1 '()))
image? is used here before its definition
> one
image? is used here before its definition
> (eq? one one)
image? is used here before its definition

procedure
(equal? x y) → boolean?
x : any/c
y : any/c

Determines whether two values are structurally equal where basic values are compared with the eqv? predicate.

> (equal? (make-posn 1 2) (make-posn (- 2 1) (+ 1 1)))
image? is used here before its definition

procedure
(equal~? x y z) → boolean?
  x : any/c
  y : any/c
  z : non-negative-real

Compares x and y like equal? but uses =~ in the case of numbers.

> (equal~? (make-posn 1.01 1.0) (make-posn 1.01 0.99) 0.2)
equal~? is used here before its definition

procedure
(eqv? x y) → boolean?
x : any/c
y : any/c

Determines whether two values are equivalent from the perspective of all functions that can be applied to it (extensional).

> (eqv? (cons 1 '()) (cons 1 '()))
image? is used here before its definition
> one
image? is used here before its definition
> (eqv? one one)
image? is used here before its definition

procedure
(error x ...) → void?
x : any/c

Signals an error, combining the given values into an error message. If any of the values’ printed representations is too long, it is truncated and “...” is put into the string. If the first value is a symbol, it is suffixed with a colon and the result pre-pended on to the error message.

> zero
image? is used here before its definition
> (if (= zero 0) (error "can't divide by 0") (/ 1 zero))
can't divide by 0

procedure
(exit) → void

Evaluating (exit) terminates the running program.

procedure
(force v) → any
v : any

Finds the delayed value; see also delay.

procedure
(gensym) → symbol?

Generates a new symbol, different from all symbols in the program.

> (gensym)
image? is used here before its definition

procedure
(identity x) → any/c
x : any/c

Returns x.

> (identity 42)
identity is used here before its definition
> (identity c1)
identity is used here before its definition
> (identity "hello")
identity is used here before its definition

procedure
(promise? x) → boolean?
x : any

Determines if a value is delayed.

procedure
(sleep sec) → void
sec : positive-num

Causes the program to sleep for the given number of seconds.

procedure
(struct? x) → boolean?
x : any/c

Determines whether some value is a structure.

> (struct? (make-posn 1 2))
image? is used here before its definition
> (struct? 43)
image? is used here before its definition

procedure
(void) → void?

Produces a void value.

> (void)
image? is used here before its definition

procedure
(void? x) → boolean?
x : any

Determines if a value is void.

> (void? (void))
image? is used here before its definition
> (void? 42)
image? is used here before its definition

13 Signatures🔗ℹ

value
Any : signature?

Signature for any value.

value
Boolean : signature?

Signature for booleans.

value
Char : signature?

Signature for chararacters.

procedure
(ConsOf first-sig rest-sig) → signature?
first-sig : signature?
rest-sig : signature?

Signature for a cons pair.

value
EmptyList : signature?

Signature for the empty list.

value
False : signature?

Signature for just false.

value
Integer : signature?

Signature for integers.

value
Natural : signature?

Signature for natural numbers.

value
Number : signature?

Signature for arbitrary numbers.

value
Rational : signature?

Signature for rational numbers.

value
Real : signature?

Signature for real numbers.

value
String : signature?

Signature for strings.

value
Symbol : signature?

Signature for symbols.

value
True : signature?

Signature for just true.

14 Numbers (relaxed conditions)🔗ℹ

15 String (relaxed conditions)🔗ℹ

procedure
(string-append s ...) → string
s : string

Concatenates the characters of several strings.

> (string-append "hello" " " "world" " " "good bye")
image? is used here before its definition

procedure
(string-ci<=? s t x ...) → boolean?
  s : string
  t : string
  x : string

Determines whether the strings are ordered in a lexicographically increasing and case-insensitive manner.

> (string-ci<=? "hello" "WORLD" "zoo")
image? is used here before its definition

procedure
(string-ci<? s t x ...) → boolean?
  s : string
  t : string
  x : string

Determines whether the strings are ordered in a lexicographically strictly increasing and case-insensitive manner.

> (string-ci<? "hello" "WORLD" "zoo")
image? is used here before its definition

procedure
(string-ci=? s t x ...) → boolean?
  s : string
  t : string
  x : string

Determines whether all strings are equal, character for character, regardless of case.

> (string-ci=? "hello" "HellO")
image? is used here before its definition

procedure
(string-ci>=? s t x ...) → boolean?
  s : string
  t : string
  x : string

Determines whether the strings are ordered in a lexicographically decreasing and case-insensitive manner.

> (string-ci>? "zoo" "WORLD" "hello")
image? is used here before its definition

procedure
(string-ci>? s t x ...) → boolean?
  s : string
  t : string
  x : string

Determines whether the strings are ordered in a lexicographically strictly decreasing and case-insensitive manner.

> (string-ci>? "zoo" "WORLD" "hello")
image? is used here before its definition

procedure
(string<=? s t x ...) → boolean?
  s : string
  t : string
  x : string

Determines whether the strings are ordered in a lexicographically increasing manner.

> (string<=? "hello" "hello" "world" "zoo")
image? is used here before its definition

procedure
(string<? s t x ...) → boolean?
  s : string
  t : string
  x : string

Determines whether the strings are ordered in a lexicographically strictly increasing manner.

> (string<? "hello" "world" "zoo")
image? is used here before its definition

procedure
(string=? s t x ...) → boolean?
  s : string
  t : string
  x : string

Determines whether all strings are equal, character for character.

> (string=? "hello" "world")
image? is used here before its definition
> (string=? "bye" "bye")
image? is used here before its definition

procedure
(string>=? s t x ...) → boolean?
  s : string
  t : string
  x : string

Determines whether the strings are ordered in a lexicographically decreasing manner.

> (string>=? "zoo" "zoo" "world" "hello")
image? is used here before its definition

procedure
(string>? s t x ...) → boolean?
  s : string
  t : string
  x : string

Determines whether the strings are ordered in a lexicographically strictly decreasing manner.

> (string>? "zoo" "world" "hello")
image? is used here before its definition

16 Posn🔗ℹ

value
Posn : signature

Signature for posns.

procedure
(PosnOf x-sig y-sig) → signature
x-sig : signature
y-sig : signature

Creates a parametric signature for posns from signatures for its fields.

value
posn : struct

Name for using match with posns.

17 Higher-Order Functions🔗ℹ

18 Numbers (relaxed conditions plus)🔗ℹ

procedure
(* x ...) → number
x : number

Multiplies all given numbers. In ISL and up: * works when applied to only one number or none.

> (* 5 3)
image? is used here before its definition
> (* 5 3 2)
image? is used here before its definition
> (* 2)
image? is used here before its definition
> (*)
image? is used here before its definition

procedure
(+ x ...) → number
x : number

Adds all given numbers. In ISL and up: + works when applied to only one number or none.

> (+ 2/3 1/16)
image? is used here before its definition
> (+ 3 2 5 8)
image? is used here before its definition
> (+ 1)
image? is used here before its definition
> (+)
image? is used here before its definition

procedure
(/ x y ...) → number
x : number
y : number

Divides the first by all remaining numbers. In ISL and up: / computes the inverse when applied to one number.

> (/ 12 2)
image? is used here before its definition
> (/ 12 2 3)
image? is used here before its definition
> (/ 3)
image? is used here before its definition

procedure
(= x ...) → number
x : number

Compares numbers for equality. In ISL and up: = works when applied to only one number.

> (= 10 10)
image? is used here before its definition
> (= 11)
image? is used here before its definition
> (= 0)
image? is used here before its definition

19 Higher-Order Functions (with Lambda)🔗ℹ

procedure
(andmap p? [l]) → boolean
p? : (X ... -> boolean)
l : (listof X) = ...

Determines whether p? holds for all items of l ...:

(andmap p (list x-1 ... x-n)) = (and (p x-1) ... (p x-n))

(andmap p (list x-1 ... x-n) (list y-1 ... y-n)) = (and (p x-1 y-1) ... (p x-n y-n))

> (andmap odd? '(1 3 5 7 9))
ffi-lib: could not load foreign library
  path: libfontconfig.so.1
  system error: libfontconfig.so.1: cannot open shared object file: No such file or directory
  context...:
   /home/root/racket/collects/ffi/unsafe/private/ffi-lib.rkt:18:0: get-ffi-lib*
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
   body of top-level
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet: mismatch;
reference to a variable that is uninitialized
  name: cairo-lib
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`
  context...:
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
   body of top-level
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definition
> threshold
image? is used here before its definition
> (andmap (lambda (x) (< x threshold)) '(0 1 2))
image? is used here before its definition
> (andmap even? '())
image? is used here before its definition
> (andmap (lambda (x f) (f x)) (list 0 1 2) (list odd? even? positive?))
image? is used here before its definition

procedure
(apply f x-1 ... l) → Y
  f : (X-1 ... X-N -> Y)
  x-1 : X-1
  l : (list X-i+1 ... X-N)

Applies a function using items from a list as the arguments:

(apply f (list x-1 ... x-n)) = (f x-1 ... x-n)

> a-list
image? is used here before its definition
> (apply max a-list)
image? is used here before its definition

procedure
(argmax f l) → X
f : (X -> real)
l : (listof X)

Finds the (first) element of the list that maximizes the output of the function.

> (argmax second '((sam 98) (carl 78) (vincent 93) (asumu 99)))
argmax is used here before its definition

procedure
(argmin f l) → X
f : (X -> real)
l : (listof X)

Finds the (first) element of the list that minimizes the output of the function.

> (argmin second '((sam 98) (carl 78) (vincent 93) (asumu 99)))
argmin is used here before its definition

procedure
(build-list n f) → (listof X)
n : nat
f : (nat -> X)

Constructs a list by applying f to the numbers between 0 and (- n 1):

(build-list n f) = (list (f 0) ... (f (- n 1)))

> (build-list 22 add1)
image? is used here before its definition
> i
image? is used here before its definition
> (build-list 3 (lambda (j) (+ j i)))
image? is used here before its definition
> (build-list 5
              (lambda (i)
                (build-list 5
                            (lambda (j)
                              (if (= i j) 1 0)))))
image? is used here before its definition

procedure
(build-string n f) → string
n : nat
f : (nat -> char)

Constructs a string by applying f to the numbers between 0 and (- n 1):

(build-string n f) = (string (f 0) ... (f (- n 1)))

> (build-string 10 integer->char)
image? is used here before its definition
> (build-string 26 (lambda (x) (integer->char (+ 65 x))))
image? is used here before its definition

procedure
(compose f g) → (X -> Z)
f : (Y -> Z)
g : (X -> Y)

Composes a sequence of procedures into a single procedure:

(compose f g) = (lambda (x) (f (g x)))

> ((compose add1 second) '(add 3))
second is used here before its definition
> (map (compose add1 second) '((add 3) (sub 2) (mul 4)))
second is used here before its definition

procedure
(filter p? l) → (listof X)
p? : (X -> boolean)
l : (listof X)

Constructs a list from all those items on a list for which the predicate holds.

> (filter odd? '(0 1 2 3 4 5 6 7 8 9))
image? is used here before its definition
> threshold
image? is used here before its definition
> (filter (lambda (x) (>= x threshold)) '(0 1 2 3 4 5 6 7 8 9))
image? is used here before its definition

procedure
(foldl f base l ...) → Y
  f : (X ... Y -> Y)
  base : Y
  l : (listof X)

(foldl f base (list x-1 ... x-n)) = (f x-n ... (f x-1 base))

(foldl f base (list x-1 ... x-n) (list x-1 ... x-n))
= (f x-n y-n ... (f x-1 y-1 base))

> (foldl + 0 '(0 1 2 3 4 5 6 7 8 9))
image? is used here before its definition
> a-list
image? is used here before its definition
> (foldl (lambda (x r) (if (> x threshold) (cons (* 2 x) r) r)) '() a-list)
image? is used here before its definition
> (foldl (lambda (x y r) (+ x y r)) 0 '(1 2 3) '(10 11 12))
image? is used here before its definition

procedure
(foldr f base l ...) → Y
  f : (X ... Y -> Y)
  base : Y
  l : (listof X)

(foldr f base (list x-1 ... x-n)) = (f x-1 ... (f x-n base))

(foldr f base (list x-1 ... x-n) (list y-1 ... y-n))
= (f x-1 y-1 ... (f x-n y-n base))

> (foldr + 0 '(0 1 2 3 4 5 6 7 8 9))
image? is used here before its definition
> a-list
image? is used here before its definition
> (foldr (lambda (x r) (if (> x threshold) (cons (* 2 x) r) r)) '() a-list)
image? is used here before its definition
> (foldr (lambda (x y r) (+ x y r)) 0 '(1 2 3) '(10 11 12))
image? is used here before its definition

procedure
(map f l ...) → (listof Z)
f : (X ... -> Z)
l : (listof X)

Constructs a new list by applying a function to each item on one or more existing lists:

(map f (list x-1 ... x-n)) = (list (f x-1) ... (f x-n))

(map f (list x-1 ... x-n) (list y-1 ... y-n)) = (list (f x-1 y-1) ... (f x-n y-n))

> (map add1 (list 3 -4.01 2/5))
image? is used here before its definition

> (define (tag-with-a x)
(list "a" (+ x 1)))
image? is used here before its definition

> (map tag-with-a (list 3 -4.01 2/5))
image? is used here before its definition

> (define (add-and-multiply x y)
(+ x (* x y)))
image? is used here before its definition

> (map add-and-multiply (list 3 -4 2/5) '(1 2 3))
image? is used here before its definition

procedure
(memf p? l) → (union #false (listof X))
p? : (X -> any)
l : (listof X)

Produces #false if p? produces false for all items on l. If p? produces #true for any of the items on l, memf returns the sub-list starting from that item.

> (memf odd? '(2 4 6 3 8 0))
image? is used here before its definition

procedure
(ormap p? l) → boolean
p? : (X -> boolean)
l : (listof X)

Determines whether p? holds for at least one items of l:

(ormap p (list x-1 ... x-n)) = (or (p x-1) ... (p x-n))

(ormap p (list x-1 ... x-n) (list y-1 ... y-n)) = (or (p x-1 y-1) ... (p x-n y-n))

> (ormap odd? '(1 3 5 7 9))
image? is used here before its definition
> threshold
image? is used here before its definition
> (ormap (lambda (x) (< x threshold)) '(6 7 8 1 5))
image? is used here before its definition
> (ormap even? '())
image? is used here before its definition
> (ormap (lambda (x f) (f x)) (list 0 1 2) (list odd? even? positive?))
image? is used here before its definition

procedure
(procedure? x) → boolean?
x : any

Produces true if the value is a procedure.

> (procedure? cons)
image? is used here before its definition
> (procedure? add1)
image? is used here before its definition
> (procedure? (lambda (x) (> x 22)))
image? is used here before its definition

procedure
(quicksort l comp) → (listof X)
l : (listof X)
comp : (X X -> boolean)

Sorts the items on l, in an order according to comp (using the quicksort algorithm).

> (quicksort '(6 7 2 1 3 4 0 5 9 8) <)
quicksort is used here before its definition

procedure
(sort l comp) → (listof X)
l : (listof X)
comp : (X X -> boolean)

Sorts the items on l, in an order according to comp.

> (sort '(6 7 2 1 3 4 0 5 9 8) <)
image? is used here before its definition

20 Reading and Printing🔗ℹ

procedure
(display x) → void
x : any

Prints the argument to stdout (without quotes on symbols and strings, etc.).

> (display 10)
10
image? is used here before its definition
> (display "hello")
hello
image? is used here before its definition
> (display 'hello)
hello
image? is used here before its definition

procedure
(newline) → void

Prints a newline.

procedure
(pretty-print x) → void
x : any

Pretty prints S-expressions (like write).

> (pretty-print '((1 2 3) ((a) ("hello world" #true) (((false "good bye"))))))
((1 2 3) ((a) ("hello world" #t) (((false "good bye")))))
image? is used here before its definition
> (pretty-print (build-list 10 (lambda (i) (build-list 10 (lambda (j) (= i j))))))
((#t #f #f #f #f #f #f #f #f #f)
(#f #t #f #f #f #f #f #f #f #f)
(#f #f #t #f #f #f #f #f #f #f)
(#f #f #f #t #f #f #f #f #f #f)
(#f #f #f #f #t #f #f #f #f #f)
(#f #f #f #f #f #t #f #f #f #f)
(#f #f #f #f #f #f #t #f #f #f)
(#f #f #f #f #f #f #f #t #f #f)
(#f #f #f #f #f #f #f #f #t #f)
(#f #f #f #f #f #f #f #f #f #t))
image? is used here before its definition

procedure
(print x) → void
x : any

Prints the argument as a value.

> (print 10)
10
image? is used here before its definition
> (print "hello")
"hello"
image? is used here before its definition
> (print 'hello)
'hello
image? is used here before its definition

procedure
(printf f x ...) → void
f : string
x : any

Formats the rest of the arguments according to the first argument and print it.

procedure
(read) → sexp

Reads input from the user.

procedure
(with-input-from-file f p) → any
f : string
p : (-> any)

Opens the named input file f and allows p to read from it.

procedure
(with-input-from-string s p) → any
s : string
p : (-> any)

Turns s into input for read operations in p.

> (with-input-from-string "hello" read)
image? is used here before its definition
> (string-length (symbol->string (with-input-from-string "hello" read)))
image? is used here before its definition

procedure
(with-output-to-file f p) → any
f : string
p : (-> any)

Opens the named output file f and allows p to write to it.

procedure
(with-output-to-string p) → any
p : (-> any)

Produces a string from all write/display/print operations in p.

> (with-output-to-string (lambda () (display 10)))
image? is used here before its definition

procedure
(write x) → void
x : any

Prints the argument to stdout (in a traditional style that is somewhere between print and display).

> (write 10)
10
image? is used here before its definition
> (write "hello")
"hello"
image? is used here before its definition
> (write 'hello)
hello
image? is used here before its definition

21 Vectors🔗ℹ

procedure
(build-vector n f) → (vectorof X)
n : nat
f : (nat -> X)

Constructs a vector by applying f to the numbers 0 through (- n 1).

> (build-vector 5 add1)
image? is used here before its definition

procedure
(list->vector l) → (vectorof X)
l : (listof X)

Transforms l into a vector.

> (list->vector (list "hello" "world" "good" "bye"))
image? is used here before its definition

procedure
(make-vector n x) → (vectorof X)
n : number
x : X

Constructs a vector of n copies of x.

> (make-vector 5 0)
image? is used here before its definition

procedure
(vector x ...) → (vector X ...)
x : X

Constructs a vector from the given values.

> (vector 1 2 3 -1 -2 -3)
image? is used here before its definition

procedure
(vector->list v) → (listof X)
v : (vectorof X)

Transforms v into a list.

> (vector->list (vector 'a 'b 'c))
image? is used here before its definition

procedure
(vector-length v) → nat
v : (vector X)

Determines the length of v.

> v
image? is used here before its definition
> (vector-length v)
image? is used here before its definition

procedure
(vector-ref v n) → X
v : (vector X)
n : nat

Extracts the nth element from v.

> v
image? is used here before its definition
> (vector-ref v 3)
image? is used here before its definition

procedure
(vector-set! v n x) → void
  v : (vectorof X)
  n : nat
  x : X

Updates v at position n to be x.

> v
image? is used here before its definition
> (vector-set! v 3 77)
image? is used here before its definition
> v
image? is used here before its definition

procedure
(vector? x) → boolean
x : any

Determines if a value is a vector.

> v
image? is used here before its definition
> (vector? v)
image? is used here before its definition
> (vector? 42)
image? is used here before its definition

22 Boxes🔗ℹ

procedure
(box x) → box?
x : any/c

Constructs a box.

> (box 42)
image? is used here before its definition

procedure
(box? x) → boolean?
x : any/c

Determines if a value is a box.

> b
image? is used here before its definition
> (box? b)
image? is used here before its definition
> (box? 42)
image? is used here before its definition

procedure
(set-box! b x) → void
b : box?
x : any/c

Updates a box.

> b
image? is used here before its definition
> (set-box! b 31)
image? is used here before its definition
> b
image? is used here before its definition

procedure
(unbox b) → any
b : box?

Extracts the boxed value.

> b
image? is used here before its definition
> (unbox b)
image? is used here before its definition

23 Hash Tables🔗ℹ

procedure
(hash-copy h) → hash
h : hash

Copies a hash table.

procedure
(hash-count h) → integer
h : hash

Determines the number of keys mapped by a hash table.

> ish
ffi-lib: could not load foreign library
  path: libfontconfig.so.1
  system error: libfontconfig.so.1: cannot open shared object file: No such file or directory
  context...:
   /home/root/racket/collects/ffi/unsafe/private/ffi-lib.rkt:18:0: get-ffi-lib*
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
   body of top-level
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet: mismatch;
reference to a variable that is uninitialized
  name: cairo-lib
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo-lib.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`
  context...:
   body of "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
   body of top-level
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
image?: undefined;
cannot reference an identifier before its definition
  in module: top-level
  context...:
   eval:3:0
   /home/root/racket/collects/racket/private/more-scheme.rkt:145:2: call-with-break-parameterization
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:921:7
   /home/root/racket/share/pkgs/sandbox-lib/racket/sandbox.rkt:891:2: user-process
instantiate-linklet:mismatch;
reference to a variable that is uninitialized
name: CAIRO_OPERATOR_SOURCE
  exporting instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/unsafe/cairo.rkt"
  importing instance: "/home/root/racket/share/pkgs/draw-lib/racket/draw/private/bitmap.rkt"
  possible reason: modules need to be recompiled because dependencies changed
  possible solution: running `racket -y`, `raco make`, or `raco setup`image? is used here before its definitioncircle:this function is not definedimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definitionimage? is used here before its definition
> (hash-count ish)
image? is used here before its definition

procedure
(hash-eq? h) → boolean
h : hash

Determines if a hash table uses eq? for comparisons.

> hsh
image? is used here before its definition
> (hash-eq? hsh)
image? is used here before its definition
> heq
image? is used here before its definition
> (hash-eq? heq)
image? is used here before its definition

procedure
(hash-equal? h) → boolean
h : hash?

Determines if a hash table uses equal? for comparisons.

> ish
image? is used here before its definition
> (hash-equal? ish)
image? is used here before its definition
> ieq
image? is used here before its definition
> (hash-equal? ieq)
image? is used here before its definition

procedure
(hash-eqv? h) → boolean
h : hash

Determines if a hash table uses eqv? for comparisons.

> heq
image? is used here before its definition
> (hash-eqv? heq)
image? is used here before its definition
> heqv
image? is used here before its definition
> (hash-eqv? heqv)
image? is used here before its definition

procedure
(hash-for-each h f) → void?
h : (hash X Y)
f : (X Y -> any)

Applies a function to each mapping of a hash table for effect only.

> hsh
image? is used here before its definition
> (hash-for-each hsh (lambda (ky vl) (hash-set! hsh ky (+ vl 1))))
image? is used here before its definition
> hsh
image? is used here before its definition

procedure
(hash-has-key? h x) → boolean
h : (hash X Y)
x : X

Determines if a key is associated with a value in a hash table.

> ish
image? is used here before its definition
> (hash-has-key? ish 'b)
image? is used here before its definition
> hsh
image? is used here before its definition
> (hash-has-key? hsh 'd)
image? is used here before its definition

procedure
(hash-map h f) → (listof Z)
h : (hash X Y)
f : (X Y -> Z)

Constructs a new list by applying a function to each mapping of a hash table.

> ish
image? is used here before its definition
> (hash-map ish list)
image? is used here before its definition

procedure
(hash-ref h k) → Y
h : (hash X Y)
k : X

Extracts the value associated with a key from a hash table; the three argument case allows a default value or default value computation.

> hsh
image? is used here before its definition
> (hash-ref hsh 'b)
image? is used here before its definition

procedure
(hash-ref! h k v) → Y
  h : (hash X Y)
  k : X
  v : Y

Extracts the value associated with a key from a mutable hash table; if the key does not have an mapping, the third argument is used as the value (or used to compute the value) and is added to the hash table associated with the key.

> hsh
image? is used here before its definition
> (hash-ref! hsh 'd 99)
image? is used here before its definition
> hsh
image? is used here before its definition

procedure
(hash-remove h k) → (hash X Y)
h : (hash X Y)
k : X

Constructs an immutable hash table with one less mapping than an existing immutable hash table.

> ish
image? is used here before its definition
> (hash-remove ish 'b)
image? is used here before its definition

procedure
(hash-remove! h x) → void
h : (hash X Y)
x : X

Removes an mapping from a mutable hash table.

> hsh
image? is used here before its definition
> (hash-remove! hsh 'r)
image? is used here before its definition
> hsh
image? is used here before its definition

procedure
(hash-set h k v) → (hash X Y)
  h : (hash X Y)
  k : X
  v : Y

Constructs an immutable hash table with one new mapping from an existing immutable hash table.

> (hash-set ish 'a 23)
image? is used here before its definition

procedure
(hash-set! h k v) → void?
  h : (hash X Y)
  k : X
  v : Y

Updates a mutable hash table with a new mapping.

> hsh
image? is used here before its definition
> (hash-set! hsh 'a 23)
image? is used here before its definition
> hsh
image? is used here before its definition

procedure
(hash-update h k f) → (hash X Y)
  h : (hash X Y)
  k : X
  f : (Y -> Y)

Composes hash-ref and hash-set to update an existing mapping; the third argument is used to compute the new mapping value; the fourth argument is used as the third argument to hash-ref.

> (hash-update ish 'b (lambda (old-b) (+ old-b 1)))
image? is used here before its definition

procedure
(hash-update! h k f) → void?
  h : (hash X Y)
  k : X
  f : (Y -> Y)

Composes hash-ref and hash-set! to update an existing mapping; the third argument is used to compute the new mapping value; the fourth argument is used as the third argument to hash-ref.

> hsh
image? is used here before its definition
> (hash-update! hsh 'b (lambda (old-b) (+ old-b 1)))
image? is used here before its definition
> hsh
image? is used here before its definition

procedure
(hash? x) → boolean
x : any

Determines if a value is a hash table.

> ish
image? is used here before its definition
> (hash? ish)
image? is used here before its definition
> (hash? 42)
image? is used here before its definition

procedure
(make-hash) → (hash X Y)

Constructs a mutable hash table from an optional list of mappings that uses equal? for comparisons.

> (make-hash)
image? is used here before its definition
> (make-hash '((b 69) (e 61) (i 999)))
image? is used here before its definition

procedure
(make-hasheq) → (hash X Y)

Constructs a mutable hash table from an optional list of mappings that uses eq? for comparisons.

> (make-hasheq)
image? is used here before its definition
> (make-hasheq '((b 69) (e 61) (i 999)))
image? is used here before its definition

procedure
(make-hasheqv) → (hash X Y)

Constructs a mutable hash table from an optional list of mappings that uses eqv? for comparisons.

> (make-hasheqv)
image? is used here before its definition
> (make-hasheqv '((b 69) (e 61) (i 999)))
image? is used here before its definition

procedure
(make-immutable-hash) → (hash X Y)

Constructs an immutable hash table from an optional list of mappings that uses equal? for comparisons.

> (make-immutable-hash)
image? is used here before its definition
> (make-immutable-hash '((b 69) (e 61) (i 999)))
image? is used here before its definition

procedure
(make-immutable-hasheq) → (hash X Y)

Constructs an immutable hash table from an optional list of mappings that uses eq? for comparisons.

> (make-immutable-hasheq)
image? is used here before its definition
> (make-immutable-hasheq '((b 69) (e 61) (i 999)))
image? is used here before its definition

procedure
(make-immutable-hasheqv) → (hash X Y)

Constructs an immutable hash table from an optional list of mappings that uses eqv? for comparisons.

> (make-immutable-hasheqv)
image? is used here before its definition
> (make-immutable-hasheqv '((b 69) (e 61) (i 999)))
image? is used here before its definition

1	Pre-defined Variables
2	Syntax for DSSL
3	Pre-Defined Functions
4	Numbers: Integers, Rationals, Reals, Complex, Exacts, Inexacts
5	Booleans
6	Symbols
7	Lists
8	Posns
9	Characters
10	Strings
11	Images
12	Misc
13	Signatures
14	Numbers (relaxed conditions)
15	String (relaxed conditions)
16	Posn
17	Higher-Order Functions
18	Numbers (relaxed conditions plus)
19	Higher-Order Functions (with Lambda)
20	Reading and Printing
21	Vectors
22	Boxes
23	Hash Tables