Hello

I want to be able to see the values which are visible by some closure (without having to enter the closure with the stepper and look at the ,e output, and I'd like to be able to do that also for compiled code (if compiled with the 'debug option)).

Since in Scheme (or functional languages in general), closures are a common alternative to structures for storing data, they should be as easily inspectable (for debugging purposes at least) as the latter.

Sometimes I'm using ##vector-ref for checking the contents of a closure data structure, but that's rather tedious, since the relationship between the variable name and the index in the structure isn't straight-forward. (See below for an example where I'm trying to get at the relevant information through manual inspection.)

I'm imagining something like:

(procedure-prettyprint/environment someclosure)

#<procedure #2 someclosure len: 5 data: #(0 0 0 0 0) pos: 0>

where len, data and pos are the bindings which are being stored along with the closure and maybe also those stored with their "parents" (if chaining of environments is being used; it seems that the gambit compiler is using boxing and stores away a copy of the reference to the box directly with the closure instead of chaining).

Would it be possible to display the above data from the currently available data structures? Do you imagine I could implement it myself?

Thanks Christian.

(define showval (gensym))

(define (alternator len) (let* ((data (make-vector len)) (pos 0) (incpos! (lambda () (set! pos (let ((p (+ pos 1))) (if (>= p len) 0 p)))))) (lambda (#!optional v) (cond ((eq? v showval) (vector len data pos)) (v (incpos!) (vector-set! data pos v)) (else (incpos!) (vector-ref data pos))))))

When run in the interpreter:

(define a (alternator 5)) (##vector-length a)

4

(##vector-ref a 0)

#<procedure #2>

(pp #2)

#<procedure #2> -> must be compiled, thus (in this case) be some gambit internal

(##vector-ref a 1)

#(#(#(#(#(#(#(#f #<procedure #3 ##cprc-seq> #(#(#(#(#....endless

(##vector-ref a 2)

#<procedure #4 a>

(pp #4)

(lambda (#!optional v) (cond ((eq? v showval) (vector len data pos)) (v (incpos!) (vector-set! data pos v)) (else (incpos!) (vector-ref data pos))))

(##vector-ref a 3)

#(#(#(#(#f #<procedure #5 alternator> 5) #(0 0 0 0 0)) 0) #<procedure #6>)

(pp #5)

(lambda (len) (let ((data (make-vector len))) (let ((pos 0)) (let ((incpos! (lambda () (set! pos (let ((p (+ pos 1))) (if (>= p len) 0 p)))))) (lambda (#!optional v) (cond ((eq? v showval) (vector len data pos)) (v (incpos!) (vector-set! data pos v)) (else (incpos!) (vector-ref data pos))))))))

(pp #6)

(lambda () (set! pos (let ((p (+ pos 1))) (if (>= p len) 0 p))))

When compiled with 'debug:

(bruse exp-closuredisplay) (define a (alternator 5)) (##vector-length a)

4

(##vector-ref a 0)

#<procedure #2>

(pp #2)

(lambda (#!optional v) (cond ((eq? v showval) (vector len data pos)) (v (incpos!) (vector-set! data pos v)) (else (incpos!) (vector-ref data pos))))

(##vector-ref a 1)

#(0 0 0 0 0)

(##vector-ref a 2)

5

(##vector-ref a 3)

#&0