HORIZON HASKELLDocslts/ghc-9.10.x248f8f02026-10-05Search names, modules, packages, or :: a typeCtrl K

GHC 9.10.3 · lts/ghc-9.10.x · 248f8f0 · 2026-10-05

Modulerelude-1.2.0.0Haskell2010

Relude.Debug

SPDX-License-Identifier : MIT Maintainer : Kowainik xrom.xkov@gmail.com Stability : Stable Portability : Portable

This module contains functions for debugging pure functions. You can't use functions like System.IO.putStrLn for this purpose because they require changes to the type signature, but functions in this module avoid this problem by being pure on their own.

Additionally, these functions produce compile-time warnings, if you leave them in your code. Warnings help you to cleanup all debugging usages before releasing.

ghci> foo = trace "I forgot trace in code"

<interactive>:4:7: warning: [-Wdeprecations]
    In the use of ‘trace’ (imported from Relude):
    "trace remains in code"

The following table briefly shows names and types of all functions in this module.

Name

Type

trace

String -> a -> a

traceShow

Show a => a -> b -> b

traceShowId

Show a => a -> a

traceShowWith

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

traceId

String -> String

traceM

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

traceShowM

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

⚠ NOTE: Use these functions only for local debugging purposes. They break referential transparency, they are only useful when you want to observe intermediate values of your pure functions and to understand the behaviour locally. If you want to log debug messages in your application, consider using a logging library instead.

  • 1 type
  • 9 values
  • Packagerelude-1.2.0.0
  • Exports10
  • LanguageHaskell2010
  • LicenceMIT
  • SourceDebug.hs

Tracing

7 declarations
valuetrace :: String -> a -> a
#

trace remains in code

Prints the given String message and returns the passed value of type a.

Example2 expressions
increment l = map (+1) lincrement [2, 3, 4][3,4,5]
Example2 expressions
increment l = trace ("incrementing each value of: " ++ show l) (map (+1) l)increment [2, 3, 4]incrementing each value of: [2,3,4][3,4,5]
valuetraceShow :: Show a => a -> b -> b
#

traceShow remains in code

Similar to trace but prints a given value with the Show instance instead of a String.

Example2 expressions
increment l = map (+1) lincrement [2, 3, 4][3,4,5]
Example2 expressions
increment l = traceShow l (map (+1) l)increment [2, 3, 4][2,3,4][3,4,5]

  • If you want to print a specific String instead, use trace

  • If you want to print and return the same value, use traceShowId

  • If you want to specify a custom printing function, use traceShowWith

valuetraceShowId :: Show a => a -> a
#

traceShowId remains in code

Similar to traceShow but prints the given value itself instead of a separate value.

Example1 expression
traceShowId (1+2+3, "hello" ++ "world")(6,"helloworld")(6,"helloworld")
valuetraceShowWith :: Show b => (a -> b) -> a -> a
#

'traceShowWith remains in code

Similar traceShowId, but uses a provided function to convert the argument to a value with the Show constraint.

Example1 expression
traceShowWith fst (1, "ABC")1(1,"ABC")

In other words, traceShowId ≡ traceShowWith id.

This function is useful for debugging values that do not have Show instance:

Example1 expression
fst $ traceShowWith fst (1, id)11
valuetraceM :: Applicative f => String -> f ()
#

traceM remains in code

Trace function to print values while working a pure monad (e.g. Maybe, State, etc.)

Example1 expression
:{let action :: Maybe Int    action = do        x <- Just 3        traceM ("x: " ++ show x)        y <- pure 12        traceM ("y: " ++ show y)        pure (x*2 + y)in action:}x: 3y: 12Just 18

  • If you want to print a value with the Show instance instead, use traceShowM

valuetraceShowM :: (Show a, Applicative f) => a -> f ()
#

traceShowM remains in code

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

Example1 expression
:{let action :: Maybe Int    action = do        x <- Just 3        traceShowM x        y <- pure 12        traceShowM y        pure (x*2 + y)in action:}312Just 18

Imprecise error

3 declarations
valueerror :: (HasCallStack, IsText t) => t -> a
#

Throw pure errors. Use this function only to when you are sure that this branch of code execution is not possible. DO NOT USE error as a normal error handling mechanism.

Example1 expression
error "oops"*** Exception: oopsCallStack (from HasCallStack):  error, called at src/Relude/Debug.hs:289:11 in ......

⚠️CAUTION⚠️ Unlike Prelude version, error takes Text as an argument. In case it used by mistake, the user will see the following:

Example2 expressions
error ("oops" :: String)...... 'error' expects 'Text' but was given 'String'.      Possible fixes:          * Make sure OverloadedStrings extension is enabled          * Use 'error (toText msg)' instead of 'error msg'...error False...... 'error' works with 'Text'      But given: Bool...
datadata Undefined
#

Undefined type remains in code

Similar to undefined but data type.

Undefined
Instances9Bounded, Enum, Eq, Data, Ord, Read, …