lambda.scm

(define (deep-map func list)
  "Recursively map function onto sublists"
  (map
    (lambda (x)
      (if (pair? x)
          (deep-map func x)
          (func x))) list))

(define (free-variable-list func)
  (let ((body (caddr func)) (args (cadr func)))
       (print (deep-map (lambda (x) 
                          (if (not (member x args)) x))
                          body))))

(define (list-after l tag)
  (call/cc
    (lambda (ret)
      (map (lambda (x)
        (if (pair? x)
            (if (eq? (car x) tag)
                (ret x)))) l))))

(define (let-transform expr)
  (call/cc
    (lambda (ret)
      (let ((let-statement (list-after expr 'let)))
           (if (null? let-statement)
               (ret #f)
               (let ((args '()) (vals '()))
                    (define (trans params)
                      (if (null? params)
                        (ret (cons `(lambda ,args ,(caddr let-statement)) vals))
                        (begin
                          (set! args (cons (caar params) args))
                          (set! vals (cons (cadar params) vals))
                          (trans (cdr params)))))
                        (trans (cadr let-statement))))))))


             
(define l '(lambda (x y z)
             (let ((m 10) (q 5))
                  (set! m (cons x y))
                  (cons m y))))