ProgrammingLanguagesB

Question 1

Why do you need to write #lang racket at the top of all your Racket files?

Answer 1

It is so DrRacket will interpret the code as Racket code.

Question 2

Simple racket file

Answer 2

lang racket

(provide (all-defined-out))

(define s “hello”)

Question 3

Define variable x and assign it 3

Answer 3

(define x 3)

Question 4

Define variable y and assign it x+5

Answer 4

(define y (+ x 5))

Question 5

Define function that gets number and returns it’s square

Answer 5

(define square1
(lambda (x)
(* x x)))

; OR

(define (square1 x) (* x x))

Question 6

Example of pow function(RECURSIVE)

Answer 6

(define (pow1 x y)
(if (= y 0)
1
(* x (pow1 x (- y 1)))))

Question 7

Example of Currying

Answer 7

(define pow2
(lambda (x)
(lambda (y)
(pow1 x y))))

(define three-to-the (pow2 3))
(three-to-the 5)

Question 8

List processing

Answer 8

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

Question 9

Racket syntax. A term is either a:

Answer 9

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

Question 10

Cond operator syntax

Answer 10

(cond [e1a e1b]
           [e2a e2b]
           [e3a e3b]
                  ...
           [eNa eNb])

• Good style: eNa should be #t

Question 11

True and False in Racket

Answer 11

#t - True
#f - False

Question 12

Local bindings in Racket

Answer 12

let
let*
letrec
define

Question 13

Let

Answer 13

can bind any number of local variables

Question 14

Let example

Answer 14

(define (silly-double x)
(let ([x (+ x 3)]
[y (+ x 2)])
(+ x y -5)))

;> (silly-double 2)
;9

Question 15

Let*

Answer 15

The expressions are evaluated in the environment produced from previous bindings

Question 16

Let* example

Answer 16

(define (silly-double-2 x)
(let* ([x (+ x 3)]
[y (+ x 2)])
(+ x y)))

;> (silly-double-2 2)
;12

Question 17

Letrec

Answer 17

the expressions are evaluated in the environment that includes all the bindings. Needed for mutual recursion

Question 18

Letrec example

Answer 18

(define (silly-triple x)
  (letrec ([y (+ x 2)]
           [f (lambda(z) (+ z y w x))]
           [w (+ x 7)])
    (f -9)))

Question 19

Mutation with !set

Answer 19

(set! x 45) ; changes value of x

Question 20

Type of lists

Answer 20

Proper: (cons 1 (cons 2 (cons 3 null)))
Improper: (cons 1 (cons 2 3))

Question 21

mcons

Answer 21

mutable cons

Question 22

mcons example

Answer 22

> (define y (mcons 14 null))
> (define z y)
> (mcar y)
14
> (set-mcar! y 47)
> y
(mcons 47 '())
> z
(mcons 47 '())

Question 23

mcons and proper-list

Answer 23

mcons cannot be a proper list

Question 24

Thunk

Answer 24

A zero-argument function used to delay evaluation

Question 25

Thunk example

Answer 25

(define (my-if x y z)
(if x (y) (z)))

(define (fact n)
(my-if (= n 0)
(lambda() 1)
(lambda() (* n (fact (- n 1))))))

Question 26

Streams

Answer 26

A stream is an infinite sequence of values

Question 27

Streams example

Answer 27

; 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

Question 28

Memoization

Answer 28

Hold values in function for already calculated results

Question 29

Memoization example

Answer 29

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

Question 30

Macros define-syntax

Answer 30

(define-syntax mif
(syntax-rules (then else)
[(mif e1 then e2 else e3)
(if e1 e2 e3)]))

Question 31

what did (struct foo (bar baz quux) #:transparent)?

Answer 31

; 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