Modulepretty-simple-4.1.3.0Haskell2010

Debug.Pretty.Simple

This module contains the same functionality with Prelude's Debug.Trace module, with pretty printing the debug strings.

Warning: This module also shares the same unsafety of Debug.Trace module.

50 values

Packagepretty-simple-4.1.3.0
Exports50
LanguageHaskell2010
LicenceBSD-3-Clause
SourceSimple.hs

Trace with color on dark background

14 declarations

valuepTrace :: String -> a -> a

pTrace remains in code

The pTrace function pretty prints the trace message given as its first argument, before returning the second argument as its result.

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

pTrace ("calling f with x = " ++ show x) (f x)

The pTrace function should only be used for debugging, or for monitoring execution. The function is not referentially transparent: its type indicates that it is a pure function but it has the side effect of outputting the trace message.

valuepTraceId :: String -> String

pTraceId remains in code

Like pTrace but returns the message instead of a third value.

valuepTraceShow :: Show a => a -> b -> b

pTraceShow remains in code

Like pTrace, but uses show on the argument to convert it to a String.

This makes it convenient for printing the values of interesting variables or expressions inside a function. For example here we print the value of the variables x and z:

f x y =
    pTraceShow (x, z) $ result
  where
    z = ...
    ...

valuepTraceShowId :: Show a => a -> a

pTraceShowId remains in code

Like pTraceShow but returns the shown value instead of a third value.

valuepTraceIO :: String -> IO ()

pTraceIO remains in code

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

valuepTraceM :: Applicative f => String -> f ()

pTraceM remains in code

Like pTrace but returning unit in an arbitrary Applicative context. Allows for convenient use in do-notation.

Note that the application of pTraceM is not an action in the Applicative context, as pTraceIO is in the IO type. While the fresh bindings in the following example will force the traceM expressions to be reduced every time the do-block is executed, traceM "not crashed" would only be reduced once, and the message would only be printed once. If your monad is in MonadIO, liftIO . pTraceIO may be a better option.

... = do
  x <- ...
  pTraceM $ "x: " ++ show x
  y <- ...
  pTraceM $ "y: " ++ show y

valuepTraceShowM :: (Show a, Applicative f) => a -> f ()

pTraceShowM remains in code

Like pTraceM, but uses show on the argument to convert it to a String.

... = do
  x <- ...
  pTraceShowM $ x
  y <- ...
  pTraceShowM $ x + y

valuepTraceStack :: String -> a -> a

pTraceStack remains in code

like pTrace, 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; otherwise pTraceStack behaves exactly like pTrace. Entries in the call stack correspond to SCC annotations, so it is a good idea to use -fprof-auto or -fprof-auto-calls to add SCC annotations automatically.

valuepTraceEvent :: String -> a -> a

pTraceEvent remains in code

The pTraceEvent function behaves like trace 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 use pTraceEventIO 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 uses pTraceEvent.

valuepTraceEventIO :: String -> IO ()

pTraceEventIO remains in code

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

Compared to pTraceEvent, pTraceEventIO sequences the event with respect to other IO actions.

valuepTraceMarker :: String -> a -> a

pTraceMarker remains in code

The pTraceMarker function emits a marker to the eventlog, if eventlog profiling is available and enabled at runtime. The String 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 use pTraceMarkerIO 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 uses pTraceMarker.

valuepTraceMarkerIO :: String -> IO ()

pTraceMarkerIO remains in code

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

Compared to pTraceMarker, pTraceMarkerIO sequences the event with respect to other IO actions.

valuepTraceWith :: (a -> String) -> a -> a

pTraceWith remains in code

The pTraceWith function pretty prints the result of applying f to a and returns back @a

@since ?

valuepTraceShowWith :: Show b => (a -> b) -> a -> a

pTraceShowWith remains in code

The pTraceShowWith function similar to pTraceWith except that @f can return any type that implements Show

@since ?

Trace forcing color

12 declarations

valuepTraceForceColor :: String -> a -> a

pTraceForceColor remains in code

Similar to pTrace, but forcing color.

valuepTraceIdForceColor :: String -> String

pTraceIdForceColor remains in code

Similar to pTraceId, but forcing color.

valuepTraceShowForceColor :: Show a => a -> b -> b

pTraceShowForceColor remains in code

Similar to pTraceShow, but forcing color.

valuepTraceShowIdForceColor :: Show a => a -> a

pTraceShowIdForceColor remains in code

Similar to pTraceShowId, but forcing color.

valuepTraceMForceColor :: Applicative f => String -> f ()

pTraceMForceColor remains in code

Similar to pTraceM, but forcing color.

valuepTraceShowMForceColor :: (Show a, Applicative f) => a -> f ()

pTraceShowMForceColor remains in code

Similar to pTraceShowM, but forcing color.

valuepTraceStackForceColor :: String -> a -> a

pTraceStackForceColor remains in code

Similar to pTraceStack, but forcing color.

valuepTraceEventForceColor :: String -> a -> a

pTraceEventForceColor remains in code

Similar to pTraceEvent, but forcing color.

valuepTraceEventIOForceColor :: String -> IO ()

pTraceEventIOForceColor remains in code

Similar to pTraceEventIO, but forcing color.

valuepTraceMarkerForceColor :: String -> a -> a

pTraceMarkerForceColor remains in code

Similar to pTraceMarker, but forcing color.

valuepTraceMarkerIOForceColor :: String -> IO ()

pTraceMarkerIOForceColor remains in code

Similar to pTraceMarkerIO, but forcing color.

valuepTraceIOForceColor :: String -> IO ()

pTraceIOForceColor remains in code

Similar to pTraceIO, but forcing color.

Trace without color

12 declarations

valuepTraceNoColor :: String -> a -> a

pTraceNoColor remains in code

Similar to pTrace, but without color.

Example1 expression

>>> pTraceNoColor "wow" ()wow()

valuepTraceIdNoColor :: String -> String

pTraceIdNoColor remains in code

Similar to pTraceId, but without color.

Example1 expression

>>> pTraceIdNoColor "(1, 2, 3)" `seq` ()( 1, 2, 3)()

valuepTraceShowNoColor :: Show a => a -> b -> b

pTraceShowNoColor remains in code

Similar to pTraceShow, but without color.

Example2 expressions

>>> import qualified Data.Map as M>>> pTraceShowNoColor (M.fromList [(1, True)]) ()fromList    [        ( 1        , True        )    ]()

valuepTraceShowIdNoColor :: Show a => a -> a

pTraceShowIdNoColor remains in code

Similar to pTraceShowId, but without color.

Example2 expressions

>>> import qualified Data.Map as M>>> pTraceShowIdNoColor (M.fromList [(1, True)]) `seq` ()fromList    [        ( 1        , True        )    ]()

valuepTraceMNoColor :: Applicative f => String -> f ()

pTraceMNoColor remains in code

Similar to pTraceM, but without color.

Example1 expression

>>> pTraceMNoColor "wow"wow

valuepTraceShowMNoColor :: (Show a, Applicative f) => a -> f ()

pTraceShowMNoColor remains in code

Similar to pTraceShowM, but without color.

Example1 expression

>>> pTraceShowMNoColor [1,2,3][ 1, 2, 3]

valuepTraceStackNoColor :: String -> a -> a

pTraceStackNoColor remains in code

Similar to pTraceStack, but without color.

Example1 expression

>>> pTraceStackNoColor "wow" () `seq` ()wow()

valuepTraceEventNoColor :: String -> a -> a

pTraceEventNoColor remains in code

Similar to pTraceEvent, but without color.

valuepTraceEventIONoColor :: String -> IO ()

pTraceEventIONoColor remains in code

Similar to pTraceEventIO, but without color.

valuepTraceMarkerNoColor :: String -> a -> a

pTraceMarkerNoColor remains in code

Similar to pTraceMarker, but without color.

valuepTraceMarkerIONoColor :: String -> IO ()

pTraceMarkerIONoColor remains in code

Similar to pTraceMarkerIO, but without color.

valuepTraceIONoColor :: String -> IO ()

pTraceIONoColor remains in code

Similar to pTraceIO, but without color.

Example1 expression

>>> pTraceIONoColor "(1, 2, 3)"( 1, 2, 3)

Trace With OutputOptions

12 declarations

valuepTraceOpt :: CheckColorTty -> OutputOptions -> String -> a -> a

pTraceOpt remains in code

Like pTrace but takes OutputOptions.

valuepTraceIdOpt :: CheckColorTty -> OutputOptions -> String -> String

pTraceIdOpt remains in code

Like pTraceId but takes OutputOptions.

valuepTraceShowOpt :: Show a => CheckColorTty -> OutputOptions -> a -> b -> b

pTraceShowOpt remains in code

Like pTraceShow but takes OutputOptions.

valuepTraceShowIdOpt :: Show a => CheckColorTty -> OutputOptions -> a -> a

pTraceShowIdOpt remains in code

Like pTraceShowId but takes OutputOptions.

valuepTraceOptIO :: CheckColorTty -> OutputOptions -> String -> IO ()

pTraceOptIO remains in code

Like pTraceIO but takes OutputOptions.

valuepTraceOptM

:: Applicative f
=> CheckColorTty
-> OutputOptions
-> String
-> f ()

pTraceOptM remains in code

Like pTraceM but takes OutputOptions.

valuepTraceShowOptM

:: (Show a, Applicative f)
=> CheckColorTty
-> OutputOptions
-> a
-> f ()

pTraceShowOptM remains in code

Like pTraceShowM but takes OutputOptions.

valuepTraceStackOpt :: CheckColorTty -> OutputOptions -> String -> a -> a

pTraceStackOpt remains in code

Like pTraceStack but takes OutputOptions.

valuepTraceEventOpt :: CheckColorTty -> OutputOptions -> String -> a -> a

pTraceEventOpt remains in code

Like pTraceEvent but takes OutputOptions.

valuepTraceEventOptIO :: CheckColorTty -> OutputOptions -> String -> IO ()

pTraceEventOptIO remains in code

Like pTraceEventIO but takes OutputOptions.

valuepTraceMarkerOpt :: CheckColorTty -> OutputOptions -> String -> a -> a

pTraceMarkerOpt remains in code

Like pTraceMarker but takes OutputOptions.

valuepTraceMarkerOptIO :: CheckColorTty -> OutputOptions -> String -> IO ()

pTraceMarkerOptIO remains in code

Like pTraceMarkerIO but takes OutputOptions.