Thetrace function outputs the trace message given as its first argument,before returning the second argument as its result.

For example, this returns the value off x but first outputs the message.

>>>let x = 123; f = show>>>trace ("calling f with x = " ++ show x) (f x)"calling f with x = 123123"

Thetrace function shouldonly be used for debugging, or for monitoringexecution. The function is not referentially transparent: its type indicatesthat it is a pure function but it has the side effect of outputting thetrace message.

Liketrace but returns the message instead of a third value.

>>>traceId "hello""hellohello"

Since: 4.7.0.0

Liketrace, but usesshow on the argument to convert it to aString.

This makes it convenient for printing the values of interesting variables orexpressions inside a function. For example here we print the value of thevariablesx andy:

>>>let f x y = traceShow (x,y) (x + y) in f (1+2) 5(3,5)8

LiketraceShow but returns the shown value instead of a third value.

>>>traceShowId (1+2+3, "hello" ++ "world")(6,"helloworld")(6,"helloworld")

Since: 4.7.0.0

liketrace, but additionally prints a call stack if one is available.

In the current GHC implementation, the call stack is only available if the program was compiled with-prof; otherwisetraceStack behaves exactly liketrace. Entries in the call stack correspond toSCC annotations, so it is a good idea to use-fprof-auto or-fprof-auto-calls to add SCC annotations automatically.

Since: 4.5.0.0

ThetraceIO function outputs the trace message from the IO monad. This sequences the output with respect to other IO actions.

Since: 4.5.0.0

Liketrace but returning unit in an arbitraryApplicative context. Allowsfor convenient use in do-notation.

Note that the application oftraceM is not an action in theApplicativecontext, astraceIO is in theIO type. While the fresh bindings in thefollowing example will force thetraceM expressions to be reduced every timethedo-block is executed,traceM "not crashed" would only be reduced once,and the message would only be printed once. If your monad is inMonadIO,liftIO . traceIO may be a better option.

>>>:{do    x <- Just 3    traceM ("x: " ++ show x)    y <- pure 12    traceM ("y: " ++ show y)    pure (x*2 + y):}x: 3y: 12Just 18

Since: 4.7.0.0

LiketraceM, but usesshow on the argument to convert it to aString.

>>>:{do    x <- Just 3    traceShowM x    y <- pure 12    traceShowM y    pure (x*2 + y):}312Just 18

Since: 4.7.0.0

ThetraceEvent function behaves liketrace with the difference that the message is emitted to the eventlog, if eventlog profiling is available and enabled at runtime.

It is suitable for use in pure code. In an IO context usetraceEventIO instead.

Note that when using GHC's SMP runtime, it is possible (but rare) to get duplicate events emitted if two CPUs simultaneously evaluate the same thunk that usestraceEvent.

Since: 4.5.0.0

ThetraceEventIO function emits a message to the eventlog, if eventlog profiling is available and enabled at runtime.

Compared totraceEvent,traceEventIO sequences the event with respect to other IO actions.

Since: 4.5.0.0

ThetraceMarker function emits a marker to the eventlog, if eventlog profiling is available and enabled at runtime. TheString is the name of the marker. The name is just used in the profiling tools to help you keep clear which marker is which.

This function is suitable for use in pure code. In an IO context usetraceMarkerIO instead.

Note that when using GHC's SMP runtime, it is possible (but rare) to get duplicate events emitted if two CPUs simultaneously evaluate the same thunk that usestraceMarker.

Since: 4.7.0.0

ThetraceMarkerIO function emits a marker to the eventlog, if eventlog profiling is available and enabled at runtime.

Compared totraceMarker,traceMarkerIO sequences the event with respect to other IO actions.

Since: 4.7.0.0