► |  | How to Design Programs Languages

1 | Beginning Student
2 | Beginning Student with List Abbreviations
3 | Intermediate Student
4 | Intermediate Student with Lambda
5 | Advanced Student
| Index

▼ | 5 | Advanced Student

5.1 | define
5.2 | define-struct
5.3 | lambda
5.4 | Function Calls
5.5 | begin
5.6 | begin0
5.7 | set!
5.8 | delay
5.9 | shared
5.10 | let
5.11 | recur
5.12 | case
5.13 | when and unless
5.14 | Primitive Operations
5.15 | Unchanged Forms

On this page:

<
<=
=
>
>=
abs
acos
add1
angle
asin
atan
ceiling
complex?
conjugate
cos
cosh
current-seconds
denominator
e
even?
exact->inexact
exact?
exp
expt
floor
gcd
imag-part
inexact->exact
inexact?
integer->char
integer-sqrt
integer?
lcm
log
magnitude
make-polar
make-rectangular
max
min
modulo
negative?
number->string
number?
numerator
odd?
pi
positive?
quotient
random
rational?
real-part
real?
remainder
round
sgn
sin
sinh
sqr
sqrt
sub1
tan
zero?
boolean=?
boolean?
false?
not
symbol->string
symbol=?
symbol?
append
assoc
assq
caaar
caadr
caar
cadar
cadddr
caddr
cadr
car
cdaar
cdadr
cdar
cddar
cdddr
cddr
cdr
cons
cons?
eighth
empty?
fifth
first
fourth
length
list
list*
list-ref
list?
make-list
member
memq
memv
null
null?
pair?
remove
rest
reverse
second
seventh
sixth
third
make-posn
posn-x
posn-y
posn?
set-posn-x!
set-posn-y!
char->integer
char-alphabetic?
char-ci<=?
char-ci<?
char-ci=?
char-ci>=?
char-ci>?
char-downcase
char-lower-case?
char-numeric?
char-upcase
char-upper-case?
char-whitespace?
char<=?
char<?
char=?
char>=?
char>?
char?
explode
format
implode
int->string
list->string
make-string
replicate
string
string->int
string->list
string->number
string->symbol
string-alphabetic?
string-append
string-ci<=?
string-ci<?
string-ci=?
string-ci>=?
string-ci>?
string-copy
string-ith
string-length
string-lower-case?
string-numeric?
string-ref
string-upper-case?
string-whitespace?
string<=?
string<?
string=?
string>=?
string>?
string?
substring
image=?
image?
=~
current-milliseconds
eof
eof-object?
eq?
equal?
equal~?
eqv?
error
exit
force
gensym
identity
promise?
sleep
struct?
void
void?
*
+
-
/
andmap
apply
argmax
argmin
build-list
build-string
compose
filter
foldl
foldr
for-each
map
memf
ormap
procedure?
quicksort
sort
display
newline
pretty-print
print
printf
read
with-input-from-file
with-input-from-string
with-output-to-file
with-output-to-string
write
build-vector
make-vector
vector
vector-length
vector-ref
vector-set!
vector?
box
box?
set-box!
unbox

top ← prev up next →

#### 5.14`` Primitive Operations

< : (real real real ... -> boolean)

Purpose: to compare real numbers for less-than

<= : (real real real ... -> boolean)

Purpose: to compare real numbers for less-than or equality

= : (number number number ... -> boolean)

Purpose: to compare numbers for equality

> : (real real real ... -> boolean)

Purpose: to compare real numbers for greater-than

>= : (real real ... -> boolean)

Purpose: to compare real numbers for greater-than or equality

abs : (real -> real)

Purpose: to compute the absolute value of a real number

acos : (number -> number)

Purpose: to compute the arccosine (inverse of cos) of a number

add1 : (number -> number)

Purpose: to compute a number one larger than a given number

angle : (number -> real)

Purpose: to extract the angle from a complex number

asin : (number -> number)

Purpose: to compute the arcsine (inverse of sin) of a number

atan : (number -> number)

Purpose: to compute the arctan (inverse of tan) of a number

ceiling : (real -> integer)

Purpose: to determine the closest integer (exact or inexact) above a real number

complex? : (any -> boolean)

Purpose: to determine whether some value is complex

conjugate : (number -> number)

Purpose: to compute the conjugate of a complex number

cos : (number -> number)

Purpose: to compute the cosine of a number (radians)

cosh : (number -> number)

Purpose: to compute the hyperbolic cosine of a number

current-seconds : (-> integer)

Purpose: to compute the current time in seconds elapsed (since a platform-specific starting date)

denominator : (rat -> integer)

Purpose: to compute the denominator of a rational

e : real

Purpose: Euler’s number

even? : (integer -> boolean)

Purpose: to determine if some integer (exact or inexact) is even or not

exact->inexact : (number -> number)

Purpose: to convert an exact number to an inexact one

exact? : (number -> boolean)

Purpose: to determine whether some number is exact

exp : (number -> number)

Purpose: to compute e raised to a number

expt : (number number -> number)

Purpose: to compute the power of the first to the second number

floor : (real -> integer)

Purpose: to determine the closest integer (exact or inexact) below a real number

gcd : (integer integer ... -> integer)

Purpose: to compute the greatest common divisior of two integers (exact or inexact)

imag-part : (number -> real)

Purpose: to extract the imaginary part from a complex number

inexact->exact : (number -> number)

Purpose: to approximate an inexact number by an exact one

inexact? : (number -> boolean)

Purpose: to determine whether some number is inexact

integer->char : (integer -> char)

Purpose: to lookup the character that corresponds to the given integer (exact only!) in the ASCII table (if any)

integer-sqrt : (number -> integer)

Purpose: to compute the integer (exact or inexact) square root of a number

integer? : (any -> boolean)

Purpose: to determine whether some value is an integer (exact or inexact)

lcm : (integer integer ... -> integer)

Purpose: to compute the least common multiple of two integers (exact or inexact)

log : (number -> number)

Purpose: to compute the base-e logarithm of a number

magnitude : (number -> real)

Purpose: to determine the magnitude of a complex number

make-polar : (real real -> number)

Purpose: to create a complex from a magnitude and angle

make-rectangular : (real real -> number)

Purpose: to create a complex from a real and an imaginary part

max : (real real ... -> real)

Purpose: to determine the largest number

min : (real real ... -> real)

Purpose: to determine the smallest number

modulo : (integer integer -> integer)

Purpose: to find the remainder of the division of the first number by the second; try (modulo 4 3) (modulo 4 -3)

negative? : (number -> boolean)

Purpose: to determine if some value is strictly smaller than zero

number->string : (number -> string)

Purpose: to convert a number to a string

number? : (any -> boolean)

Purpose: to determine whether some value is a number

numerator : (rat -> integer)

Purpose: to compute the numerator of a rational

odd? : (integer -> boolean)

Purpose: to determine if some integer (exact or inexact) is odd or not

pi : real

Purpose: the ratio of a circle’s circumference to its diameter

positive? : (number -> boolean)

Purpose: to determine if some value is strictly larger than zero

quotient : (integer integer -> integer)

Purpose: to divide the first integer (exact or inexact) into the second; try (quotient 3 4) and (quotient 4 3)

random :

(case->
(integer -> integer)
(-> (and/c real inexact? (>/c 0) (</c 1))))

Purpose: to generate a random natural number less than some given integer, or to generate a random inexact number between 0.0 and 1.0 exclusive

rational? : (any -> boolean)

Purpose: to determine whether some value is a rational number

real-part : (number -> real)

Purpose: to extract the real part from a complex number

real? : (any -> boolean)

Purpose: to determine whether some value is a real number

remainder : (integer integer -> integer)

Purpose: to determine the remainder of dividing the first by the second integer (exact or inexact)

round : (real -> integer)

Purpose: to round a real number to an integer (rounds to even to break ties)

sgn : (real -> (union 1 1.0 0 0.0 -1 -1.0))

Purpose: to compute the sign of a real number

sin : (number -> number)

Purpose: to compute the sine of a number (radians)

sinh : (number -> number)

Purpose: to compute the hyperbolic sine of a number

sqr : (number -> number)

Purpose: to compute the square of a number

sqrt : (number -> number)

Purpose: to compute the square root of a number

sub1 : (number -> number)

Purpose: to compute a number one smaller than a given number

tan : (number -> number)

Purpose: to compute the tangent of a number (radians)

zero? : (number -> boolean)

Purpose: to determine if some value is zero or not

boolean=? : (boolean boolean -> boolean)

Purpose: to determine whether two booleans are equal

boolean? : (any -> boolean)

Purpose: to determine whether some value is a boolean

false? : (any -> boolean)

Purpose: to determine whether a value is false

not : (boolean -> boolean)

Purpose: to compute the negation of a boolean value

symbol->string : (symbol -> string)

Purpose: to convert a symbol to a string

symbol=? : (symbol symbol -> boolean)

Purpose: to determine whether two symbols are equal

symbol? : (any -> boolean)

Purpose: to determine whether some value is a symbol

append : ((listof any) ... -> (listof any))

Purpose: to create a single list from several

assoc : (any (listof any) -> (listof any) or false)

Purpose: to produce the first element on the list whose first is equal? to v; otherwise it produces false

assq :

(X
(listof (cons X Y))
->
(union false (cons X Y)))

Purpose: to determine whether some item is the first item of a pair in a list of pairs

caaar :

((cons
(cons (cons W (listof Z)) (listof Y))
(listof X))
->
W)

Purpose: to select the first item of the first list in the first list of a list

caadr :

((cons
(cons (cons W (listof Z)) (listof Y))
(listof X))
->
(listof Z))

Purpose: to select the rest of the first list in the first list of a list

caar : ((cons (cons Z (listof Y)) (listof X)) -> Z)

Purpose: to select the first item of the first list in a list

cadar :

((cons (cons W (cons Z (listof Y))) (listof X))
->
Z)

Purpose: to select the second item of the first list of a list

cadddr : ((listof Y) -> Y)

Purpose: to select the fourth item of a non-empty list

caddr : ((cons W (cons Z (cons Y (listof X)))) -> Y)

Purpose: to select the third item of a non-empty list

cadr : ((cons Z (cons Y (listof X))) -> Y)

Purpose: to select the second item of a non-empty list

car : ((cons Y (listof X)) -> Y)

Purpose: to select the first item of a non-empty list

cdaar :

((cons
(cons (cons W (listof Z)) (listof Y))
(listof X))
->
(listof Z))

Purpose: to select the rest of the first list in the first list of a list

cdadr :

((cons W (cons (cons Z (listof Y)) (listof X)))
->
(listof Y))

Purpose: to select the rest of the first list in the rest of a list

cdar :

((cons (cons Z (listof Y)) (listof X))
->
(listof Y))

Purpose: to select the rest of a non-empty list in a list

cddar :

((cons (cons W (cons Z (listof Y))) (listof X))
->
(listof Y))

Purpose: to select the rest of the rest of the first list of a list

cdddr :

((cons W (cons Z (cons Y (listof X))))
->
(listof X))

Purpose: to select the rest of the rest of the rest of a list

cddr : ((cons Z (cons Y (listof X))) -> (listof X))

Purpose: to select the rest of the rest of a list

cdr : ((cons Y (listof X)) -> (listof X))

Purpose: to select the rest of a non-empty list

cons : (X (listof X) -> (listof X))

Purpose: to construct a list

cons? : (any -> boolean)

Purpose: to determine whether some value is a constructed list

eighth : ((listof Y) -> Y)

Purpose: to select the eighth item of a non-empty list

empty? : (any -> boolean)

Purpose: to determine whether some value is the empty list

fifth : ((listof Y) -> Y)

Purpose: to select the fifth item of a non-empty list

first : ((cons Y (listof X)) -> Y)

Purpose: to select the first item of a non-empty list

fourth : ((listof Y) -> Y)

Purpose: to select the fourth item of a non-empty list

length : ((listof any) -> number)

Purpose: to compute the number of items on a list

list : (any ... -> (listof any))

Purpose: to construct a list of its arguments

list* : (any ... (listof any) -> (listof any))

Purpose: to construct a list by adding multiple items to a list

list-ref : ((listof X) natural-number -> X)

Purpose: to extract the indexed item from the list

list? : (any -> boolean)

Purpose: to determine whether some value is a list

make-list : (natural-number any -> (listof any))

Purpose: (make-list k x) constructs a list of k copies of x

member : (any (listof any) -> boolean)

Purpose: to determine whether some value is on the list (comparing values with equal?)

memq : (any (listof any) -> (union false list))

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

memv : (any (listof any) -> (union false list))

Purpose: to determine 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.)

null : empty

Purpose: the empty list

null? : (any -> boolean)

Purpose: to determine whether some value is the empty list

pair? : (any -> boolean)

Purpose: to determine whether some value is a constructed list

remove : (any (listof any) -> (listof any))

Purpose: to construct a list like the given one with the first occurrence of the given item removed (comparing values with equal?)

rest : ((cons Y (listof X)) -> (listof X))

Purpose: to select the rest of a non-empty list

reverse : ((listof any) -> list)

Purpose: to create a reversed version of a list

second : ((cons Z (cons Y (listof X))) -> Y)

Purpose: to select the second item of a non-empty list

seventh : ((listof Y) -> Y)

Purpose: to select the seventh item of a non-empty list

sixth : ((listof Y) -> Y)

Purpose: to select the sixth item of a non-empty list

third : ((cons W (cons Z (cons Y (listof X)))) -> Y)

Purpose: to select the third item of a non-empty list

make-posn : (number number -> posn)

Purpose: to construct a posn

posn-x : (posn -> number)

Purpose: to extract the x component of a posn

posn-y : (posn -> number)

Purpose: to extract the y component of a posn

posn? : (anything -> boolean)

Purpose: to determine if its input is a posn

set-posn-x! : (posn number -> void)

Purpose: to update the x component of a posn

set-posn-y! : (posn number -> void)

Purpose: to update the x component of a posn

char->integer : (char -> integer)

Purpose: to lookup the number that corresponds to the given character in the ASCII table (if any)

char-alphabetic? : (char -> boolean)

Purpose: to determine whether a character represents an alphabetic character

char-ci<=? : (char char char ... -> boolean)

Purpose: to determine whether a character precedes another (or is equal to it) in a case-insensitive manner

char-ci<? : (char char char ... -> boolean)

Purpose: to determine whether a character precedes another in a case-insensitive manner

char-ci=? : (char char char ... -> boolean)

Purpose: to determine whether two characters are equal in a case-insensitive manner

char-ci>=? : (char char char ... -> boolean)

Purpose: to determine whether a character succeeds another (or is equal to it) in a case-insensitive manner

char-ci>? : (char char char ... -> boolean)

Purpose: to determine whether a character succeeds another in a case-insensitive manner

char-downcase : (char -> char)

Purpose: to determine the equivalent lower-case character

char-lower-case? : (char -> boolean)

Purpose: to determine whether a character is a lower-case character

char-numeric? : (char -> boolean)

Purpose: to determine whether a character represents a digit

char-upcase : (char -> char)

Purpose: to determine the equivalent upper-case character

char-upper-case? : (char -> boolean)

Purpose: to determine whether a character is an upper-case character

char-whitespace? : (char -> boolean)

Purpose: to determine whether a character represents space

char<=? : (char char char ... -> boolean)

Purpose: to determine whether a character precedes another (or is equal to it)

char<? : (char char char ... -> boolean)

Purpose: to determine whether a character precedes another

char=? : (char char char ... -> boolean)

Purpose: to determine whether two characters are equal

char>=? : (char char char ... -> boolean)

Purpose: to determine whether a character succeeds another (or is equal to it)

char>? : (char char char ... -> boolean)

Purpose: to determine whether a character succeeds another

char? : (any -> boolean)

Purpose: to determine whether a value is a character

explode : (string -> (listof string))

Purpose: to translate a string into a list of 1-letter strings

format : (string any ... -> string)

Purpose: to format a string, possibly embedding values

implode : ((listof string) -> string)

Purpose: to concatenate the list of 1-letter strings into one string

int->string : (integer -> string)

Purpose: to convert an integer in [0,55295] or [57344 1114111] to a 1-letter string

list->string : ((listof char) -> string)

Purpose: to convert a s list of characters into a string

make-string : (nat char -> string)

Purpose: to produce a string of given length from a single given character

replicate : (nat string -> string)

Purpose: to replicate the given string

string : (char ... -> string)

Purpose: (string c1 c2 ...) builds a string

string->int : (string -> integer)

Purpose: to convert a 1-letter string to an integer in [0,55295] or [57344, 1114111]

string->list : (string -> (listof char))

Purpose: to convert a string into a list of characters

string->number : (string -> (union number false))

Purpose: to convert a string into a number, produce false if impossible

string->symbol : (string -> symbol)

Purpose: to convert a string into a symbol

string-alphabetic? : (string -> boolean)

Purpose: to determine whether all ’letters’ in the string are alphabetic

string-append : (string ... -> string)

Purpose: to juxtapose the characters of several strings

string-ci<=? : (string string string ... -> boolean)

Purpose: to determine whether one string alphabetically precedes another (or is equal to it) in a case-insensitive manner

string-ci<? : (string string string ... -> boolean)

Purpose: to determine whether one string alphabetically precedes another in a case-insensitive manner

string-ci=? : (string string string ... -> boolean)

Purpose: to compare two strings character-wise in a case-insensitive manner

string-ci>=? : (string string string ... -> boolean)

Purpose: to determine whether one string alphabetically succeeds another (or is equal to it) in a case-insensitive manner

string-ci>? : (string string string ... -> boolean)

Purpose: to determine whether one string alphabetically succeeds another in a case-insensitive manner

string-copy : (string -> string)

Purpose: to copy a string

string-ith : (string nat -> string)

Purpose: to extract the ith 1-letter substring from the given one

string-length : (string -> nat)

Purpose: to determine the length of a string

string-lower-case? : (string -> boolean)

Purpose: to determine whether all ’letters’ in the string are lower case

string-numeric? : (string -> boolean)

Purpose: to determine whether all ’letters’ in the string are numeric

string-ref : (string nat -> char)

Purpose: to extract the i-the character from a string

string-upper-case? : (string -> boolean)

Purpose: to determine whether all ’letters’ in the string are upper case

string-whitespace? : (string -> boolean)

Purpose: to determine whether all ’letters’ in the string are white space

string<=? : (string string string ... -> boolean)

Purpose: to determine whether one string alphabetically precedes another (or is equal to it)

string<? : (string string string ... -> boolean)

Purpose: to determine whether one string alphabetically precedes another

string=? : (string string string ... -> boolean)

Purpose: to compare two strings character-wise

string>=? : (string string string ... -> boolean)

Purpose: to determine whether one string alphabetically succeeds another (or is equal to it)

string>? : (string string string ... -> boolean)

Purpose: to determine whether one string alphabetically succeeds another

string? : (any -> boolean)

Purpose: to determine whether a value is a string

substring : (string nat nat -> string)

Purpose: to extract the substring starting at a 0-based index up to the second 0-based index (exclusive)

image=? : (image image -> boolean)

Purpose: to determine whether two images are equal

image? : (any -> boolean)

Purpose: to determine whether a value is an image

=~ : (real real non-negative-real -> boolean)

Purpose: to check whether two real numbers are within some amount (the third argument) of either other

current-milliseconds : (-> exact-integer)

Purpose: to return the current “time” in fixnum milliseconds (possibly negative)

eof : eof

Purpose: the end-of-file value

eof-object? : (any -> boolean)

Purpose: to determine whether some value is the end-of-file value

eq? : (any any -> boolean)

Purpose: to determine whether two values are equivalent from the computer’s perspective (intensional)

equal? : (any any -> boolean)

Purpose: to determine whether two values are structurally equal where basic values are compared with the eqv? predicate

equal~? : (any any non-negative-real -> boolean)

Purpose: to compare like equal? on the first two arguments, except using =~ in the case of real numbers

eqv? : (any any -> boolean)

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

error : (any ... -> void)

Purpose: to signal an error, turning the given values into an error message

exit : (-> void)

Purpose: to exit the running program

force : (delay -> any)

Purpose: to find the delayed value; see also delay

gensym : (-> symbol?)

Purpose: to generate a new symbol, different from all symbols in the program

identity : (any -> any)

Purpose: to return the argument unchanged

promise? : (any -> boolean)

Purpose: to determine if a value is delayed

sleep : (-> positive-number void)

Purpose: to cause the program to sleep for the given number of seconds

struct? : (any -> boolean)

Purpose: to determine whether some value is a structure

void : (-> void)

Purpose: produces a void value

void? : (any -> boolean)

Purpose: to determine if a value is void

* : (number ... -> number)

Purpose: to multiply all given numbers

+ : (number ... -> number)

Purpose: to add all given numbers

- : (number ... -> number)

Purpose: to subtract from the first all remaining numbers

/ : (number ... -> number)

Purpose: to divide the first by all remaining numbers

andmap : ((X -> boolean) (listof X) -> boolean)

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

apply :

((X-1 ... X-N -> Y)
X-1
...
X-i
(list X-i+1 ... X-N)
->
Y)

Purpose: to apply a function using items from a list as the arguments

argmax : ((X -> real) (listof X) -> X)

Purpose: to find the (first) element of the list that maximizes the output of the function

argmin : ((X -> real) (listof X) -> X)

Purpose: to find the (first) element of the list that minimizes the output of the function

build-list : (nat (nat -> X) -> (listof X))

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

build-string : (nat (nat -> char) -> string)

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

compose :

((Y-1 -> Z)
...
(Y-N -> Y-N-1)
(X-1 ... X-N -> Y-N)
->
(X-1 ... X-N -> Z))

Purpose: to compose a sequence of procedures into a single procedure

filter : ((X -> boolean) (listof X) -> (listof X))

Purpose: to construct a list from all those items on a list for which the predicate holds

foldl : ((X Y -> Y) Y (listof X) -> Y)

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

foldr : ((X Y -> Y) Y (listof X) -> Y)

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

for-each : ((any ... -> any) (listof any) ... -> void)

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

map : ((X ... -> Z) (listof X) ... -> (listof Z))

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

memf :

((X -> boolean)
(listof X)
->
(union false (listof X)))

Purpose: to determine whether the first argument produces true for some value in the second argument

ormap : ((X -> boolean) (listof X) -> boolean)

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

procedure? : (any -> boolean)

Purpose: to determine if a value is a procedure

quicksort : ((listof X) (X X -> boolean) -> (listof X))

Purpose: to construct a list from all items on a list in an order according to a predicate

sort : ((listof X) (X X -> boolean) -> (listof X))

Purpose: to construct a list from all items on a list in an order according to a predicate

display : (any -> void)

Purpose: to print the argument to stdout (without quotes on symbols and strings, etc.)

newline : (-> void)

Purpose: to print a newline to stdout

pretty-print : (any -> void)

Purpose: like write, but with standard newlines and indentation

print : (any -> void)

Purpose: to print the argument as a value to stdout

printf : (string any ... -> void)

Purpose: to format the rest of the arguments according to the first argument and print it to stdout

read : (-> sexp)

Purpose: to read input from the user

with-input-from-file : (string (-> any) -> any)

Purpose: to open the named input file and to extract all input from there

with-input-from-string : (string (-> any) -> any)

Purpose: to turn the given string into input for read* operations

with-output-to-file : (string (-> any) -> any)

Purpose: to open the named output file and to put all output there

with-output-to-string : (string (-> any) -> any)

Purpose: to produce a string from all write/display/print operations

write : (any -> void)

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

build-vector : (nat (nat -> X) -> (vectorof X))

Purpose: to construct a vector

make-vector : (number X -> (vectorof X))

Purpose: to construct a vector

vector : (X ... -> (vector X ...))

Purpose: to construct a vector

vector-length : ((vector X) -> nat)

Purpose: to determine the length of a vector

vector-ref : ((vector X) nat -> X)

Purpose: to extract an element from a vector

vector-set! : ((vectorof X) nat X -> void)

Purpose: to update a vector

vector? : (any -> boolean)

Purpose: to determine if a value is a vector

box : (any -> box)

Purpose: to construct a box

box? : (any -> boolean)

Purpose: to determine if a value is a box

set-box! : (box any -> void)

Purpose: to update a box

unbox : (box -> any)

Purpose: to extract the boxed value
top ← prev up next →