5 Advanced Student
The grammar notation uses the notation X ... (bold dots) to indicate that X may occur an arbitrary number of times (zero, one, or more). Separately, the grammar also defines ... as an identifier to be used in templates.
program | = | def-or-expr ... | ||||
def-or-expr | = | definition | ||||
| | expr | |||||
| | test-case | |||||
| | library-require | |||||
| | signature-declaration | |||||
definition | = | (define (name variable ...) expr) | ||||
| | (define name expr) | |||||
| | (define-struct name (name ...)) | |||||
| | (define-datatype name (name name ...) ...) | |||||
expr | = | (begin expr expr ...) | ||||
| | (begin0 expr expr ...) | |||||
| | (set! variable expr) | |||||
| | (delay expr) | |||||
| | (lambda (variable ...) expr) | |||||
| | (λ (variable ...) expr) | |||||
| | (local [definition ...] expr) | |||||
| | (letrec ([name expr] ...) expr) | |||||
| | (shared ([name expr] ...) expr) | |||||
| | (let ([name expr] ...) expr) | |||||
| | (let name ([name expr] ...) expr) | |||||
| | (let* ([name expr] ...) expr) | |||||
| | (recur name ([name expr] ...) expr) | |||||
| | (expr expr ...) | |||||
| | (cond [expr expr] ... [expr expr]) | |||||
| | (cond [expr 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 ...) | |||||
| | (time expr) | |||||
| | name | |||||
| | ’quoted | |||||
| | ‘quasiquoted | |||||
| | ’() | |||||
| | number | |||||
| | boolean | |||||
| | string | |||||
| | character | |||||
| | (signature signature-form) | |||||
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 | |||||
signature-declaration | = | (: name signature-form) | ||||
signature-form | = | (enum expr ...) | ||||
| | (mixed signature-form ...) | |||||
| | (signature-form ... -> signature-form) | |||||
| | (ListOf signature-form) | |||||
| | signature-variable | |||||
| | expr | |||||
signature-variable | = | %name | ||||
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-random expr expr) | |||||
| | (check-within expr expr expr) | |||||
| | (check-error expr expr ...) | |||||
| | (check-member-of expr expr expr) | |||||
| | (check-satisfied expr expr) | |||||
| | (check-range expr expr) | |||||
| | (check-range expr) | |||||
library-require | = | (require string) | ||||
| | (require (lib string string ...)) | |||||
| | (require (planet string package)) | |||||
package | = | (string string number number) |
5.1 Pre-defined Variables
5.2 Template Variables
syntax
syntax
syntax
syntax
syntax
5.3 Syntax for Advanced
In Advanced, set! can be used to mutate variables, and define-struct’s structures are mutatable. define and lambda can define functions of zero arguments, and function calls can invoke functions of zero arguments.
syntax
(lambda (variable ...) expression)
syntax
(λ (variable ...) expression)
syntax
(expression expression ...)
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
(define-datatype dataype-name [variant-name field-name ...] ...)
(define-datatype datatype-name [variant-name field-name #, ...] ...)
(define (datatype-name? x) (or (variant-name? x) ...)) (define-struct variant-name (field-name ...)) ...
syntax
(begin expression expression ...)
syntax
(begin0 expression expression ...)
syntax
(set! variable expression)
syntax
(delay expression)
syntax
(shared ([name expression] ...) expression)
syntax
(recur name ([name expression] ...) expression)
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
(let name ([name expression] ...) expression)
syntax
(case expression [(choice ...) expression] ... [(choice ...) expression])
syntax
(match expression [pattern expression] ...)
syntax
(when question-expression body-expression)
syntax
(unless question-expression body-expression)
5.4 Common Syntaxes
The following syntaxes behave the same in the Advanced level as they did in the Intermediate Student with Lambda level.
syntax
(local [definition ...] expression)
syntax
(letrec ([name expr-for-let] ...) expression)
syntax
(let* ([name expr-for-let] ...) expression)
syntax
(let ([name expr-for-let] ...) expression)
syntax
(time expression)
syntax
(define (name variable variable ...) expression)
syntax
(define name expression)
syntax
(define-struct structure-name (field-name ...))
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.
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])
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.
syntax
(if question-expression then-answer-expression else-answer-expression)
syntax
(and expression expression expression ...)
syntax
(or expression expression expression ...)
syntax
(check-expect expression expected-expression)
(check-expect (fahrenheit->celsius 212) 100) (check-expect (fahrenheit->celsius -40) -40) (define (fahrenheit->celsius f) (* 5/9 (- f 32)))
syntax
(check-random expression 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.
(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)))
; 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) (a-helper-function name (random HEIGHT))) ; Striing Number -> Player (define (a-helper-function name height) (make-player name (random WIDTH) height))
syntax
(check-satisfied expression predicate)
> (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
; [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))))]))
> (check-satisfied (htdp-sort (list 1 2 0 3)) sorted?)
syntax
(check-within expression expected-expression delta)
(define-struct roots (x sqrt)) ; RT is [List-of (make-roots Number Number)] (define (root-of a) (make-roots a (sqrt a))) (define (roots-table xs) (cond [(empty? xs) '()] [else (cons (root-of (first xs)) (roots-table (rest xs)))]))
> (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!
> (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.
syntax
(check-error expression expected-error-message)
(check-error expression)
(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:
> (check-expect (lookup sample-table "matthew") 20) The test passed!
> (check-error (lookup sample-table "kathi") "kathi not found") The test passed!
syntax
(check-member-of expression expression expression ...)
; [List-of X] -> X ; pick a random element from the given list l (define (pick-one l) (list-ref l (random (length l))))
> (check-member-of (pick-one '("a" "b" "c")) "a" "b" "c") The test passed!
syntax
(check-range expression low-expression high-expression)
(define EPSILON 0.001) ; [Real -> Real] Real -> Real ; what is the slope of f at x? (define (differentiate f x) (slope f (- x EPSILON) (+ x EPSILON))) ; [Real -> Real] Real Real -> Real (define (slope-of f left right) (/ (- (f right) (f left)) 2 EPSILON)) (check-range (differentiate sin 0) 0.99 1.0)
syntax
(require string)
syntax
(require module-name)
syntax
(require (lib string string ...))
syntax
(require (planet string (string string number number)))
syntax
(require (planet id))
syntax
(require (planet string))
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.
5.5 Signatures
Signatures do not have to be comment: They can also be part of the code. When a signature is attached to a function, DrRacket will check that program uses the function in accordance with the signature and display signature violations along with the test results.
A signature is a regular value, and is specified as a signature form, a special syntax that only works with : signature declarations and inside signature expressions.
syntax
(: name signature-form)
(: age Integer) (define age 42) (: area-of-square (Number -> Number)) (define (area-of-square len) (sqr len))
On running the program, Racket checks whether the signatures attached with : actually match the value of the variable. If they don’t, Racket reports signature violation along with test failures.
For example, this piece of code:
(: age Integer) (define age "fortytwo")
Yields this output:
1 signature violation. |
|
Signature violations: |
got "fortytwo" at line 2, column 12, signature at line 1, column 7 |
Note that a signature violation does not stop the running program.
syntax
(signature signature-form)
5.5.1 Signature Forms
Any expression can be a signature form, in which case the signature is the value returned by that expression. There are a few special signature forms, however:
In a signature form, any name that starts with a % is a signature variable that stands for any signature depending on how the signature is used.
Example:
(: same (%a -> %a)) (define (same x) x)
syntax
(input-signature-form ... -> output-signature-form)
syntax
(enum expr ...)
Example:
(: cute? ((enum "cat" "snake") -> Boolean)) (define (cute? pet) (cond [(string=? pet "cat") #t] [(string=? pet "snake") #f]))
syntax
(mixed signature-form ...)
Example:
syntax
(ListOf signature-form)
5.5.2 Struct Signatures
A define-struct form defines two additional names that can be used in signatures. For a struct called struct, these are Struct and StructOf. Note that these names are capitalized. In particular, a struct called Struct, will also define Struct and StructOf. Moreover, when forming the additional names, hyphens are removed, and each letter following a hyphen is capitalized - so a struct called foo-bar will define FooBar and FooBarOf.
Struct is a signature that describes struct values from this structure type. StructOf is a function that takes as input a signature for each field. It returns a signature describing values of this structure type, additionally describing the values of the fields of the value.
(define-struct pair [fst snd]) (: add-pair ((PairOf Number Number) -> Number)) (define (add-pair p) (+ (pair-fst p) (pair-snd p)))
5.6 Pre-Defined Functions
The remaining subsections list those functions that are built into the programming language. All other functions are imported from a teachpack or must be defined in the program.
5.7 Numbers: Integers, Rationals, Reals, Complex, Exacts, Inexacts
procedure
(- x y ...) → number
x : number y : number
> (- 5) -5
> (- 5 3) 2
> (- 5 3 1) 1
procedure
(< x y z ...) → boolean?
x : real y : real z : real
> (< 42 2/5) #false
procedure
(<= x y z ...) → boolean?
x : real y : real z : real
> (<= 42 2/5) #false
procedure
(= x y z ...) → boolean?
x : number y : number z : number
> (= 42 2/5) #false
procedure
(> x y z ...) → boolean?
x : real y : real z : real
> (> 42 2/5) #true
procedure
(>= x y z ...) → boolean?
x : real y : real z : real
> (>= 42 42) #true
procedure
(abs x) → real
x : real
> (abs -12) 12
procedure
(acos x) → number
x : number
> (acos 0) #i1.5707963267948966
procedure
(add1 x) → number
x : number
> (add1 2) 3
procedure
(angle x) → real
x : number
> (angle (make-polar 3 4)) #i-2.2831853071795867
procedure
(asin x) → number
x : number
> (asin 0) 0
procedure
(atan x) → number
x : number
> (atan 0) 0
> (atan 0.5) #i0.4636476090008061
> (atan 3 4) #i0.6435011087932844
> (atan -2 -1) #i-2.0344439357957027
procedure
(ceiling x) → integer
x : real
> (ceiling 12.3) #i13.0
procedure
(complex? x) → boolean?
x : any/c
> (complex? 1-2i) #true
procedure
(conjugate x) → number
x : number
> (conjugate 3+4i) 3-4i
> (conjugate -2-5i) -2+5i
> (conjugate (make-polar 3 4)) #i-1.960930862590836+2.2704074859237844i
procedure
(cos x) → number
x : number
> (cos pi) #i-1.0
procedure
(cosh x) → number
x : number
> (cosh 10) #i11013.232920103324
procedure
(current-seconds) → integer
> (current-seconds) 1621102681
procedure
(denominator x) → integer
x : rational?
> (denominator 2/3) 3
value
e : real
> e #i2.718281828459045
procedure
(even? x) → boolean?
x : integer
> (even? 2) #true
procedure
(exact->inexact x) → number
x : number
> (exact->inexact 12) #i12.0
procedure
(exact? x) → boolean?
x : number
> (exact? (sqrt 2)) #false
procedure
(exp x) → number
x : number
> (exp -2) #i0.1353352832366127
procedure
(expt x y) → number
x : number y : number
> (expt 16 1/2) 4
> (expt 3 -4) 1/81
procedure
(floor x) → integer
x : real
> (floor 12.3) #i12.0
procedure
(gcd x y ...) → integer
x : integer y : integer
> (gcd 6 12 8) 2
procedure
(imag-part x) → real
x : number
> (imag-part 3+4i) 4
procedure
(inexact->exact x) → number
x : number
> (inexact->exact 12.0) 12
procedure
(inexact? x) → boolean?
x : number
> (inexact? 1-2i) #false
procedure
(integer->char x) → char
x : exact-integer?
> (integer->char 42) #\*
procedure
(integer-sqrt x) → complex
x : integer
> (integer-sqrt 11) 3
> (integer-sqrt -11) 0+3i
procedure
(integer? x) → boolean?
x : any/c
> (integer? (sqrt 2)) #false
procedure
(lcm x y ...) → integer
x : integer y : integer
> (lcm 6 12 8) 24
procedure
(log x) → number
x : number
> (log 12) #i2.4849066497880004
procedure
(magnitude x) → real
x : number
> (magnitude (make-polar 3 4)) #i2.9999999999999996
procedure
(make-polar x y) → number
x : real y : real
> (make-polar 3 4) #i-1.960930862590836-2.2704074859237844i
procedure
(make-rectangular x y) → number
x : real y : real
> (make-rectangular 3 4) 3+4i
procedure
(max x y ...) → real
x : real y : real
> (max 3 2 8 7 2 9 0) 9
procedure
(min x y ...) → real
x : real y : real
> (min 3 2 8 7 2 9 0) 0
procedure
(modulo x y) → integer
x : integer y : integer
> (modulo 9 2) 1
> (modulo 3 -4) -1
procedure
(negative? x) → boolean?
x : real
> (negative? -2) #true
procedure
(number->string x) → string
x : number
> (number->string 42) "42"
procedure
(number->string-digits x p) → string
x : number p : posint
> (number->string-digits 0.9 2) "0.9"
> (number->string-digits pi 4) "3.1416"
procedure
(number? n) → boolean?
n : any/c
> (number? "hello world") #false
> (number? 42) #true
procedure
(numerator x) → integer
x : rational?
> (numerator 2/3) 2
procedure
(odd? x) → boolean?
x : integer
> (odd? 2) #false
value
pi : real
> pi #i3.141592653589793
procedure
(positive? x) → boolean?
x : real
> (positive? -2) #false
procedure
(quotient x y) → integer
x : integer y : integer
> (quotient 9 2) 4
> (quotient 3 4) 0
procedure
(random x) → natural
x : natural
> (random) #i0.18611414258176034
> (random) #i0.1315358153915614
> (random 42) 23
> (random 42) 34
procedure
(rational? x) → boolean?
x : any/c
> (rational? 1) #true
> (rational? -2.349) #true
> (rational? #i1.23456789) #true
> (rational? (sqrt -1)) #false
> (rational? pi) #true
> (rational? e) #true
> (rational? 1-2i) #false
procedure
(real-part x) → real
x : number
> (real-part 3+4i) 3
procedure
(real? x) → boolean?
x : any/c
> (real? 1-2i) #false
procedure
(remainder x y) → integer
x : integer y : integer
> (remainder 9 2) 1
> (remainder 3 4) 3
procedure
(round x) → integer
x : real
> (round 12.3) #i12.0
procedure
(sgn x) → (union 1 #i1.0 0 #i0.0 -1 #i-1.0)
x : real
> (sgn -12) -1
procedure
(sin x) → number
x : number
> (sin pi) #i1.2246467991473532e-16
procedure
(sinh x) → number
x : number
> (sinh 10) #i11013.232874703393
procedure
(sqr x) → number
x : number
> (sqr 8) 64
procedure
(sqrt x) → number
x : number
> (sqrt 9) 3
> (sqrt 2) #i1.4142135623730951
procedure
(sub1 x) → number
x : number
> (sub1 2) 1
procedure
(tan x) → number
x : number
> (tan pi) #i-1.2246467991473532e-16
procedure
(zero? x) → boolean?
x : number
> (zero? 2) #false
5.8 Booleans
procedure
(boolean->string x) → string
x : boolean?
> (boolean->string #false) "#false"
> (boolean->string #true) "#true"
procedure
(boolean=? x y) → boolean?
x : boolean? y : boolean?
> (boolean=? #true #false) #false
procedure
(boolean? x) → boolean?
x : any/c
> (boolean? 42) #false
> (boolean? #false) #true
procedure
(false? x) → boolean?
x : any/c
> (false? #false) #true
procedure
(not x) → boolean?
x : boolean?
> (not #false) #true
5.9 Symbols
procedure
(symbol->string x) → string
x : symbol
> (symbol->string 'c) "c"
procedure
(symbol=? x y) → boolean?
x : symbol y : symbol
> (symbol=? 'a 'b) #false
procedure
(symbol? x) → boolean?
x : any/c
> (symbol? 'a) #true
5.10 Lists
procedure
(append l ...) → (listof any)
l : (listof any)
procedure
(assoc x l) → (union (listof any) #false)
x : any l : (listof any)
> (assoc "hello" '(("world" 2) ("hello" 3) ("good" 0))) (list "hello" 3)
procedure
(assq x l) → (union #false cons?)
x : any/c l : list?
> a (list (list 'a 22) (list 'b 8) (list 'c 70))
> (assq 'b a) (list 'b 8)
procedure
(caaar x) → any/c
x : list?
> w (list (list (list (list "bye") 3) #true) 42)
> (caaar w) (list "bye")
procedure
(caadr x) → any/c
x : list?
> (caadr (cons 1 (cons (cons 'a '()) (cons (cons 'd '()) '())))) 'a
procedure
(caar x) → any/c
x : list?
> y (list (list (list 1 2 3) #false "world"))
> (caar y) (list 1 2 3)
procedure
(cadar x) → any/c
x : list?
> w (list (list (list (list "bye") 3) #true) 42)
> (cadar w) #true
procedure
(cadddr x) → any/c
x : list?
> v (list 1 2 3 4 5 6 7 8 9 'A)
> (cadddr v) 4
procedure
(caddr x) → any/c
x : list?
> x (list 2 "hello" #true)
> (caddr x) #true
procedure
(cadr x) → any/c
x : list?
> x (list 2 "hello" #true)
> (cadr x) "hello"
procedure
(car x) → any/c
x : cons?
> x (list 2 "hello" #true)
> (car x) 2
procedure
(cdaar x) → any/c
x : list?
> w (list (list (list (list "bye") 3) #true) 42)
> (cdaar w) (list 3)
procedure
(cdadr x) → any/c
x : list?
> (cdadr (list 1 (list 2 "a") 3)) (list "a")
procedure
(cdar x) → list?
x : list?
> y (list (list (list 1 2 3) #false "world"))
> (cdar y) (list #false "world")
procedure
(cddar x) → any/c
x : list?
> w (list (list (list (list "bye") 3) #true) 42)
> (cddar w) '()
procedure
(cdddr x) → any/c
x : list?
> 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?
> x (list 2 "hello" #true)
> (cddr x) (list #true)
procedure
(cdr x) → any/c
x : cons?
> x (list 2 "hello" #true)
> (cdr x) (list "hello" #true)
procedure
(cons x l) → (listof X)
x : X l : (listof X)
procedure
(cons? x) → boolean?
x : any/c
> (cons? (cons 1 '())) #true
> (cons? 42) #false
procedure
(eighth x) → any/c
x : list?
> v (list 1 2 3 4 5 6 7 8 9 'A)
> (eighth v) 8
procedure
(empty? x) → boolean?
x : any/c
> (empty? '()) #true
> (empty? 42) #false
procedure
(fifth x) → any/c
x : list?
> v (list 1 2 3 4 5 6 7 8 9 'A)
> (fifth v) 5
procedure
(first x) → any/c
x : cons?
> x (list 2 "hello" #true)
> (first x) 2
procedure
(for-each f l ...) → void?
f : (any ... -> any) l : (listof any)
(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
(fourth x) → any/c
x : list?
> v (list 1 2 3 4 5 6 7 8 9 'A)
> (fourth v) 4
procedure
(length l) → natural-number?
l : list?
> x (list 2 "hello" #true)
> (length x) 3
procedure
(list x ...) → list?
x : any/c
> (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 '()))))))))))
procedure
(list* x ... l) → (listof any)
x : any l : (listof any)
procedure
(list-ref x i) → any/c
x : list? i : natural?
> v (list 1 2 3 4 5 6 7 8 9 'A)
> (list-ref v 9) 'A
procedure
(list? x) → boolean?
x : any
> (list? 42) #false
> (list? '()) #true
> (list? (cons 1 (cons 2 '()))) #true
procedure
(make-list i x) → list?
i : natural-number x : any/c
> (make-list 3 "hello") (cons "hello" (cons "hello" (cons "hello" '())))
procedure
(member x l) → boolean?
x : any/c l : list?
> x (list 2 "hello" #true)
> (member "hello" x) #true
procedure
(member? x l) → boolean?
x : any/c l : list?
> x (list 2 "hello" #true)
> (member? "hello" x) #true
procedure
(memq x l) → boolean?
x : any/c l : list?
> x (list 2 "hello" #true)
> (memq (list (list 1 2 3)) x) #false
procedure
(memq? x l) → boolean?
x : any/c l : list?
> 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?
> x (list 2 "hello" #true)
> (memv (list (list 1 2 3)) x) #false
value
null : list
> null '()
procedure
(null? x) → boolean?
x : any/c
> (null? '()) #true
> (null? 42) #false
procedure
(range start end step) → list?
start : number end : number step : number
> (range 0 10 2) (cons 0 (cons 2 (cons 4 (cons 6 (cons 8 '())))))
procedure
(remove x l) → list?
x : any/c l : list?
> x (list 2 "hello" #true)
> (remove "hello" x) (list 2 #true)
> hello-2 (list 2 "hello" #true "hello")
> (remove "hello" hello-2) (list 2 #true "hello")
procedure
(remove-all x l) → list?
x : any/c l : list?
> x (list 2 "hello" #true)
> (remove-all "hello" x) (list 2 #true)
> hello-2 (list 2 "hello" #true "hello")
> (remove-all "hello" hello-2) (list 2 #true)
procedure
(rest x) → any/c
x : cons?
> x (list 2 "hello" #true)
> (rest x) (list "hello" #true)
procedure
(reverse l) → list
l : list?
> x (list 2 "hello" #true)
> (reverse x) (list #true "hello" 2)
procedure
(second x) → any/c
x : list?
> x (list 2 "hello" #true)
> (second x) "hello"
procedure
(seventh x) → any/c
x : list?
> v (list 1 2 3 4 5 6 7 8 9 'A)
> (seventh v) 7
procedure
(sixth x) → any/c
x : list?
> v (list 1 2 3 4 5 6 7 8 9 'A)
> (sixth v) 6
procedure
(third x) → any/c
x : list?
> x (list 2 "hello" #true)
> (third x) #true
5.11 Posns
procedure
(make-posn x y) → posn
x : any/c y : any/c
> (make-posn 3 3) (make-posn 3 3)
> (make-posn "hello" #true) (make-posn "hello" #true)
procedure
(posn-x p) → any
p : posn
> p (make-posn 2 -3)
> (posn-x p) 2
procedure
(posn-y p) → any
p : posn
> p (make-posn 2 -3)
> (posn-y p) -3
procedure
(posn? x) → boolean?
x : any/c
> q (make-posn "bye" 2)
> (posn? q) #true
> (posn? 42) #false
procedure
(set-posn-x! p x) → void?
p : posn x : any
> p (make-posn 2 -3)
> (set-posn-x! p 678) > p (make-posn 678 -3)
procedure
(set-posn-y! p x) → void
p : posn x : any
> q (make-posn "bye" 2)
> (set-posn-y! q 678) > q (make-posn "bye" 678)
5.12 Characters
procedure
(char->integer c) → integer
c : char
> (char->integer #\a) 97
> (char->integer #\z) 122
procedure
(char-alphabetic? c) → boolean?
c : char
> (char-alphabetic? #\Q) #true
procedure
(char-ci<=? c d e ...) → boolean?
c : char d : char e : char
> (char-ci<=? #\b #\B) #true
> (char<=? #\b #\B) #false
procedure
(char-ci<? c d e ...) → boolean?
c : char d : char e : char
> (char-ci<? #\B #\c) #true
> (char<? #\b #\B) #false
procedure
(char-ci=? c d e ...) → boolean?
c : char d : char e : char
> (char-ci=? #\b #\B) #true
procedure
(char-ci>=? c d e ...) → boolean?
c : char d : char e : char
> (char-ci>=? #\b #\C) #false
> (char>=? #\b #\C) #true
procedure
(char-ci>? c d e ...) → boolean?
c : char d : char e : char
> (char-ci>? #\b #\B) #false
> (char>? #\b #\B) #true
procedure
(char-downcase c) → char
c : char
> (char-downcase #\T) #\t
procedure
(char-lower-case? c) → boolean?
c : char
> (char-lower-case? #\T) #false
procedure
(char-numeric? c) → boolean?
c : char
> (char-numeric? #\9) #true
procedure
(char-upcase c) → char
c : char
> (char-upcase #\t) #\T
procedure
(char-upper-case? c) → boolean?
c : char
> (char-upper-case? #\T) #true
procedure
(char-whitespace? c) → boolean?
c : char
> (char-whitespace? #\tab) #true
procedure
(char<=? c d e ...) → boolean?
c : char d : char e : char
> (char<=? #\a #\a #\b) #true
procedure
(char<? x d e ...) → boolean?
x : char d : char e : char
> (char<? #\a #\b #\c) #true
procedure
(char=? c d e ...) → boolean?
c : char d : char e : char
> (char=? #\b #\a) #false
procedure
(char>=? c d e ...) → boolean?
c : char d : char e : char
> (char>=? #\b #\b #\a) #true
procedure
(char>? c d e ...) → boolean?
c : char d : char e : char
> (char>? #\A #\z #\a) #false
procedure
(char? x) → boolean?
x : any/c
> (char? "a") #false
> (char? #\a) #true
5.13 Strings
procedure
(explode s) → (listof string)
s : string
> (explode "cat") (list "c" "a" "t")
procedure
(format f x ...) → string
f : string x : any/c
> (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?
> (implode (cons "c" (cons "a" (cons "t" '())))) "cat"
procedure
(int->string i) → string
i : integer
> (int->string 65) "A"
procedure
(list->string l) → string
l : list?
> (list->string (cons #\c (cons #\a (cons #\t '())))) "cat"
procedure
(make-string i c) → string
i : natural-number c : char
> (make-string 3 #\d) "ddd"
procedure
(replicate i s) → string
i : natural-number s : string
> (replicate 3 "h") "hhh"
procedure
(string c ...) → string?
c : char
> (string #\d #\o #\g) "dog"
procedure
(string->int s) → integer
s : string
> (string->int "a") 97
procedure
(string->list s) → (listof char)
s : string
> (string->list "hello") (list #\h #\e #\l #\l #\o)
procedure
(string->number s) → (union number #false)
s : string
> (string->number "-2.03") #i-2.03
> (string->number "1-2i") 1-2i
procedure
(string->symbol s) → symbol
s : string
> (string->symbol "hello") 'hello
procedure
(string-alphabetic? s) → boolean?
s : string
> (string-alphabetic? "123") #false
> (string-alphabetic? "cat") #true
procedure
(string-contains-ci? s t) → boolean?
s : string t : string
> (string-contains-ci? "At" "caT") #true
procedure
(string-contains? s t) → boolean?
s : string t : string
> (string-contains? "at" "cat") #true
procedure
(string-copy s) → string
s : string
> (string-copy "hello") "hello"
procedure
(string-downcase s) → string
s : string
> (string-downcase "CAT") "cat"
> (string-downcase "cAt") "cat"
procedure
(string-ith s i) → 1string?
s : string i : natural-number
> (string-ith "hello world" 1) "e"
procedure
(string-length s) → nat
s : string
> (string-length "hello world") 11
procedure
(string-lower-case? s) → boolean?
s : string
> (string-lower-case? "CAT") #false
procedure
(string-numeric? s) → boolean?
s : string
> (string-numeric? "123") #true
> (string-numeric? "1-2i") #false
procedure
(string-ref s i) → char
s : string i : natural-number
> (string-ref "cat" 2) #\t
procedure
(string-upcase s) → string
s : string
> (string-upcase "cat") "CAT"
> (string-upcase "cAt") "CAT"
procedure
(string-upper-case? s) → boolean?
s : string
> (string-upper-case? "CAT") #true
procedure
(string-whitespace? s) → boolean?
s : string
> (string-whitespace? (string-append " " (string #\tab #\newline #\return))) #true
procedure
(string? x) → boolean?
x : any/c
> (string? "hello world") #true
> (string? 42) #false
procedure
(substring s i j) → string
s : string i : natural-number j : natural-number
> (substring "hello world" 1 5) "ello"
> (substring "hello world" 4) "o world"
5.14 Images
procedure
(image=? i j) → boolean?
i : image j : image
> c1 > (image=? (circle 5 "solid" "green") c1) #false
> (image=? (circle 10 "solid" "green") c1) #true
procedure
(image? x) → boolean?
x : any/c
> c1 > (image? c1) #true
5.15 Misc
procedure
(=~ x y eps) → boolean?
x : number y : number eps : non-negative-real
> (=~ 1.01 1.0 0.1) #true
> (=~ 1.01 1.5 0.1) #false
procedure
(current-milliseconds) → exact-integer
> (current-milliseconds) 1621102678410
value
eof : eof-object?
> eof #<eof>
procedure
(eof-object? x) → boolean?
x : any/c
> (eof-object? eof) #true
> (eof-object? 42) #false
procedure
(eq? x y) → boolean?
x : any/c y : any/c
> (eq? (cons 1 '()) (cons 1 '())) #false
> one (list 1)
> (eq? one one) #true
procedure
(equal? x y) → boolean?
x : any/c y : any/c
> (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
> (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
> (eqv? (cons 1 '()) (cons 1 '())) #false
> one (list 1)
> (eqv? one one) #true
procedure
(error x ...) → void?
x : any/c
> zero 0
> (if (= zero 0) (error "can't divide by 0") (/ 1 zero)) can't divide by 0
procedure
(exit) → void
procedure
(force v) → any
v : any
procedure
(gensym) → symbol?
> (gensym) 'g7014461
procedure
(identity x) → any
x : any/c
> (identity 42) 42
> (identity c1) > (identity "hello") "hello"
procedure
(promise? x) → boolean?
x : any
procedure
(sleep sec) → void
sec : positive-num
procedure
(struct? x) → boolean?
x : any/c
> (struct? (make-posn 1 2)) #true
> (struct? 43) #false
procedure
(void) → void?
> (void)
procedure
(void? x) → boolean?
x : any
> (void? (void)) #true
> (void? 42) #false
5.16 Numbers (relaxed conditions)
procedure
(* x ...) → number
x : number
> (* 5 3) 15
> (* 5 3 2) 30
> (* 2) 2
> (*) 1
procedure
(+ x ...) → number
x : number
> (+ 2/3 1/16) 35/48
> (+ 3 2 5 8) 18
> (+ 1) 1
> (+) 0
procedure
(/ x y ...) → number
x : number y : number
> (/ 12 2) 6
> (/ 12 2 3) 2
> (/ 3) 1/3
5.17 String (relaxed conditions)
procedure
(string-append s ...) → string
s : string
> (string-append "hello" " " "world" " " "good bye") "hello world good bye"
procedure
(string-ci<=? s t x ...) → boolean?
s : string t : string x : string
> (string-ci<=? "hello" "WORLD" "zoo") #true
procedure
(string-ci<? s t x ...) → boolean?
s : string t : string x : string
> (string-ci<? "hello" "WORLD" "zoo") #true
procedure
(string-ci=? s t x ...) → boolean?
s : string t : string x : string
> (string-ci=? "hello" "HellO") #true
procedure
(string-ci>=? s t x ...) → boolean?
s : string t : string x : string
> (string-ci>? "zoo" "WORLD" "hello") #true
procedure
(string-ci>? s t x ...) → boolean?
s : string t : string x : string
> (string-ci>? "zoo" "WORLD" "hello") #true
procedure
(string<=? s t x ...) → boolean?
s : string t : string x : string
> (string<=? "hello" "hello" "world" "zoo") #true
procedure
(string<? s t x ...) → boolean?
s : string t : string x : string
> (string<? "hello" "world" "zoo") #true
procedure
(string=? s t x ...) → boolean?
s : string t : string x : string
> (string=? "hello" "world") #false
> (string=? "bye" "bye") #true
procedure
(string>=? s t x ...) → boolean?
s : string t : string x : string
> (string>=? "zoo" "zoo" "world" "hello") #true
procedure
(string>? s t x ...) → boolean?
s : string t : string x : string
> (string>? "zoo" "world" "hello") #true
5.18 Posn
procedure
(posn) → signature
5.19 Higher-Order Functions
procedure
(andmap p? l ...) → boolean
p? : (X ... -> boolean) l : (listof X)
(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)) #true
> (andmap even? '()) #true
> (define (small-enough? x) (< x 3)) small-enough?:this name was defined previously and cannot be re-defined
> (andmap small-enough? '(0 1 2)) #true
> (define (and-satisfies? x f) (f x)) and-satisfies?:this name was defined previously and cannot be re-defined
> (andmap and-satisfies? (list 0 1 2) (list odd? even? positive?)) #false
procedure
(apply f x-1 ... l) → Y
f : (X-1 ... X-N -> Y) x-1 : X-1 l : (list X-i+1 ... X-N)
(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)
> (argmax second '((sam 98) (carl 78) (vincent 93) (asumu 99))) (list 'asumu 99)
procedure
(argmin f l) → X
f : (X -> real) l : (listof X)
> (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)
(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)
> (define (diagonalize i) (local ((define (off j) (if (= i j) 1 0))) (build-list 3 off))) diagonalize:this name was defined previously and cannot be re-defined
> (build-list 3 diagonalize) (list (list 1 0 0) (list 0 1 0) (list 0 0 1))
procedure
(build-string n f) → string
n : nat f : (nat -> char)
(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"
> (define (starting-at-a x) (integer->char (+ 65 x))) starting-at-a:this name was defined previously and cannot be re-defined
> (build-string 26 starting-at-a) "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
procedure
(compose f g) → (X -> Z)
f : (Y -> Z) g : (X -> Y)
(compose f g)
(define (f-after-g x) (f (g x)))
> (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)
> (filter odd? '(0 1 2 3 4 5 6 7 8 9)) (list 1 3 5 7 9)
> (define (large-enough? x) (>= x 3)) large-enough?:this name was defined previously and cannot be re-defined
> (filter large-enough? '(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 f base (list x-1 ... x-n) (list y-1 ... y-n)) = (f x-n y-n ... (f x-1 y-1 base))
> (foldl + 0 '(0 1 2 3 4 5 6 7 8 9)) 45
> (foldl cons '() '(a b c)) (list 'c 'b 'a)
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)) 45
> (define (append-rests f r) (append (rest f) r)) append-rests:this name was defined previously and cannot be re-defined
> (foldr append-rests '() '((1 a) (2 b c) (3 d e f))) (list 'a 'b 'c 'd 'e 'f)
> (define (add-two-lists x y r) (+ x y r)) add-two-lists:this name was defined previously and cannot be re-defined
> (foldr add-two-lists 0 '(1 2 3) '(10 11 12)) 39
procedure
(map f l ...) → (listof Z)
f : (X ... -> Z) l : (listof X)
(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)) (list 4 #i-3.01 1.4)
> (define (tag-with-a x) (list "a" (+ x 1))) tag-with-a:this name was defined previously and cannot be re-defined
> (map tag-with-a (list 3 -4.01 2/5)) (list (list "a" 4) (list "a" #i-3.01) (list "a" 1.4))
> (define (add-and-multiply x y) (+ x (* x y))) add-and-multiply:this name was defined previously and cannot be re-defined
> (map add-and-multiply (list 3 -4 2/5) '(1 2 3)) (list 6 -12 1.6)
procedure
(memf p? l) → (union #false (listof X))
p? : (X -> any) l : (listof X)
> (memf odd? '(2 4 6 3 8 0)) (list 3 8 0)
procedure
(ormap p? l ...) → boolean
p? : (X ... -> boolean) l : (listof X)
(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)) #true
> (ormap even? '()) #false
> (define (a-small-one? x) (< x 3)) a-small-one?:this name was defined previously and cannot be re-defined
> (ormap a-small-one? '(6 7 8 1 5)) #true
> (define (or-satisfies? x f) (f x)) or-satisfies?:this name was defined previously and cannot be re-defined
> (ormap or-satisfies? (list 0 1 2) (list odd? even? positive?)) #true
procedure
(procedure? x) → boolean?
x : any
> (procedure? cons) #true
> (procedure? add1) #true
> (define (my-function x) x) my-function:this name was defined previously and cannot be re-defined
> (procedure? my-function) #true
procedure
(quicksort l comp) → (listof X)
l : (listof X) comp : (X X -> boolean)
> (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)
> (sort '(6 7 2 1 3 4 0 5 9 8) <) (list 0 1 2 3 4 5 6 7 8 9)
5.20 Reading and Printing
procedure
(display x) → void
x : any
> (display 10) 10
> (display "hello") hello
> (display 'hello) hello
procedure
(newline) → void
procedure
(pretty-print x) → void
x : any
> (pretty-print '((1 2 3) ((a) ("hello world" #true) (((false "good bye")))))) ((1 2 3) ((a) ("hello world" #true) (((false "good bye")))))
> (pretty-print (build-list 10 (lambda (i) (build-list 10 (lambda (j) (= i j))))))
((#true #false #false #false #false #false #false #false #false #false)
(#false #true #false #false #false #false #false #false #false #false)
(#false #false #true #false #false #false #false #false #false #false)
(#false #false #false #true #false #false #false #false #false #false)
(#false #false #false #false #true #false #false #false #false #false)
(#false #false #false #false #false #true #false #false #false #false)
(#false #false #false #false #false #false #true #false #false #false)
(#false #false #false #false #false #false #false #true #false #false)
(#false #false #false #false #false #false #false #false #true #false)
(#false #false #false #false #false #false #false #false #false #true))
procedure
(print x) → void
x : any
> (print 10) 10
> (print "hello") "hello"
> (print 'hello) 'hello
procedure
(printf f x ...) → void
f : string x : any
procedure
(read) → sexp
procedure
(with-input-from-file f p) → any
f : string p : (-> any)
procedure
(with-input-from-string s p) → any
s : string p : (-> any)
> (with-input-from-string "hello" read) 'hello
> (string-length (symbol->string (with-input-from-string "hello" read))) 5
procedure
(with-output-to-file f p) → any
f : string p : (-> any)
procedure
(with-output-to-string p) → any
p : (-> any)
> (with-output-to-string (lambda () (display 10))) "10"
procedure
(write x) → void
x : any
> (write 10) 10
> (write "hello") "hello"
> (write 'hello) hello
5.21 Vectors
procedure
(build-vector n f) → (vectorof X)
n : nat f : (nat -> X)
> (build-vector 5 add1) (vector 1 2 3 4 5)
procedure
(list->vector l) → (vectorof X)
l : (listof X)
> (list->vector (list "hello" "world" "good" "bye")) (vector "hello" "world" "good" "bye")
procedure
(make-vector n x) → (vectorof X)
n : number x : X
> (make-vector 5 0) (vector 0 0 0 0 0)
procedure
(vector x ...) → (vector X ...)
x : X
> (vector 1 2 3 -1 -2 -3) (vector 1 2 3 -1 -2 -3)
procedure
(vector->list v) → (listof X)
v : (vectorof X)
> (vector->list (vector 'a 'b 'c)) (list 'a 'b 'c)
procedure
(vector-length v) → nat
v : (vector X)
> v (vector "a" "b" "c" "d" "e")
> (vector-length v) 5
procedure
(vector-ref v n) → X
v : (vector X) n : nat
> v (vector "a" "b" "c" "d" "e")
> (vector-ref v 3) "d"
procedure
(vector-set! v n x) → void
v : (vectorof X) n : nat x : X
> v (vector "a" "b" "c" "d" "e")
> (vector-set! v 3 77) > v (vector "a" "b" "c" 77 "e")
procedure
(vector? x) → boolean
x : any
> v (vector "a" "b" "c" 77 "e")
> (vector? v) #true
> (vector? 42) #false
5.22 Boxes
procedure
(box x) → box?
x : any/c
> (box 42) (box 42)
procedure
(box? x) → boolean?
x : any/c
> b (box 33)
> (box? b) #true
> (box? 42) #false
procedure
(set-box! b x) → void
b : box? x : any/c
> b (box 33)
> (set-box! b 31) > b (box 31)
procedure
(unbox b) → any
b : box?
> b (box 31)
> (unbox b) 31
5.23 Hash Tables
procedure
(hash-copy h) → hash
h : hash
procedure
(hash-count h) → integer
h : hash
> ish (make-immutable-hash (list (cons 'b 69) (cons 'r 999) (cons 'c 42) (cons 'e 61)))
> (hash-count ish) 4
procedure
(hash-eq? h) → boolean
h : hash
> hsh (make-hash (list (cons 'c 42) (cons 'r 999) (cons 'b 69) (cons 'e 61)))
> (hash-eq? hsh) #false
> heq (make-hasheq (list (cons 'r 999) (cons 'e 61) (cons 'b 69) (cons 'c 42)))
> (hash-eq? heq) #true
procedure
(hash-equal? h) → boolean
h : hash?
> ish (make-immutable-hash (list (cons 'b 69) (cons 'r 999) (cons 'c 42) (cons 'e 61)))
> (hash-equal? ish) #true
> ieq (make-immutable-hasheq (list (cons 'b 69) (cons 'r 999) (cons 'c 42) (cons 'e 61)))
> (hash-equal? ieq) #false
procedure
(hash-eqv? h) → boolean
h : hash
> heq (make-hasheq (list (cons 'r 999) (cons 'e 61) (cons 'b 69) (cons 'c 42)))
> (hash-eqv? heq) #false
> heqv (make-hasheqv (list (cons 'r 999) (cons 'e 61) (cons 'b 69) (cons 'c 42)))
> (hash-eqv? heqv) #true
procedure
(hash-for-each h f) → void?
h : (hash X Y) f : (X Y -> any)
> hsh (make-hash (list (cons 'c 42) (cons 'r 999) (cons 'b 69) (cons 'e 61)))
> (hash-for-each hsh (lambda (ky vl) (hash-set! hsh ky (+ vl 1)))) > hsh (make-hash (list (cons 'c 43) (cons 'r 1000) (cons 'b 70) (cons 'e 62)))
procedure
(hash-has-key? h x) → boolean
h : (hash X Y) x : X
> ish (make-immutable-hash (list (cons 'b 69) (cons 'r 999) (cons 'c 42) (cons 'e 61)))
> (hash-has-key? ish 'b) #true
> hsh (make-hash (list (cons 'c 43) (cons 'r 1000) (cons 'b 70) (cons 'e 62)))
> (hash-has-key? hsh 'd) #false
procedure
(hash-map h f) → (listof Z)
h : (hash X Y) f : (X Y -> Z)
> ish (make-immutable-hash (list (cons 'b 69) (cons 'r 999) (cons 'c 42) (cons 'e 61)))
> (hash-map ish list) (list (list 'b 69) (list 'r 999) (list 'c 42) (list 'e 61))
procedure
(hash-ref h k) → Y
h : (hash X Y) k : X
> hsh (make-hash (list (cons 'c 43) (cons 'r 1000) (cons 'b 70) (cons 'e 62)))
> (hash-ref hsh 'b) 70
procedure
(hash-ref! h k v) → Y
h : (hash X Y) k : X v : Y
> hsh (make-hash (list (cons 'c 43) (cons 'r 1000) (cons 'b 70) (cons 'e 62)))
> (hash-ref! hsh 'd 99) 99
> hsh (make-hash (list (cons 'c 43) (cons 'r 1000) (cons 'b 70) (cons 'e 62) (cons 'd 99)))
procedure
(hash-remove h k) → (hash X Y)
h : (hash X Y) k : X
> ish (make-immutable-hash (list (cons 'b 69) (cons 'r 999) (cons 'c 42) (cons 'e 61)))
> (hash-remove ish 'b) (make-immutable-hash (list (cons 'c 42) (cons 'r 999) (cons 'e 61)))
procedure
(hash-remove! h x) → void
h : (hash X Y) x : X
> hsh (make-hash (list (cons 'c 43) (cons 'r 1000) (cons 'b 70) (cons 'e 62) (cons 'd 99)))
> (hash-remove! hsh 'r) > hsh (make-hash (list (cons 'c 43) (cons 'b 70) (cons 'e 62) (cons 'd 99)))
procedure
(hash-set h k v) → (hash X Y)
h : (hash X Y) k : X v : Y
> (hash-set ish 'a 23) (make-immutable-hash (list (cons 'b 69) (cons 'r 999) (cons 'c 42) (cons 'a 23) (cons 'e 61)))
procedure
(hash-set! h k v) → void?
h : (hash X Y) k : X v : Y
> hsh (make-hash (list (cons 'c 43) (cons 'b 70) (cons 'e 62) (cons 'd 99)))
> (hash-set! hsh 'a 23) > hsh (make-hash (list (cons 'c 43) (cons 'b 70) (cons 'e 62) (cons 'd 99) (cons 'a 23)))
procedure
(hash-update h k f) → (hash X Y)
h : (hash X Y) k : X f : (Y -> Y)
> (hash-update ish 'b (lambda (old-b) (+ old-b 1))) (make-immutable-hash (list (cons 'b 70) (cons 'r 999) (cons 'c 42) (cons 'e 61)))
procedure
(hash-update! h k f) → void?
h : (hash X Y) k : X f : (Y -> Y)
> hsh (make-hash (list (cons 'c 43) (cons 'b 70) (cons 'e 62) (cons 'd 99) (cons 'a 23)))
> (hash-update! hsh 'b (lambda (old-b) (+ old-b 1))) > hsh (make-hash (list (cons 'c 43) (cons 'b 71) (cons 'e 62) (cons 'd 99) (cons 'a 23)))
procedure
(hash? x) → boolean
x : any
> ish (make-immutable-hash (list (cons 'b 69) (cons 'r 999) (cons 'c 42) (cons 'e 61)))
> (hash? ish) #true
> (hash? 42) #false
procedure
(make-hash) → (hash X Y)
> (make-hash) (make-hash)
> (make-hash '((b 69) (e 61) (i 999))) (make-hash (list (cons 'i 999) (cons 'b 69) (cons 'e 61)))
procedure
(make-hasheq) → (hash X Y)
> (make-hasheq) (make-hasheq)
> (make-hasheq '((b 69) (e 61) (i 999))) (make-hasheq (list (cons 'e 61) (cons 'b 69) (cons 'i 999)))
procedure
(make-hasheqv) → (hash X Y)
> (make-hasheqv) (make-hasheqv)
> (make-hasheqv '((b 69) (e 61) (i 999))) (make-hasheqv (list (cons 'e 61) (cons 'b 69) (cons 'i 999)))
procedure
(make-immutable-hash) → (hash X Y)
> (make-immutable-hash) (make-immutable-hash)
> (make-immutable-hash '((b 69) (e 61) (i 999))) (make-immutable-hash (list (cons 'b 69) (cons 'e 61) (cons 'i 999)))
procedure
(make-immutable-hasheq) → (hash X Y)
> (make-immutable-hasheq) (make-immutable-hasheq)
> (make-immutable-hasheq '((b 69) (e 61) (i 999))) (make-immutable-hasheq (list (cons 'b 69) (cons 'e 61) (cons 'i 999)))
procedure
(make-immutable-hasheqv) → (hash X Y)
> (make-immutable-hasheqv) (make-immutable-hasheqv)
> (make-immutable-hasheqv '((b 69) (e 61) (i 999))) (make-immutable-hasheqv (list (cons 'b 69) (cons 'e 61) (cons 'i 999)))
5.24 Signatures
value
Any : signature?
value
Boolean : signature?
value
Char : signature?
procedure
(ConsOf first-sig rest-sig) → signature?
first-sig : signature? rest-sig : signature?
value
EmptyList : signature?
value
False : signature?
value
Integer : signature?
value
Natural : signature?
value
Number : signature?
value
Rational : signature?
value
Real : signature?
value
String : signature?
value
Symbol : signature?
value
True : signature?