Node:Trace, Next:, Previous:Single-Step, Up:Debugging Features

11.2 Trace

When a function is traced, it means that every call to that function is reported to the user during a program run. This can help a programmer determine whether a function is being called at the wrong time or with the wrong set of arguments.

trace function Function
Enable debug tracing on function. While a program is being run, Guile will print a brief report at each call to a traced function, advising the user which function was called and the arguments that were passed to it.

untrace function Function
Disable debug tracing for function.


(define (rev ls)
  (if (null? ls)
      (append (rev (cdr ls))
              (cons (car ls) '())))) => rev

(trace rev) => (rev)

(rev '(a b c d e))
=> [rev (a b c d e)]
   |  [rev (b c d e)]
   |  |  [rev (c d e)]
   |  |  |  [rev (d e)]
   |  |  |  |  [rev (e)]
   |  |  |  |  |  [rev ()]
   |  |  |  |  |  ()
   |  |  |  |  (e)
   |  |  |  (e d)
   |  |  (e d c)
   |  (e d c b)
   (e d c b a)
   (e d c b a)

Note the way Guile indents the output, illustrating the depth of execution at each function call. This can be used to demonstrate, for example, that Guile implements self-tail-recursion properly:

(define (rev ls sl)
  (if (null? ls)
      (rev (cdr ls)
           (cons (car ls) sl)))) => rev

(trace rev) => (rev)

(rev '(a b c d e) '())
=> [rev (a b c d e) ()]
   [rev (b c d e) (a)]
   [rev (c d e) (b a)]
   [rev (d e) (c b a)]
   [rev (e) (d c b a)]
   [rev () (e d c b a)]
   (e d c b a)
   (e d c b a)

Since the tail call is effectively optimized to a goto statement, there is no need for Guile to create a new stack frame for each iteration. Using trace here helps us see why this is so.