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

Version: 4.1.4
top← prev up next →

### 5`` Advanced Student

program |  | = |  | def-or-expr ...
def-or-expr |  | = |  | definition
|  | | |  | expr
|  | | |  | test-case
|  | | |  | library-require
definition |  | = |  | (define (id id id ...) expr)
|  | | |  | (define id expr)
|  | | |  | (define-struct id (id ...))
expr |  | = |  | (begin expr expr ...)
|  | | |  | (begin0 expr expr ...)
|  | | |  | (set! id expr)
|  | | |  | (delay expr)
|  | | |  | (lambda (id ...) expr)
|  | | |  | (local [definition ...] expr)
|  | | |  | (letrec ([id expr] ...) expr)
|  | | |  | (shared ([id expr] ...) expr)
|  | | |  | (let ([id expr] ...) expr)
|  | | |  | (let id ([id expr] ...) expr)
|  | | |  | (let* ([id expr] ...) expr)
|  | | |  | (recur id ([id expr] ...) expr)
|  | | |  | (expr expr ...) ; function call
|  | | |  | (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])

|  | | |  | (if expr expr expr)
|  | | |  | (when expr expr)
|  | | |  | (unless expr expr)
|  | | |  | (and expr expr expr ...)
|  | | |  | (or expr expr expr ...)
|  | | |  | (time expr)
|  | | |  | empty
|  | | |  | id ; identifier
|  | | |  | prim-op ; primitive operation
|  | | |  | 'id
|  | | |  | ’quoted ; quoted value
|  | | |  | `quasiquoted ; quasiquote
|  | | |  | number
|  | | |  | true
|  | | |  | false
|  | | |  | string
|  | | |  | character
choice |  | = |  | id ; treated as a symbol
|  | | |  | number
quoted |  | = |  | id
|  | | |  | number
|  | | |  | string
|  | | |  | character
|  | | |  | (quoted ...)
|  | | |  | ’quoted
|  | | |  | `quoted
|  | | |  | ,quoted
|  | | |  | ,@quoted
quasiquoted |  | = |  | id
|  | | |  | number
|  | | |  | string
|  | | |  | character
|  | | |  | (quasiquoted ...)
|  | | |  | ’quasiquoted
|  | | |  | `quasiquoted
|  | | |  | ,expr
|  | | |  | ,@expr
test-case |  | = |  | (check-expect expr expr)
|  | | |  | (check-within expr expr expr)
|  | | |  | (check-error expr expr)
library-require |  | = |  | (require string)
|  | | |  | (require (lib string string ...))
|  | | |  | (require (planet string package))
package |  | = |  | (string string number number)

An id 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 string is enclosed by a pair of ". Unlike symbols, strings may be split into characters and manipulated by a variety of primitive 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.

A prim-op is one of:
Numbers: Integers, Rationals, Reals, Complex, Exacts, Inexacts
* : (num num num ... -> num)
+ : (num num num ... -> num)
- : (num num ... -> num)
/ : (num num num ... -> num)
< : (real real real ... -> boolean)
<= : (real real real ... -> boolean)
= : (num num num ... -> boolean)
> : (real real real ... -> boolean)
>= : (real real ... -> boolean)
abs : (real -> real)
acos : (num -> num)
add1 : (number -> number)
angle : (num -> real)
asin : (num -> num)
atan : (num -> num)
ceiling : (real -> int)
complex? : (any -> boolean)
conjugate : (num -> num)
cos : (num -> num)
cosh : (num -> num)
current-seconds : (-> int)
denominator : (rat -> int)
e : real
even? : (integer -> boolean)
exact->inexact : (num -> num)
exact? : (num -> boolean)
exp : (num -> num)
expt : (num num -> num)
floor : (real -> int)
gcd : (int int ... -> int)
imag-part : (num -> real)
inexact->exact : (num -> num)
inexact? : (num -> boolean)
integer->char : (int -> char)
integer? : (any -> boolean)
lcm : (int int ... -> int)
log : (num -> num)
magnitude : (num -> real)
make-polar : (real real -> num)
max : (real real ... -> real)
min : (real real ... -> real)
modulo : (int int -> int)
negative? : (number -> boolean)
number->string : (num -> string)
number? : (any -> boolean)
numerator : (rat -> int)
odd? : (integer -> boolean)
pi : real
positive? : (number -> boolean)
quotient : (int int -> int)
random : (int -> int)
rational? : (any -> boolean)
real-part : (num -> real)
real? : (any -> boolean)
remainder : (int int -> int)
round : (real -> int)
sgn : (real -> (union 1 1.0 0 0.0 -1 -1.0))
sin : (num -> num)
sinh : (num -> num)
sqr : (num -> num)
sqrt : (num -> num)
sub1 : (number -> number)
tan : (num -> num)
zero? : (number -> boolean)
Booleans
boolean=? : (boolean boolean -> boolean)
boolean? : (any -> boolean)
false? : (any -> boolean)
not : (boolean -> boolean)
Symbols
symbol->string : (symbol -> string)
symbol=? : (symbol symbol -> boolean)
symbol? : (any -> boolean)
Lists
append : ((listof any) ... -> (listof any))

assq :

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

caaar :

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

caadr :

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

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

cadar :

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

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

cdaar :

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

cdadr :

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

cdar :

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

cddar :

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

cdddr :

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

cddr : ((cons Z (cons Y (listof X))) -> (listof X))
cdr : ((cons Y (listof X)) -> (listof X))
cons : (X (listof X) -> (listof X))
cons? : (any -> boolean)
eighth : ((listof Y) -> Y)
empty? : (any -> boolean)
fifth : ((listof Y) -> Y)
first : ((cons Y (listof X)) -> Y)
fourth : ((listof Y) -> Y)
length : ((listof any) -> number)
list : (any ... -> (listof any))
list-ref : ((listof X) natural-number -> X)
list? : (any -> boolean)
member : (any (listof any) -> boolean)
memq : (any (listof any) -> (union false list))
memv : (any (listof any) -> (union false list))
null : empty
null? : (any -> boolean)
pair? : (any -> boolean)
rest : ((cons Y (listof X)) -> (listof X))
reverse : ((listof any) -> list)
second : ((cons Z (cons Y (listof X))) -> Y)
seventh : ((listof Y) -> Y)
sixth : ((listof Y) -> Y)
third : ((cons W (cons Z (cons Y (listof X)))) -> Y)
Posns
make-posn : (number number -> posn)
posn-x : (posn -> number)
posn-y : (posn -> number)
posn? : (anything -> boolean)
set-posn-x! : (posn number -> void)
set-posn-y! : (posn number -> void)
Characters
char->integer : (char -> integer)
char-alphabetic? : (char -> boolean)
char-ci<=? : (char char char ... -> boolean)
char-ci<? : (char char char ... -> boolean)
char-ci=? : (char char char ... -> boolean)
char-ci>=? : (char char char ... -> boolean)
char-ci>? : (char char char ... -> boolean)
char-downcase : (char -> char)
char-lower-case? : (char -> boolean)
char-numeric? : (char -> boolean)
char-upcase : (char -> char)
char-upper-case? : (char -> boolean)
char-whitespace? : (char -> boolean)
char<=? : (char char char ... -> boolean)
char<? : (char char char ... -> boolean)
char=? : (char char char ... -> boolean)
char>=? : (char char char ... -> boolean)
char>? : (char char char ... -> boolean)
char? : (any -> boolean)
Strings
format : (string any ... -> string)
list->string : ((listof char) -> string)
make-string : (nat char -> string)
string : (char ... -> string)
string->list : (string -> (listof char))
string->number : (string -> (union number false))
string->symbol : (string -> symbol)
string-append : (string ... -> string)
string-ci<=? : (string string string ... -> boolean)
string-ci<? : (string string string ... -> boolean)
string-ci=? : (string string string ... -> boolean)
string-ci>=? : (string string string ... -> boolean)
string-ci>? : (string string string ... -> boolean)
string-copy : (string -> string)
string-length : (string -> nat)
string-ref : (string nat -> char)
string<=? : (string string string ... -> boolean)
string<? : (string string string ... -> boolean)
string=? : (string string string ... -> boolean)
string>=? : (string string string ... -> boolean)
string>? : (string string string ... -> boolean)
string? : (any -> boolean)
substring : (string nat nat -> string)
Images
image=? : (image image -> boolean)
image? : (any -> boolean)
Misc
=~ : (real real non-negative-real -> boolean)
eof : eof
eof-object? : (any -> boolean)
eq? : (any any -> boolean)
equal? : (any any -> boolean)
equal~? : (any any non-negative-real -> boolean)
eqv? : (any any -> boolean)
error : (symbol string -> void)
exit : (-> void)
force : (delay -> any)
identity : (any -> any)
promise? : (any -> boolean)
struct? : (any -> boolean)
void : (-> void)
void? : (any -> boolean)
Higher-Order Functions
andmap : ((X -> boolean) (listof X) -> boolean)

apply :

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

argmax : ((X -> real) (listof X) -> X)
argmin : ((X -> real) (listof X) -> X)
build-list : (nat (nat -> X) -> (listof X))
build-string : (nat (nat -> char) -> string)

compose :

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

filter : ((X -> boolean) (listof X) -> (listof X))
foldl : ((X Y -> Y) Y (listof X) -> Y)
foldr : ((X Y -> Y) Y (listof X) -> Y)
for-each : ((any ... -> any) (listof any) ... -> void)
map : ((X ... -> Z) (listof X) ... -> (listof Z))

memf :

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

ormap : ((X -> boolean) (listof X) -> boolean)
procedure? : (any -> boolean)
quicksort : ((listof X) (X X -> boolean) -> (listof X))
sort : ((listof X) (X X -> boolean) -> (listof X))
Reading and Printing
display : (any -> void)
newline : (-> void)
pretty-print : (any -> void)
print : (any -> void)
printf : (string any ... -> void)
read : (-> sexp)
write : (any -> void)
Vectors
build-vector : (nat (nat -> X) -> (vectorof X))
make-vector : (number X -> (vectorof X))
vector : (X ... -> (vector X ...))
vector-length : ((vector X) -> nat)
vector-ref : ((vector X) nat -> X)
vector-set! : ((vectorof X) nat X -> void)
vector? : (any -> boolean)
Boxes
box : (any -> box)
box? : (any -> boolean)
set-box! : (box any -> void)
unbox : (box -> any)

top← prev up next →