make-traced-procedure takes a name (typically a
symbol) and a procedure. It returns a procedure similar to proc
except that it traces its arguments and values.
> (define (fact n) (if (zero? n) (lambda (k) (k 1)) (lambda (k) ((fact (- n 1)) (make-traced-procedure `(k ,n) (lambda (v) (k (* v n)))))))) > (call/cc (lambda (k) ((fact 5) (make-traced-procedure 'K k)))) |((k 1) 1) |((k 2) 1) |((k 3) 2) |((k 4) 6) |((k 5) 24) |(K 120) 120
trace-define syntax is similar to
that the bound value, which must be a procedure, becomes a traced
procedure. A traced procedure prints its arguments when it is called
and prints its values when it returns.
> (trace-define (fact n) (if (zero? n) 1 (* n (fact (- n 1))))) > (fact 5) |(fact 5) | (fact 4) | |(fact 3) | | (fact 2) | | |(fact 1) | | | (fact 0) | | | 1 | | |1 | | 2 | |6 | 24 |120 120
The tracing facility in Vicare preserves and shows tail recursion and distinguishes it from non–tail recursion by showing tail calls starting at the same line in which their parent was called.
> (trace-define (fact n) (trace-define (fact-aux n m) (if (zero? n) m (fact-aux (- n 1) (* n m)))) (fact-aux n 1)) > (fact 5) |(fact 5) |(fact-aux 5 1) |(fact-aux 4 5) |(fact-aux 3 20) |(fact-aux 2 60) |(fact-aux 1 120) |(fact-aux 0 120) |120 120
Moreover, the tracing facility interacts well with continuations and exceptions.
> (call/cc (lambda (k) (trace-define (loop n) (if (zero? n) (k 'done) (+ (loop (- n 1)) 1))) (loop 5))) |(loop 5) | (loop 4) | |(loop 3) | | (loop 2) | | |(loop 1) | | | (loop 0) done
trace-lambda macro is similar to
that the resulting procedure is traced: it prints the arguments it
receives and the results it returns.
define-syntax but create a tracing transformer function.
Whenever the macro is expanded the transformer function will print its
argument (the input form) and its return value (the output form).
(trace-define-syntax ciao (syntax-rules () ((_ ?a) (list 1 ?a 3)))) (ciao 2) -| |(ciao (ciao 2)) -| |(list 1 2 3)
the first printed symbolic expression
(ciao (ciao 2)) shows the
called tranformer function
(ciao ---) and its argument being the
(ciao 2), filtered through
letrec-syntax but define tracing