Evaluation of {with {x 3} {+ x x}} from page 76 in PLAI

Question

I am studying PLAI's Chapter8 "Implementing Laziness", and finished the following CFAE/L:

    (define-type CFAE/L
      [num (n number?)]
      [add (lhs CFAE/L?)(rhs CFAE/L?)]
      [id (name symbol?)]
      [fun (param symbol?)(body CFAE/L?)]
      [app (fun-expr CFAE/L?)(arg-expr CFAE/L?)])

    (define-type CFAE/L-Value
      [numV (n number?)]
      [closureV (param symbol?)
            (body CFAE/L?)
            (env Env?)]
      [exprV (expr CFAE/L?)
         (env Env?)])

      (define-type Env
        [mtSub]
        [aSub (name symbol?)(value CFAE/L-Value?)(env Env?)])

    (define (num+ x y) ;; need this because we can't just use Scheme + to add FAE-values
      (numV (+ (numV-n x) (numV-n y))))

    (define (parse sexp)
      (cond [(number? sexp) (num sexp)]
        [(symbol? sexp) (id sexp)]
        [(list? sexp)
         (case (first sexp)
           ((+)
            (add (parse (second sexp))
                 (parse (third sexp))))
           ((with)                                 
            (app (fun (first (second sexp))        
                      (parse (third sexp)))        
                 (parse (second (second sexp)))))  
           ((fun)                                  
            (fun (first (second sexp))             
                 (parse (third sexp))))            
           (else
            (app (parse (first sexp))            
                 (parse (second sexp)))))]))
   (define (lookup name env)
      (type-case Env env
        [mtSub() (error 'lookup "no binding for identifier")]
        [aSub (bound-name bound-value rest-ds)
          (if (symbol=? bound-name name)
              bound-value
              (lookup name rest-ds))]))

   (define (interp expr env)
      (type-case CFAE/L expr
        [num (n) (numV n)]
        [add (l r)(num+ (interp l env)(interp r env))]
        [id (v) (lookup v env)]
        [fun (bound-id bound-body)
         (closureV bound-id bound-body env)]
          [app (fun-expr arg-expr)
         (local ([define fun-val (interp fun-expr env)]
                 [define arg-val (exprV arg-expr env)])
           (interp (closureV-body fun-val)
                   (aSub (closureV-param fun-val)
                         arg-val
                         (closureV-env fun-val))))]))

According to this interpreter, I want to evaluate the page76's

{with {x 3} {+ x x}}

(1) when typing:

(interp (parse '{with {x 3} {+ x x}}) {mtSub}) I got errors as below:

numV-n: contract violation, expected: numV?, given: (exprV (num 3) (mtSub)) contract from: numV-n, blaming: use contract: (-> numV? number?) at: /study/lisp/plai/chapter8.scm:10.9

(2) I wanted to write down the steps by hand for understanding page76's description as below: "The interpreter evaluates each x in the body to an expression closure (because that’s what is bound to x in the environment), but the addition procedure cannot handle these: it (and similarly any other arithmetic primitive) needs to know exactly which number the expression closure corresponds to.", but I am still not clear about this description after finishing the steps. there are my steps : (interp (parse '(with (x 3) (+ x x))) (mtSub))

step1: (parse '(with (x 3) (+ x x))) => (app (fun 'x (add (id 'x) (id 'x))) (num 3))

   NOTE: fun-exp is (fun 'x (add (id 'x), arg-expr is (num 3)

step2: (cloSureV 'x (add (id 'x) (id 'x)) (mtSub)) (as fun-val)

   and (experV (num 3) (mtSub)) (as arg-val) 

step3: (interp (add (id 'x) (id 'x)) (aSub 'x (num 3) (mtSub)))

Thanks in advance!

Answer 1

Ad 1)

This is the expected behaviour. The error message you got was:

 numV-n: contract violation, 
   expected: numV?, 
   given: (exprV (num 3) (mtSub)) 
   ...

This numV-n was the one in num+. This es explained in the last paragraph of page 75. The primitives such as num+ expected non-closure values, but the value (exprV (num 3) (mtSub)) is the number 3 closed over the empty environment.

Therefore the primitives such as num+ must force the arguments. From page 76:

(define (num+ n1 n2)
    (numV (+ (numV-n (strict n1) ) (numV-n (strict n2) ))))

Ad 2)

Do the explanation of 1) help with 2) ?

ADDED

Why not let the interpreter write out the steps for you?

The quick fix:

(define (interp expr env)
      (displayln (list 'expr expr 'env env))
      (type-case CFAE/L expr

To get more readable output, first write unparse that converts a CFAE/L to a (readable) string.