Q1: 
Transpose:
(define transpose
  (lambda (m)
   (cond
    (null? m ())
    (null? (car m) ())
    (else 
      (cons (append (map car m))  (transpose (map cdr m))))
   )))
or better?
(define transpose
  (lambda (m)
    (apply map list m)))

Q2:
Key: Passing an argument -- don't evaluate. Pass a closure with no formal
arguments.
     Evaluating a identifier -- evaluate the closure, if the identifier
     happens to be an argument.

Q3:  
Types:
t := bool | list <t> | nullT

Type rules
|- false: bool
|- true: bool
|- '(): nullT

nullT <= list<t> // for any t.

|- e : list<t>
---------------
|- car e: t

|- e : list<t>
---------------
|- cdr e: list<t>

|- e: list<t>
------------
null? e : bool
	
|- e: t, t <= t'
--------------------
|- e: t'

|- e1: t, e2 : list<t>
---------------
cons e1 e2 : list <t>

|- e0: bool, e1: tx, e2: tx
------------------------------
|- if (e0) e1 e2: tx



Small step semantics:
-------------------

Value: false | true | '() | list of values

car '(v1, l1) ->v  v1
cdr '(v1, l1) ->v  l1

null? '() ->v true

null? '(l) ->v false

cons v1 l1 ->v  (v1 l1)

e1 ->v e1'
-----------
cons e1 e2 ->v cons e1' e2

e2 ->v e2'
-----------
cons v1 e2 ->v cons v1 e2'


e0 ->v e0'
-----------
if e0 e1 e2 ->v if e0' e1 e2


if true e1 e2 -> e1

if false e1 e2 -> e2