(guile.info.gz) Trace

Info Catalog

(guile.info.gz) Single-Step

(guile.info.gz) Debugging Features

(guile.info.gz) Backtrace

 
 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.
 
  -- Function: trace 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.
 
  -- Function: untrace function
      Disable debug tracing for `function'.
 
    Example:
 
      (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)
            sl
            (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.
 

Info Catalog

(guile.info.gz) Single-Step

(guile.info.gz) Debugging Features

(guile.info.gz) Backtrace