3 Intermediate Student

▼ |  | 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

► | 3 | Intermediate Student

3.1 | Pre-Defined Variables
3.2 | Template Variables
3.3 | Syntax for Intermediate
3.4 | Common Syntaxes
3.5 | Pre-defined Functions

On this page:

3.1`` Pre-Defined Variables
empty
true
false
3.2`` Template Variables
..
...
....
.....
......
3.3`` Syntax for Intermediate
local
letrec
let*
let
time
3.4`` Common Syntaxes
quote
quasiquote
unquote
unquote-splicing
define
lambda
define-struct
cond
else
if
and
or
check-expect
check-within
check-error
check-member-of
check-range
require
3.5`` Pre-defined Functions
3.5.1`` Numbers: Integers, Rationals, Reals, Complex, Exacts, Inexacts
-
<
<=
=
>
>=
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?
3.5.2`` Booleans
boolean=?
boolean?
false?
not
3.5.3`` Symbols
symbol->string
symbol=?
symbol?
3.5.4`` Lists
append
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
make-list
member
member?
memq
memq?
memv
null
null?
range
remove
rest
reverse
second
seventh
sixth
third
3.5.5`` Posns
make-posn
posn
posn-x
posn-y
posn?
3.5.6`` Characters
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?
3.5.7`` Strings
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-contains?
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
3.5.8`` Images
image=?
image?
3.5.9`` Misc
=~
eof
eof-object?
eq?
equal?
equal~?
eqv?
error
exit
identity
struct?
3.5.10`` Numbers (relaxed conditions)
*
+
/
3.5.11`` Higher-Order Functions
andmap
apply
argmax
argmin
build-list
build-string
compose
filter
foldl
foldr
for-each
map
memf
ormap
procedure?
quicksort
sort

top ← prev up next →

### 3`` Intermediate Student

program |  | = |  | def-or-expr ...
def-or-expr |  | = |  | definition
|  | | |  | expr
|  | | |  | test-case
|  | | |  | library-require
definition |  | = |  | (define (name variable variable ...) expr)
|  | | |  | (define name expr)
|  | | |  | (define name (lambda (variable variable ...) expr))
|  | | |  | (define-struct name (name ...))
expr |  | = |  | (local [definition ...] expr)
|  | | |  | (letrec ([name expr-for-let] ...) expr)
|  | | |  | (let ([name expr-for-let] ...) expr)
|  | | |  | (let* ([name expr-for-let] ...) expr)
|  | | |  | (name expr expr ...)
|  | | |  | (cond [expr expr] ... [expr expr])
|  | | |  | (cond [expr expr] ... [else expr])
|  | | |  | (if expr expr expr)
|  | | |  | (and expr expr expr ...)
|  | | |  | (or expr expr expr ...)
|  | | |  | (time expr)
|  | | |  | name
|  | | |  | ’quoted
|  | | |  | ‘quasiquoted
|  | | |  | number
|  | | |  | boolean
|  | | |  | string
|  | | |  | character
expr-for-let |  | = |  | (lambda (variable variable ...) expr)
|  | | |  | expr
quoted |  | = |  | name
|  | | |  | number
|  | | |  | string
|  | | |  | character
|  | | |  | (quoted ...)
|  | | |  | ’quoted
|  | | |  | ‘quoted
|  | | |  | ,quoted
|  | | |  | ,@quoted
quasiquoted |  | = |  | name
|  | | |  | number
|  | | |  | string
|  | | |  | character
|  | | |  | (quasiquoted ...)
|  | | |  | ’quasiquoted
|  | | |  | ‘quasiquoted
|  | | |  | ,expr
|  | | |  | ,@expr
test-case |  | = |  | (check-expect expr expr)
|  | | |  | (check-within expr expr expr)
|  | | |  | (check-member-of expr expr ...)
|  | | |  | (check-range expr expr expr)
|  | | |  | (check-error expr expr)
|  | | |  | (check-error expr)
library-require |  | = |  | (require string)
|  | | |  | (require (lib string string ...))
|  | | |  | (require (planet string package))
package |  | = |  | (string string number number)

An 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, false, #t, #f, #true, or #false.
A symbol is a quote character followed by a name. A symbol is a value, just like 0 or empty.
A string is 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 immediatly after the open parenthesis can be any functions defined with define or define-struct, or any one of the pre-defined functions.

#### 3.1`` Pre-Defined Variables

> value empty : empty?

The empty list.

> value true : boolean?

The true value.

> value false : boolean?

The false value.

#### 3.2`` Template Variables

> syntax ..

A placeholder for indicating that a definition is a template.

> syntax ...

A placeholder for indicating that a definition is a template.

> syntax ....

A placeholder for indicating that a definition is a template.

> syntax .....

A placeholder for indicating that a definition is a template.

> syntax ......

A placeholder for indicating that a definition is a template.

#### 3.3`` Syntax for Intermediate

> 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.

#### 3.4`` Common Syntaxes

The following syntaxes behave the same in the Intermediate level as they did in the Beginning Student with List Abbreviations level.

> syntax ’name
> syntax ’part
> syntax (quote name)
> syntax (quote part)

A quoted name is a symbol. A quoted part is an abbreviation for a nested lists.

Normally, this quotation is written with a ', like '(apple banana), but it can also be written with quote, like (quote (apple banana)).

> syntax ‘name
> syntax ‘part
> syntax (quasiquote name)
> syntax (quasiquote part)

Like quote, but also allows escaping to expression “unquotes.”

Normally, quasi-quotations are written with a backquote, `, like `(apple ,(+ 1 2)), but they can also be written with quasiquote, like (quasiquote-elem (apple ,(+ 1 2))).

> syntax ,expression
> syntax (unquote expression)

Under a single quasiquote, ,expression escapes from the quote to include an evaluated expression whose result is inserted into the abbreviated list.

Under multiple quasiquotes, ,expression is really the literal ,expression, decrementing the quasiquote count by one for expression.

Normally, an unquote is written with ,, but it can also be written with unquote.

> syntax ,@expression
> syntax (unquote-splicing expression)

Under a single quasiquote, ,@expression escapes from the quote to include an evaluated expression whose result is a list to splice into the abbreviated list.

Under multiple quasiquotes, a splicing unquote is like an unquote; that is, it decrements the quasiquote count by one.

Normally, a splicing unquote is written with ,, but it can also be written with unquote-splicing.

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

Defines a function named name. The expression is 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 that new expression.

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 name’s cannot be the same as that of another function or variable, and name itself must not appear in expression.

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

An alternate way on defining functions. The name is the name of the function, which cannot be the same as that of another function or variable.

A lambda cannot be used outside of this alternate syntax.

> 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.

> syntax (name expression expression ...)

Calls the function named name. The value of the call is the value of name’s body when every one of the function’s variables are replaced by the values of the corresponding expressions.

The function named name must defined before it can be called. The number of argument expressions must be the same as the number of arguments expected by the function.

> 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.

> 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.

It is an error for expressions or expected-expression to produce a function value.

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.

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

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

> 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.

> syntax (require string)

Makes the definitions of the module specified by string available in the current module (i.e., the current file), where string refers to a file relative to the current file.

The string is constrained in several ways to avoid problems with different path conventions on different platforms: a / is a directory separator, . always means the current directory, .. always means the parent directory, path elements can use only a through z (uppercase or lowercase), 0 through 9, -, _, and ., and the string cannot be empty or contain a leading or trailing /.

> syntax (require module-name)

Accesses a file in an installed library. The library name is an identifier with the same constraints as for a relative-path string (though without the quotes), with the additional constraint that it must not contain a ..

> syntax (require (lib string string ...))

Accesses a file in an installed library, making its definitions available in the current module (i.e., the current file). The first string names the library file, and the remaining strings name the collection (and sub-collection, and so on) where the file is installed. Each string is constrained in the same way as for the (require string) form.

> syntax (require (planet string (string string number number)))
> syntax (require (planet id))
> syntax (require (planet string))

Accesses a library that is distributed on the internet via the PLaneT server, making it definitions available in the current module (i.e., current file).

The full grammar for planet requires is given in Importing and Exporting: require and provide, but the best place to find examples of the syntax is on the the PLaneT server, in the description of a specific package.

#### 3.5`` Pre-defined Functions

##### 3.5.1`` 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)
> -5
> > (- 5 3)
> 2
> > (- 5 3 1)
> 1

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

Compares (real) numbers for less-than.

> > (< 42 2/5)
> false

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

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

> > (<= 42 2/5)
> false

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

Compares numbers for equality.

> > (= 42 2/5)
> false

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

Compares (real) numbers for greater-than.

> > (> 42 2/5)
> true

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

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

> > (>= 42 42)
> true

> procedure (abs x) → real
> x : real

Determines the absolute value of a real number.

> > (abs -12)
> 12

> procedure (acos x) → number
> x : number

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

> > (acos 0)
> #i1.5707963267948966

> procedure (add1 x) → number
> x : number

Incrementes the given number.

> > (add1 2)
> 3

> procedure (angle x) → real
> x : number

Extracts the angle from a complex number.

> > (angle (make-polar 3 4))
> #i-2.2831853071795867

> procedure (asin x) → number
> x : number

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

> > (asin 0)
> 0

> procedure (atan x y) → number
> x : number
> y : number

Computes the arctan of the given number or the ratio of the two given numbers.

> > (atan 0)
> 0
> > (atan 3 4)
> #i0.6435011087932844

> procedure (ceiling x) → integer
> x : real

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

> > (ceiling 12.3)
> #i13.0

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

Determines whether some value is complex.

> > (real? 1-2i)
> false

> procedure (conjugate x) → number
> x : number

Extracts the conjugate of a complex number.

> > (conjugate (make-polar 3 4))
> #i-1.960930862590836+2.2704074859237844i

> procedure (cos x) → number
> x : number

Computes the cosine of a number (radians).

> > (cos pi)
> #i-1.0

> procedure (cosh x) → number
> x : number

Computes the hyperbolic cosine of a number.

> > (cosh 10)
> #i11013.232920103324

> procedure (current-seconds) → integer

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

> > (current-seconds)
> 1393986937

> procedure (denominator x) → integer
> x : rational?

Computees the denominator of a rational.

> > (denominator 2/3)
> 3

> value e : real

Euler’s number.

> > e
> #i2.718281828459045

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

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

> > (even? 2)
> true

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

Converts an exact number to an inexact one.

> > (exact->inexact 12)
> #i12.0

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

Determines whether some number is exact.

> > (exact? (sqrt 2))
> false

> procedure (exp x) → number
> x : number

Determines e raised to a number.

> > (exp -2)
> #i0.1353352832366127

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

Computes the power of the first to the second number.

> > (expt 16 1/2)
> 4
> > (expt 3 -4)
> 1/81

> procedure (floor x) → integer
> x : real

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

> > (floor 12.3)
> #i12.0

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

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

> > (gcd 6 12 8)
> 2

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

Extracts the imaginary part from a complex number.

> > (imag-part 3+4i)
> 4

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

Approximates an inexact number by an exact one.

> > (inexact->exact 12.0)
> 12

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

Determines whether some number is inexact.

> > (inexact? 1-2i)
> false

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

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

> > (integer->char 42)
> #\*

> procedure (integer-sqrt x) → integer
> x : number

Computes the integer (exact or inexact) square root of a number.

> > (sqrt 11)
> #i3.3166247903554

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

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

> > (integer? (sqrt 2))
> false

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

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

> > (lcm 6 12 8)
> 24

> procedure (log x) → number
> x : number

Determines the base-e logarithm of a number.

> > (log 12)
> #i2.4849066497880004

> procedure (magnitude x) → real
> x : number

Determines the magnitude of a complex number.

> > (magnitude (make-polar 3 4))
> #i3.0

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

Creates a complex from a magnitude and angle.

> > (make-polar 3 4)
> #i-1.960930862590836-2.2704074859237844i

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

Creates a complex from a real and an imaginary part.

> > (make-rectangular 3 4)
> 3+4i

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

Determines the largest number—aka, the maxiumum.

> > (max 3 2 8 7 2 9 0)
> 9

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

Determines the smallest number—aka, the miniumum.

> > (min 3 2 8 7 2 9 0)
> 0

> 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)
> 1
> > (modulo 3 -4)
> -1

> procedure (negative? x) → boolean?
> x : number

Determines if some value is strictly smaller than zero.

> > (negative? -2)
> true

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

Converts a number to a string.

> > (number->string 42)
> "42"

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

Determines whether some value is a number:

> > (number? "hello world")
> false
> > (number? 42)
> true

> procedure (numerator x) → integer
> x : rational?

Computes the numerator of a rational.

> > (numerator 2/3)
> 2

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

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

> > (odd? 2)
> false

> value pi : real

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

> > pi
> #i3.141592653589793

> procedure (positive? x) → boolean?
> x : number

Determines if some value is strictly larger than zero.

> > (positive? -2)
> false

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

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

> > (quotient 9 2)
> 4
> > (quotient 3 4)
> 0

> procedure (random x) → integer
> x : integer

Generates a random natural number less than some given exact integer.

> > (random 42)
> 8

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

Determines whether some value is a rational number.

> > (rational? 1-2i)
> false

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

Extracts the real part from a complex number.

> > (real-part 3+4i)
> 3

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

Determines whether some value is a real number.

> > (real? 1-2i)
> false

> 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)
> 1
> > (remainder 3 4)
> 3

> 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)
> #i12.0

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

Determines the sign of a real number.

> > (sgn -12)
> -1

> procedure (sin x) → number
> x : number

Computes the sine of a number (radians).

> > (sin pi)
> #i1.2246063538223773e-16

> procedure (sinh x) → number
> x : number

Computes the hyperbolic sine of a number.

> > (sinh 10)
> #i11013.232874703393

> procedure (sqr x) → number
> x : number

Computes the square of a number.

> > (sqr 8)
> 64

> procedure (sqrt x) → number
> x : number

Computes the square root of a number.

> > (sqrt 9)
> 3
> > (sqrt 2)
> #i1.4142135623730951

> procedure (sub1 x) → number
> x : number

Decrements the given number.

> > (sub1 2)
> 1

> procedure (tan x) → number
> x : number

Computes the tangent of a number (radians).

> > (tan pi)
> #i-1.2246063538223773e-16

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

Determines if some value is zero or not.

> > (zero? 2)
> false

##### 3.5.2`` Booleans

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

Determines whether two booleans are equal.

> > (boolean=? true false)
> false

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

Determines whether some value is a boolean.

> > (boolean? 42)
> false
> > (boolean? false)
> true

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

Determines whether a value is false.

> > (false? false)
> true

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

Negates a boolean value.

> > (not false)
> true

##### 3.5.3`` Symbols

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

Converts a symbol to a string.

> > (symbol->string 'c)
> "c"

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

Determines whether two symbols are equal.

> > (symbol=? 'a 'b)
> false

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

Determines whether some value is a symbol.

> > (symbol? 'a)
> true

##### 3.5.4`` Lists

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

Creates a single list from several, by juxtaposition of the items. In ISL and up: append also works when applied to one list or none.

> > (append (cons 1 (cons 2 empty)) (cons "a" (cons "b" empty)))
> (list 1 2 "a" "b")
> > (append)
> empty

> 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
> (list (list 'a 22) (list 'b 8) (list 'c 70))
> > (assq 'b a)
> (list 'b 8)

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

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

> > w
> (list (list (list (list "bye") 3) true) 42)
> > (caaar w)
> (list "bye")

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

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

> > z
> (list (list (list (list 'a 'b) 2 3)) (list false true) "world")
> > (caadr z)
> false

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

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

> > y
> (list (list (list 1 2 3) false "world"))
> > (caar y)
> (list 1 2 3)

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

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

> > w
> (list (list (list (list "bye") 3) true) 42)
> > (cadar w)
> true

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

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

> > v
> (list 1 2 3 4 5 6 7 8 9 'A)
> > (cadddr v)
> 4

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

LISP-style selector: (caddr x).

> > x
> (list 2 "hello" true)
> > (caddr x)
> true

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

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

> > x
> (list 2 "hello" true)
> > (cadr x)
> "hello"

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

Selects the first item of a non-empty list.

> > x
> (list 2 "hello" true)
> > (car x)
> 2

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

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

> > w
> (list (list (list (list "bye") 3) true) 42)
> > (cdaar w)
> (list 3)

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

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

> > z
> (list (list (list (list 'a 'b) 2 3)) (list false true) "world")
> > (cdadr z)
> (list true)

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

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

> > y
> (list (list (list 1 2 3) false "world"))
> > (cdar y)
> (list false "world")

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

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

> > w
> (list (list (list (list "bye") 3) true) 42)
> > (cddar w)
> empty

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

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

> > v
> (list 1 2 3 4 5 6 7 8 9 'A)
> > (cdddr v)
> (list 4 5 6 7 8 9 'A)

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

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

> > x
> (list 2 "hello" true)
> > (cddr x)
> (list true)

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

Selects the rest of a non-empty list.

> > x
> (list 2 "hello" true)
> > (cdr x)
> (list "hello" true)

> procedure (cons x y) → list?
> x : any/x
> y : list?

Constructs a list.

> > (cons 1 empty)
> (cons 1 empty)

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

Determines whether some value is a constructed list.

> > (cons? (cons 1 empty))
> true
> > (cons? 42)
> false

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

Selects the eighth item of a non-empty list.

> > v
> (list 1 2 3 4 5 6 7 8 9 'A)
> > (eighth v)
> 8

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

Determines whether some value is the empty list.

> > (empty? empty)
> true
> > (empty? 42)
> false

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

Selects the fifth item of a non-empty list.

> > v
> (list 1 2 3 4 5 6 7 8 9 'A)
> > (fifth v)
> 5

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

Selects the first item of a non-empty list.

> > x
> (list 2 "hello" true)
> > (first x)
> 2

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

Selects the fourth item of a non-empty list.

> > v
> (list 1 2 3 4 5 6 7 8 9 'A)
> > (fourth v)
> 4

> procedure (length l) → natural-number?
> l : list?

Evaluates the number of items on a list.

> > x
> (list 2 "hello" true)
> > (length x)
> 3

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

Constructs a list of its arguments.

> > (list 1 2 3 4 5 6 7 8 9 0)
> (cons
> 1
> (cons
> 2
> (cons
> 3
> (cons
> 4
> (cons
> 5
> (cons 6 (cons 7 (cons 8 (cons 9 (cons 0 empty))))))))))

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

Constructs a list by adding multiple items to a list.

> > x
> (cons 2 (cons "hello" (cons true empty)))
> > (list* 4 3 x)
> (cons 4 (cons 3 (cons 2 (cons "hello" (cons true empty)))))

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

Extracts the indexed item from the list.

> > v
> (list 1 2 3 4 5 6 7 8 9 'A)
> > (list-ref v 9)
> 'A

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

Constructs a list of i copies of x.

> > (make-list 3 "hello")
> (cons "hello" (cons "hello" (cons "hello" empty)))

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

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

> > x
> (list 2 "hello" true)
> > (member "hello" x)
> true

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

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

> > x
> (list 2 "hello" true)
> > (member? "hello" x)
> true

> 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
> (list 2 "hello" true)
> > (memq (list (list 1 2 3)) x)
> false

> 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
> (list 2 "hello" true)
> > (memq? (list (list 1 2 3)) x)
> false

> 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
> (list 2 "hello" true)
> > (memv (list (list 1 2 3)) x)
> false

> value null : list

Another name for the empty list

> > null
> empty

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

Determines whether some value is the empty list.

> > (null? empty)
> true
> > (null? 42)
> false

> 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)
> (cons 0 (cons 2 (cons 4 (cons 6 (cons 8 empty)))))

> 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
> (list 2 "hello" true)
> > (remove "hello" x)
> (list 2 true)

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

Selects the rest of a non-empty list.

> > x
> (list 2 "hello" true)
> > (rest x)
> (list "hello" true)

> procedure (reverse l) → list
> l : list?

Creates a reversed version of a list.

> > x
> (list 2 "hello" true)
> > (reverse x)
> (list true "hello" 2)

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

Selects the second item of a non-empty list.

> > x
> (list 2 "hello" true)
> > (second x)
> "hello"

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

Selects the seventh item of a non-empty list.

> > v
> (list 1 2 3 4 5 6 7 8 9 'A)
> > (seventh v)
> 7

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

Selects the sixth item of a non-empty list.

> > v
> (list 1 2 3 4 5 6 7 8 9 'A)
> > (sixth v)
> 6

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

Selects the third item of a non-empty list.

> > x
> (list 2 "hello" true)
> > (third x)
> true

##### 3.5.5`` Posns

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

Constructs a posn from two arbitrary values.

> > (make-posn 3 3)
> (posn 3 3)
> > (make-posn "hello" true)
> (posn "hello" true)

> procedure (posn) → signature

Signature for posns.

> procedure (posn-x p) → any
> p : posn

Extracts the x component of a posn.

> > p
> (posn 2 -3)
> > (posn-x p)
> 2

> procedure (posn-y p) → any
> p : posn

Extracts the y component of a posn.

> > p
> (posn 2 -3)
> > (posn-y p)
> -3

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

Determines if its input is a posn.

> > q
> (posn "bye" 2)
> > (posn? q)
> true
> > (posn? 42)
> false

##### 3.5.6`` Characters

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

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

> > (char->integer #\a)
> 97
> > (char->integer #\z)
> 122

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

Determines whether a character represents an alphabetic character.

> > (char-alphabetic? #\Q)
> true

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

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

> > (char-ci<=? #\b #\B)
> true
> > (char<=? #\b #\B)
> false

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

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

> > (char-ci<? #\B #\c)
> true
> > (char<? #\b #\B)
> false

> 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)
> true

> 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)
> false
> > (char>=? #\b #\C)
> true

> 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)
> false
> > (char>? #\b #\B)
> true

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

Produces the equivalent lower-case character.

> > (char-downcase #\T)
> #\t

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

Determines whether a character is a lower-case character.

> > (char-lower-case? #\T)
> false

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

Determines whether a character represents a digit.

> > (char-numeric? #\9)
> true

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

Produces the equivalent upper-case character.

> > (char-upcase #\t)
> #\T

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

Determines whether a character is an upper-case character.

> > (char-upper-case? #\T)
> true

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

Determines whether a character represents space.

> > (char-whitespace? #\tab)
> true

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

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

> > (char<=? #\a #\a #\b)
> true

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

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

> > (char<? #\a #\b #\c)
> true

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

Determines whether the characters are equal.

> > (char=? #\b #\a)
> false

> 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)
> true

> 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)
> false

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

Determines whether a value is a character.

> > (char? "a")
> false
> > (char? #\a)
> true

##### 3.5.7`` Strings

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

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

> > (explode "cat")
> (list "c" "a" "t")

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

Formats a string, possibly embedding values.

> > (format "Dear Dr. ~a:" "Flatt")
> "Dear Dr. Flatt:"
> > (format "Dear Dr. ~s:" "Flatt")
> "Dear Dr. \"Flatt\":"
> > (format "the value of ~s is ~a" '(+ 1 1) (+ 1 1))
> "the value of (+ 1 1) is 2"

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

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

> > (implode (cons "c" (cons "a" (cons "t" empty))))
> "cat"

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

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

> > (int->string 65)
> "A"

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

Converts a s list of characters into a string.

> > (list->string (cons #\c (cons #\a (cons #\t empty))))
> "cat"

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

Produces a string of length i from c.

> > (make-string 3 #\d)
> "ddd"

> procedure (replicate i s) → string
> i : natural-number
> s : string

Replicates s i times.

> > (replicate 3 "h")
> "hhh"

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

Builds a string of the given characters.

> > (string #\d #\o #\g)
> "dog"

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

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

> > (string->int "a")
> 97

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

Converts a string into a list of characters.

> > (string->list "hello")
> (list #\h #\e #\l #\l #\o)

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

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

> > (string->number "-2.03")
> #i-2.03
> > (string->number "1-2i")
> 1-2i

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

Converts a string into a symbol.

> > (string->symbol "hello")
> 'hello

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

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

> > (string-alphabetic? "123")
> false
> > (string-alphabetic? "cat")
> true

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

Juxtaposes the characters of several strings.

> > (string-append "hello" " " "world" " " "good bye")
> "hello world good bye"

> 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")
> true

> 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")
> true

> 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")
> true

> 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")
> true

> 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")
> true

> 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")
> true

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

Copies a string.

> > (string-copy "hello")
> "hello"

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

Extracts the ith 1-letter substring from s.

> > (string-ith "hello world" 1)
> "e"

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

Determines the length of a string.

> > (string-length "hello world")
> 11

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

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

> > (string-lower-case? "CAT")
> false

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

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

> > (string-numeric? "123")
> true
> > (string-numeric? "1-2i")
> false

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

Extracts the ith character from s.

> > (string-ref "cat" 2)
> #\t

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

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

> > (string-upper-case? "CAT")
> true

> 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)))
> true

> 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")
> true

> 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")
> true

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

Determines whether all strings are equal, character for character.

> > (string=? "hello" "world")
> false
> > (string=? "bye" "bye")
> true

> 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")
> true

> 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")
> true

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

Determines whether a value is a string.

> > (string? "hello world")
> true
> > (string? 42)
> false

> procedure (substring s i j) → string
> s : string
> i : natural-number
> j : natural-number

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

> > (substring "hello world" 1 5)
> "ello"
> > (substring "hello world" 4)
> "o world"

##### 3.5.8`` Images

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

Determines whether two images are equal.

> > c1
> > (image=? (circle 5 "solid" "green") c1)
> false
> > (image=? (circle 10 "solid" "green") c1)
> true

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

Determines whether a value is an image.

> > c1
> > (image? c1)
> true

##### 3.5.9`` Misc

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

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

> > (=~ 1.01 1.0 0.1)
> true
> > (=~ 1.01 1.5 0.1)
> false

> value eof : eof-object?

A value that represents the end of a file:

> > eof
> #<eof>

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

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

> > (eof-object? eof)
> true
> > (eof-object? 42)
> false

> 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 empty) (cons 1 empty))
> false
> > one
> (list 1)
> > (eq? one one)
> true

> 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)))
> true

> 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)
> true

> 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 empty) (cons 1 empty))
> false
> > one
> (list 1)
> > (eqv? one one)
> true

> 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
> 0
> > (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 (identity x) → any
> x : any/c

Returns x.

> > (identity 42)
> 42
> > (identity c1)
> > (identity "hello")
> "hello"

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

Determines whether some value is a structure.

> > (struct? (make-posn 1 2))
> true
> > (struct? 43)
> false

##### 3.5.10`` Numbers (relaxed conditions)

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

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

> > (* 5 3)
> 15
> > (* 5 3 2)
> 30
> > (* 2)
> 2
> > (*)
> 1

> 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)
> 35/48
> > (+ 3 2 5 8)
> 18
> > (+ 1)
> 1
> > (+)
> 0

> 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 only one number.

> > (/ 12 2)
> 6
> > (/ 12 2 3)
> 2
> > (/ 3)
> 1/3

##### 3.5.11`` Higher-Order Functions

> 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 odd? '(1 3 5 7 9))
> true
> > threshold
> 3
> > (andmap (lambda (x) (< x threshold)) '(0 1 2))
> true
> > (andmap even? '())
> true

> 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
> (list 0 1 2 3 4 5 6 7 8 9)
> > (apply max a-list)
> 9

> 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)))
> (list 'asumu 99)

> 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)))
> (list 'carl 78)

> 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)
> (list 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22)
> > i
> 3
> > (build-list 3 (lambda (j) (+ j i)))
> (list 3 4 5)
> > (build-list 5
> (lambda (i)
> (build-list 5
> (lambda (j)
> (if (= i j) 1 0)))))
> (list
> (list 1 0 0 0 0)
> (list 0 1 0 0 0)
> (list 0 0 1 0 0)
> (list 0 0 0 1 0)
> (list 0 0 0 0 1))

> 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)
> "\u0000\u0001\u0002\u0003\u0004\u0005\u0006\a\b\t"
> > (build-string 26 (lambda (x) (integer->char (+ 65 x))))
> "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

> 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))
> 4
> > (map (compose add1 second) '((add 3) (sub 2) (mul 4)))
> (list 4 3 5)

> 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))
> (list 1 3 5 7 9)
> > threshold
> 3
> > (filter (lambda (x) (>= x threshold)) '(0 1 2 3 4 5 6 7 8 9))
> (list 3 4 5 6 7 8 9)

> 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 + 0 '(0 1 2 3 4 5 6 7 8 9))
> 45
> > a-list
> (list 0 1 2 3 4 5 6 7 8 9)
> > (foldl (lambda (x r) (if (> x threshold) (cons (* 2 x) r) r)) '() a-list)
> (list 18 16 14 12 10 8)

> 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 + 0 '(0 1 2 3 4 5 6 7 8 9))
> 45
> > a-list
> (list 0 1 2 3 4 5 6 7 8 9)
> > (foldr (lambda (x r) (if (> x threshold) (cons (* 2 x) r) r)) '() a-list)
> (list 8 10 12 14 16 18)

> 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

> 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 add1 '(3 -4.01 2/5))
> (list 4 #i-3.01 1.4)
> > (map (lambda (x) (list 'my-list (+ x 1))) '(3 -4.01 2/5))
> (list
> (list 'my-list 4)
> (list 'my-list #i-3.01)
> (list 'my-list 1.4))

> 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))
> (list 3 8 0)

> 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 odd? '(1 3 5 7 9))
> true
> > threshold
> 3
> > (ormap (lambda (x) (< x threshold)) '(6 7 8 1 5))
> true
> > (ormap even? '())
> false

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

Produces true if the value is a procedure.

> > (procedure? cons)
> true
> > (procedure? add1)
> true
> > (procedure? (lambda (x) (> x 22)))
> true

> 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) <)
> (list 0 1 2 3 4 5 6 7 8 9)

> 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) <)
> (list 0 1 2 3 4 5 6 7 8 9)

top ← prev up next →