tracing-lambda.rkt

#lang racket

(define (expr? e)
  (match e
    [(? number? n) #t]
    [(? symbol? x) #t]
    [`(λ (,(? symbol? x)) ,(? expr? e)) #t]
    [`(,(? expr? e0) ,(? expr? e1)) #t]
    [_ #f]))

;; Closure-creating interpreter
(define (value? v)
  (match v
    [(? number? n) #t]
    [`(closure (λ (,x) ,e) ,env) #t]
    [_ #f]))

(define depth 0)

;; our interpreter takes two arguments:
;; - e, which is an expression
;;   e : expr?
;; - env, which is an environment
;;   env : symbol? → value? (a hash) 
(define (interp e env)
  (match e
    [(? number? n) n]
    [(? symbol? x) (hash-ref env x)]
    [`(λ (,(? symbol? x)) ,(? expr? e-body))
     `(closure (λ (,x) ,e-body) ,env)]
    [`(,(? expr? e0) ,(? expr? e1))
     (match (wrap-interp e0 env)
       [`(closure (λ (,x) ,e-b) ,env+)
        ;; what is the importance of env+ and env being different?
        (wrap-interp e-b (hash-set env+ x (interp e1 env)))])]))

(define (wrap-interp e env)
  (set! depth (add1 depth))
  (display (build-string depth (lambda (_) #\ )))
  (display "→")
  (displayln (format " ~a ~a" (pretty-format e) (pretty-format env)))
  (define v (interp e env))
  (display (build-string depth (lambda (_) #\ )))
  (display "← returning from ")
  (displayln (format " ~a ~a" (pretty-format e) (pretty-format env)))
  (display (build-string depth (lambda (_) #\ )))
  (displayln (format "(Return value is ~a)" (pretty-format v)))
  (set! depth (sub1 depth))
  v)

(wrap-interp '(λ (x) x) (hash))
(wrap-interp '((λ (x) x) (λ (x) x)) (hash))
(wrap-interp '((λ (x) (λ (y) x)) (λ (z) (λ (x) x))) (hash))
(wrap-interp '(((λ (x) (λ (y) x)) (λ (z) (λ (x) x))) (λ (x) (λ (z) z))) (hash))