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