ProgrammingLanguagesB Flashcards
Why do you need to write #lang racket at the top of all your Racket files?
It is so DrRacket will interpret the code as Racket code.
Simple racket file
lang racket
(provide (all-defined-out))
(define s “hello”)
Define variable x and assign it 3
(define x 3)
Define variable y and assign it x+5
(define y (+ x 5))
Define function that gets number and returns it’s square
(define square1
(lambda (x)
(* x x)))
; OR
(define (square1 x) (* x x))
Example of pow function(RECURSIVE)
(define (pow1 x y)
(if (= y 0)
1
(* x (pow1 x (- y 1)))))
Example of Currying
(define pow2
(lambda (x)
(lambda (y)
(pow1 x y))))
(define three-to-the (pow2 3))
(three-to-the 5)
List processing
;Empty list: null ;Cons constructor: cons ;Access head of list: car ;Access tail of list: cdr ;Check for empty: NULL? ;Lists without cons: (list a1 a2 a3 a4 ... an)
Racket syntax. A term is either a:
- an atom, e.g. #t, #f, 34, “hi”, null, 4.0, x…
- a special form, e.g., define, lambda, if
- a sequence of terms in parens: (t1 t2 … tn)
Cond operator syntax
(cond [e1a e1b]
[e2a e2b]
[e3a e3b]
...
[eNa eNb])
- Good style: eNa should be #t
True and False in Racket
#t - True #f - False
Local bindings in Racket
let
let*
letrec
define
Let
can bind any number of local variables
Let example
(define (silly-double x)
(let ([x (+ x 3)]
[y (+ x 2)])
(+ x y -5)))
;> (silly-double 2)
;9
Let*
The expressions are evaluated in the environment produced from previous bindings
Let* example
(define (silly-double-2 x)
(let* ([x (+ x 3)]
[y (+ x 2)])
(+ x y)))
;> (silly-double-2 2)
;12
Letrec
the expressions are evaluated in the environment that includes all the bindings. Needed for mutual recursion
Letrec example
(define (silly-triple x)
(letrec ([y (+ x 2)]
[f (lambda(z) (+ z y w x))]
[w (+ x 7)])
(f -9)))Mutation with !set
(set! x 45) ; changes value of x
Type of lists
Proper: (cons 1 (cons 2 (cons 3 null)))
Improper: (cons 1 (cons 2 3))
mcons
mutable cons
mcons example
> (define y (mcons 14 null)) > (define z y) > (mcar y) 14 > (set-mcar! y 47) > y (mcons 47 '()) > z (mcons 47 '())
mcons and proper-list
mcons cannot be a proper list
Thunk
A zero-argument function used to delay evaluation
Thunk example
(define (my-if x y z)
(if x (y) (z)))
(define (fact n)
(my-if (= n 0)
(lambda() 1)
(lambda() (* n (fact (- n 1))))))
Streams
A stream is an infinite sequence of values
Streams example
; 1 1 1 1 1 1 1
(define ones (lambda () (cons 1 ones)))
; 1 2 3 4 5
(define (f x) (cons x (lambda () (f (+ x 1)))))
; using
(car (f 5)) ; 5
(car ((cdr (f 5)))) ; 6
Memoization
Hold values in function for already calculated results
Memoization example
(define fibonacci3
(letrec([memo null]
[f (lambda (x)
(let ([ans (assoc x memo)])
(if ans
(cdr ans)
(let ([new-ans (if (or (= x 1) (= x 2))
1
(+ (f (- x 1))
(f (- x 2))))])
(begin
(set! memo (cons (cons x new-ans) memo))
new-ans)))))])
f))
Macros define-syntax
(define-syntax mif
(syntax-rules (then else)
[(mif e1 then e2 else e3)
(if e1 e2 e3)]))
what did (struct foo (bar baz quux) #:transparent)?
; defines a new kind of thing and introduce ; several new functions (foo e1 e2 e3) ; return "a foo" with ; bar, baz, quux fields holding results ; of evaluating e1, e2 and e3 (foo? e) ; evaluates e and returns #t ; if and only if the result is something ; that was made with the foo function (foo-bar e) (foo-baz e) (foo-quux e)
#:transparent is an optional attribute on struct definitions - for us, prints struct values in the REPL rather then hiding them which is convenient for debugging homework #:mutable - provides more functions - can decide if each struct supports mutation, with usual advantages and disadvantages - mcons is just predefined mutable struct
