-- test.hs
  crash = sum [1,2,3,undefined,5,6,7,8]
  main  = print crash

 > ghc-7.6.3 test.hs -prof -fprof-auto -fprof-cafs && ./test +RTS -xc
 *** Exception (reporting due to +RTS -xc): (THUNK_2_0), stack trace: 
   GHC.Err.CAF
   --> evaluated by: Main.crash,
   called from Main.CAF:crash_reH
 test: Prelude.undefined

Printf and friends

The simplest approach is to use Debug.Trace.trace:

trace :: String -> a -> a

"When called, trace outputs the string in its first argument, before returning the second argument as its result.'"

A common idiom to trace a function is:

myfun a b | trace ("myfun " ++ show a ++ " " ++ show b) False = undefined
myfun a b = ...

The advantage is that disabling and enabling the trace takes only one line comment.

You must keep in mind that due to lazy evaluation your traces will only print if the value they wrap is ever demanded.

The trace function is located in the base package. The package htrace defines a trace function similar to the one in the base package, but with indentation for better visual effect (see the mailing list thread for examples). Other tools can be found at the debug category in Hackage.

A more powerful alternative for this approach is Hood. Even if it hasn't been updated in some time, Hood works perfectly with the current ghc distribution. Even more, Hugs has it already integrated, see the manual page. Add an import Observe and start inserting observations in your code. For instance:

import Hugs.Observe

f'  = observe "Informative name for f" f 
f x = if odd x then x*2 else 0

And then in hugs:

Main> map f' [1..5]
[2,0,6,0,10]

>>>>>>> Observations <<<<<<

Informative name for f
  { \ 5  -> 10
  , \ 4  -> 0
  , \ 3  -> 6
  , \ 2  -> 0
  , \ 1  -> 2
  }

outputs a report of all the invocations of f and their result.

I have a handy bogus Hugs.Observe module with no-ops for the observations so that I don't need to remove them manually, expecting that the compiler will optimize them away.

The GHood package adds a graphical back-end to Hood. See also the GHood homepage.

The Safe Library

There is a safe library of functions from the Prelude that can crash, see the safe library. If you get an error message such as "pattern match failure, head []", you can then use headNote "extra information" to get a more detailed error message for that particular call to head. The safe library also has functions that return default values and wrap their computation in Maybe as required.

Offline analysis of traces

The most advanced debugging tools are based in offline analysis of traces.

Haskell Tracer HAT

Hat is probably the most advanced tool for this, offering a comprehensive set of tools. Neil Mitchell has made available a Windows port of Hat at his site.

The disadvantage of traditional Haskell tracers is that they either need to transform the whole program or require a specialized run-time system. Therefore they are not always compatible with the latest libraries, so you can put them to use only in some cases.

Hoed - The Lightweight Haskell Tracer and Debugger

Hoed is a tracer/debugger that offers most of HATs functionality, and works with untransformed libraries. Hoed can therefore be used to debug much more programs than traditional tracer/debuggers.

To locate a defect with Hoed you annotate suspected functions and compile as usual. Then you run your program, information about the annotated functions is collected. Finally you connect to a debugging session using a webbrowser.

Dynamic breakpoints in GHCi

Finally, the GHCi debugger enables dynamic breakpoints and intermediate values observation.

This tool allows to set breakpoints in your code, directly from the GHCi command prompt. An example session:

*main:Main> :break Main 2
Breakpoint set at (2,15)
*main:Main> qsort [10,9..1]
Local bindings in scope:
  x :: a, xs :: [a], left :: [a], right :: [a]
 
qsort2.hs:2:15-46> :sprint x
x = _
qsort2.hs:2:15-46> x

This is an untyped, unevaluated computation. You can use seq to force its evaluation and then :print to recover its type

qsort2.hs:2:15-46> seq x ()
() 
qsort2.hs:2:15-46> :p x
x - 10

Once a breakpoint is hit, you can explore the bindings in scope, as well as to evaluate any Haskell expression, as you would do in a normal GHCi prompt. The :print command can be very useful to explore the laziness of your code.

Source-located errors

LocH provides wrappers over assert for generating source-located exceptions and errors.

Consider the use of a located fromJust:

import Debug.Trace.Location
import qualified Data.Map as M
import Data.Maybe

main = do print f

f = let m = M.fromList
                [(1,"1")
                ,(2,"2")
                ,(3,"3")]
        s = M.lookup 4 m
    in fromJustSafe assert s

fromJustSafe a s = check a (fromJust s)

$ ./a.out
a.out: A.hs:12:20-25: Maybe.fromJust: Nothing

   $ ghc A.hs --make -no-recomp
   [1 of 1] Compiling Main             ( A.hs, A.o )
   Linking A ...

   $ ./A
   A: Maybe.fromJust: Nothing

import Debug.Trace.Location

   $ ghc A.hs --make -pgmF loch -F -no-recomp
   [1 of 1] Compiling Main             ( A.hs, A.o )
   Linking A ...

   $ ./A
   A: A.hs:14:14-19: Maybe.fromJust: Nothing

g x = h $ fromJust $ f x,

g x = let Just y = f x in h y,

    Main: M1.hs:9:11-22:
    Irrefutable pattern failed for pattern Data.Maybe.Just y