smoltutor

Quiz 1

arithmetic operators

(deffun (f o) (o 1 1))
(f +)

0 as condition

(if 0 #t #f)

redeclare var using defvar

(defvar x 0)
(defvar y x)
(defvar x 2)
x
y

expose local defvar

(defvar x 42)
(deffun (create)
  (defvar y 42)
  y)
(create)
(equal? x y)

pair?

(pair? (pair 1 2))
(pair? (ivec 1 2))
(pair? '#(1 2))
(pair? '(1 2))

let* and let

(let* ([v 1]
       [w (+ v 2)]
       [y (* w w)])
  (let ([v 3]
        [y (* v w)])
    y))

defvar and let

(defvar x 3)
(defvar y (let ([y 6] [x 5]) x))
(* x y)

fun-id equals to arg-id

(deffun (f f) f)
(f 5)

scoping rule of let

(let ([x 4]
      [y (+ x 10)])
  y)

the right component of ivec

(right (ivec 1 2 3))

identifiers

(defvar x 5)
(deffun (reassign var_name new_val)
  (defvar var_name new_val)
  (pair var_name x))
(reassign x 6)
x

defvar, deffun, and let

(defvar a 1)
(deffun (what-is-a) a)
(let ([a 2])
  (ivec
   (what-is-a)
   a))

syntax pitfall

(deffun (f a b) a + b)
(f 5 10)

Quiz 2

circularity

(defvar x (mvec 2 3))
(set-right! x x)
(set-left! x x)
x

eval order

(defvar x 0)
(ivec x (begin (set! x 1) x) x)

mvec as arg

(defvar x (mvec 1 2))
(deffun (f x)
  (vset! x 0 0))
(f x)
x

var as arg

(defvar x 12)
(deffun (f x)
  (set! x 0))
(f x)
x

seemly aliasing a var

(defvar x 5)
(deffun (set1 x y)
  (set! x y))
(deffun (set2 a y)
  (set! x y))
(set1 x 6)
x
(set2 x 7)
x

mutable var in vec

(defvar x 3)
(defvar v (mvec 1 2 x))
(set! x 4)
v
x

aliasing mvec in mvec

(defvar v (mvec 1 2 3 4))
(defvar vv (mvec v v))(vset! (vref vv 1) 0 100)
vv

vset! in let

(defvar x (mvec 123))
(let ([y x])
  (vset! y 0 10))
x

set! in let

(defvar x 123)
(let ([y x])
  (set! y 10))
x

seemingly aliasing a var again

(defvar x 10)
(deffun (f y z)
  (set! x z)
  y)
(f x 20)
x

Quiz 3

fun returns lambda

(deffun (f x)
  (lambda (y) (+ x y)))
((f 2) 1)

filter gt

(filter (lambda (n) (> 3 n)) '(1 2 3 4 5))

fun and state 1/4

(defvar x 1)
(defvar f
  (lambda (y)
    (+ x y)))
(set! x 2)
(f x)

fun and state 2/4

(defvar x 1)
(deffun (f y)
  (+ x y))
(set! x 2)
(f x)

fun and state 3/4

(defvar x 1)
(defvar f
  (lambda (y)
    (+ x y)))
(let ([x 2])
  (f x))

fun and state 4/4

(defvar x 1)
(deffun (f y)
  (+ x y))
(let ([x 2])
  (f x))

eval order

(deffun (f x) (+ x 1))
(deffun (new-f x) (* x x))
(f (begin
     (set! f new-f)
     10))

Counter

(deffun (make-counter)
  (let ([count 0])
    (lambda ()
      (begin
        (set! count (+ count 1))
        count))))
(defvar f (make-counter))
(defvar g (make-counter))
(f)
(g)
(f)
(f)
(g)

hof + set!

(defvar y 3)
(+ ((lambda (x) (set! y 0) (+ x y)) 1)
   y)

filter

(defvar l (list (ivec) (ivec 1) (ivec 2 3)))
(filter (lambda (x) (vlen x)) l)

eq? fun fun 1/3

(eq? (λ (x) (+ x x))
     (λ (x) (+ x x)))

eq? fun fun 2/3

(deffun (f x) (+ x x))
(deffun (g x) (+ x x))
(eq? f g)

eq? fun fun 3/3

(deffun (f x) (+ x x))
(deffun (g) f)
(eq? f (g))

equal? fun fun

(deffun (f) (lambda () 1))
(equal? (f) (f))