The trace function is a debugging tool for tracing the execution of specified procedures. One or more procedure or module names can be passed to trace.

For more comprehensive $\mathrm{interactive}$ debugging facilities, see debugger.

If a module name is given and the module has a ModuleApply procedure, this procedure will be traced. If the module does not have a ModuleApply procedure, all the exports of the module are traced. This process is recursive, so all exported procedures in all submodules are also traced.

A special syntax, similar to that used for stopat and unstopat, may be used for tracing local procedures in modules. If a module m has a local variable g that is a procedure, then you can trace g by issuing the command trace( m::g ). Similarly, tracing of g can be turned off with the call untrace( m::g ). Note that, in this call, the expression g must be of type symbol and must be global in scope. (This special way of referring to locals of a module is recognized only when used with debugging-related utilities. It is not a general syntax for referring to module locals.)

When tracing recursive procedures, it is sometimes useful to only trace the top few calls to the procedure. The depth=integer option limits tracing to the specified number of nested calls of the function(s) being traced, where a depth of 1 signifies just the top-level call.

The statements option controls how much information is shown during execution of a traced procedure. If statements=true (the default), output is produced for procedure entry, each statement within the procedure, and procedure exit. If statements=false, only procedure entry and exit are traced.

Note that it is not possible to trace most built-in functions that have special evaluation rules, such as: assigned, eval, evalhf, evalf, evaln, or seq. However, when tracing a procedure that calls evalf, any traceable code that is executed by evalf is traced.

The trace function will silently ignore any argument which is not the name of a traceable procedure. In particular, it is possible to invoke trace(anames()) to cause tracing of all procedures which correspond to currently assigned names even though many of the names in anames() may not be assigned procedures.

The untrace function turns off the tracing of the specified procedures.

The trace (untrace) function returns an expression sequence of the names of the procedures for which tracing was turned on (off).

The names debug and undebug are alternate names for trace and untrace.

Instead of tracing specified procedures, it is also possible to trace all statements up to a specified depth of procedure calls and statement nesting using the printlevel environment variables.

f := proc(x) local y; y := x * 2; g(x) / 4; end proc;

$f≔\mathbf{proc}\left(x\right)\mathbf{local}y\;y≔2\*x\;1\/4\*g\left(x\right)\mathbf{end\; proc}$

g := proc(x) local z; z := x^2; z * 2; end proc;

$g≔\mathbf{proc}\left(x\right)\mathbf{local}z\;z≔x\^2\;2\*z\mathbf{end\; proc}$

$\mathrm{trace}\left(f\,g\right)$

$f,g$

$f\left(3\right)$

{--> enter f, args = 3
                                    y := 6

{--> enter g, args = 3
                                    z := 9

                                      18

<-- exit g (now in f) = 18}
                                      9/2

<-- exit f (now in `mpldoc/process_example`) = 9/2}

$\frac{9}{2}$

$f\left(3\right)\&colon;$

{--> enter f, args = 3
                                    y := 6

{--> enter g, args = 3
                                    z := 9

                                      18

<-- exit g (now in f) = 18}
                                      9/2

<-- exit f (now in `mpldoc/process_example`) = 9/2}

$\mathrm{trace}\left(g\&comma;\mathrm{statements}=\mathrm{false}\right)$

$g$

$f\left(3\right)$

{--> enter f, args = 3
                                    y := 6

{--> enter g, args = 3
<-- exit g (now in f) = 18}
                                      9/2

<-- exit f (now in `mpldoc/process_example`) = 9/2}

$\frac{9}{2}$

m := module()
  export f;
  local g;
  g := proc( x )
    local y;
    y := 2 * x;
    y
  end proc;
  f := x -> g( x / 3 );
end module:

$\mathrm{trace}\left(m::g\right)$

$g$

$m:-f\left(2\right)$

{--> enter g, args = 2/3
                                   y := 4/3

                                      4/3

<-- exit g (now in f) = 4/3}

$\frac{4}{3}$

$\mathrm{untrace}\left(m::g\right)$

$g$

$m:-f\left(s\right)$

$\frac{2s}{3}$

Display of source file and line number information in tracing output is new in Maple 2020.

The depth option was introduced in Maple 2017.

For more information on Maple 2017 changes, see Updates in Maple 2017.

The kernelopts(traceincidentalassign), kernelopts(tracesplitmulassign) and kernelopts(traceshowspecassign) options were introduced in Maple 2019.1.

For more information on Maple 2019 changes, see Updates in Maple 2019.

The kernelopts(tracelineinfo) and kernelopts(shortlineinfo) options were introduced in Maple 2020.

For more information on Maple 2020 changes, see Updates in Maple 2020.

The trace command was updated in Maple 2021.

The statements option was introduced in Maple 2021.

For more information on Maple 2021 changes, see Updates in Maple 2021.