The Glorious Glasgow Haskell Compilation System User's Guide ...

The Glorious Glasgow Haskell
Compilation System User’s Guide,
Version 6.10.4 27 / 224
2.5.6 Debugging exceptions
Another common question that comes up when debugging is “where did this exception come from?”. Exceptions such as
those raised by error or head [] have no context information attached to them. Finding which particular call to head in
your program resulted in the error can be a painstaking process, usually involving Debug.Trace.trace, or compiling with
profiling and using +RTS -xc (see Section 5.3).
The GHCi debugger offers a way to hopefully shed some light on these errors quickly and without modifying or recompiling the
source code. One way would be to set a breakpoint on the location in the source code that throws the exception, and then use
:trace and :history to establish the context. However, head is in a library and we can’t set a breakpoint on it directly.
For this reason, GHCi provides the flags -fbreak-on-exception which causes the evaluator to stop when an exception
is thrown, and -fbreak-on-error, which works similarly but stops only on uncaught exceptions. When stopping at an
exception, GHCi will act just as it does when a breakpoint is hit, with the deviation that it will not show you any source code
location. Due to this, these commands are only really useful in conjunction with :trace, in order to log the steps leading up to
the exception. For example:
*Main> :set -fbreak-on-exception
*Main> :trace qsort ("abc" ++ undefined)
“Stopped at
_exception :: e
[] *Main> :hist
-1 : qsort.hs:3:24-38
-2 : qsort.hs:3:23-55
-3 : qsort.hs:(1,0)-(3,55)
-4 : qsort.hs:2:15-24
-5 : qsort.hs:2:15-46
-6 : qsort.hs:(1,0)-(3,55)
[] *Main> :back
Logged breakpoint at qsort.hs:3:24-38
_result :: [a]
as :: [a]
a :: a
[-1: qsort.hs:3:24-38] *Main> :force as
*** Exception: Prelude.undefined
[-1: qsort.hs:3:24-38] *Main> :print as
as = ’b’ : ’c’ : (_t1::[Char])
The exception itself is bound to a new variable, _exception.
Breaking on exceptions is particularly useful for finding out what your program was doing when it was in an infinite loop. Just
hit Control-C, and examine the history to find out what was going on.
2.5.7 Example: inspecting functions
It is possible to use the debugger to examine function values. When we are at a breakpoint and a function is in scope, the debugger
cannot show you the source code for it; however, it is possible to get some information by applying it to some arguments and
observing the result.
The process is slightly complicated when the binding is polymorphic. We show the process by means of an example. To keep
things simple, we will use the well known map function:
import Prelude hiding (map)
map :: (a->b) -> [a] -> [b]
map f [] = []
map f (x:xs) = f x : map f xs
We set a breakpoint on map, and call it.