4 Intermediate Student with Lambda
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 | |||
definition | = | (define (name variable variable ...) expr) | ||
| | (define name expr) | |||
| | (define-struct name (name ...)) | |||
expr | = | (lambda (variable variable ...) expr) | ||
| | (λ (variable variable ...) expr) | |||
| | (local [definition ...] expr) | |||
| | (letrec ([name expr] ...) expr) | |||
| | (let ([name expr] ...) expr) | |||
| | (let* ([name expr] ...) expr) | |||
| | (expr 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 | |||
| | prim-op | |||
| | ’quoted | |||
| | ‘quasiquoted | |||
| | ’() | |||
| | number | |||
| | boolean | |||
| | string | |||
| | character | |||
| | (signature signature-form) | |||
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-member-of expr expr ...) | |||
| | (check-range expr expr expr) | |||
| | (check-satisfied 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) |
4.1 Pre-defined Variables
4.2 Template Variables
syntax
syntax
syntax
syntax
syntax
4.3 Syntax for Intermediate with Lambda
syntax
(lambda (variable variable ...) expression)
syntax
(λ (variable variable ...) expression)
syntax
(expression 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
(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)
4.4 Common Syntaxes
The following syntaxes behave the same in the Intermediate with Lambda level as they did in the Intermediate Student level.
syntax
(define (name variable variable ...) expression)
syntax
(define name expression)
syntax
‘name
syntax
‘part
syntax
(quasiquote name)
syntax
(quasiquote part)
syntax
,expression
syntax
(unquote expression)
Under multiple quasiquotes, ,expression is really the literal ,expression, decrementing the quasiquote count by one for expression.
syntax
,@expression
syntax
(unquote-splicing expression)
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-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.
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.
4.5 Pre-defined Functions
4.6 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 |
syntax
(signature signature-form)
4.6.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:
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)
syntax
(predicate expression)
4.6.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)))
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.
4.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 : 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) 1730011024
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)) #i3.0
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 : (and/c natural? positive?)
> (random 42) 18
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
4.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
4.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
4.10 Lists
procedure
(append l ...) → (listof any)
l : (listof any)
> (append (cons 1 (cons 2 '())) (cons "a" (cons "b" '()))) (list 1 2 "a" "b")
> (append) '()
procedure
(assoc x l) → (union (listof any) #false)
x : any/c 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 y) → list?
x : any/c y : list?
> (cons 1 '()) (cons 1 '())
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
(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?
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) → list?
x : any/c l : list?
> x (list 2 "hello" #true)
> (list* 4 3 x) (list 4 3 2 "hello" #true)
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/c
> (list? 42) #false
> (list? '()) #true
> (list? (cons 1 (cons 2 '()))) #true
procedure
(make-list i x) → list?
i : natural? 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
4.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/c
p : posn
> p (make-posn 2 -3)
> (posn-x p) 2
procedure
(posn-y p) → any/c
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
4.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
4.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? c : char
> (make-string 3 #\d) "ddd"
procedure
(replicate i s) → string
i : natural? 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") -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?
> (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?
> (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? j : natural?
> (substring "hello world" 1 5) "ello"
> (substring "hello world" 1 8) "ello wo"
> (substring "hello world" 4) "o world"
4.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
4.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
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
(identity x) → any/c
x : any/c
> (identity 42) 42
> (identity c1) > (identity "hello") "hello"
procedure
(struct? x) → boolean?
x : any/c
> (struct? (make-posn 1 2)) #true
> (struct? 43) #false
4.16 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?
4.17 Numbers (relaxed conditions)
4.18 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
4.19 Posn
procedure
(posn) → signature
4.20 Higher-Order Functions
4.21 Numbers (relaxed conditions plus)
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
procedure
(= x ...) → number
x : number
> (= 10 10) #true
> (= 11) #true
> (= 0) #true
4.22 Higher-Order Functions (with Lambda)
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
> threshold 3
> (andmap (lambda (x) (< x threshold)) '(0 1 2)) #true
> (andmap even? '()) #true
> (andmap (lambda (x f) (f x)) (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)
> 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)
(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)
(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)
> (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 f base (list x-1 ... x-n) (list x-1 ... x-n)) = (f x-n y-n ... (f x-1 y-1 base))
> (foldl + 0 '(0 1 2 3 4 5 6 7 8 9)) 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)
> (foldl (lambda (x y r) (+ x y r)) 0 '(1 2 3) '(10 11 12)) 39
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
> 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)
> (foldr (lambda (x y r) (+ x y r)) 0 '(1 2 3) '(10 11 12)) 39
procedure
(for-each f l ...) → void?
f : (any ... -> any) l : (listof any)
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)))
> (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)))
> (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
> threshold 3
> (ormap (lambda (x) (< x threshold)) '(6 7 8 1 5)) #true
> (ormap even? '()) #false
> (ormap (lambda (x f) (f x)) (list 0 1 2) (list odd? even? positive?)) #true
procedure
(procedure? x) → boolean?
x : any
> (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)
> (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)