**Course Title:** Functional Programming with Haskell: From Fundamentals to Advanced Concepts **Section Title:** Testing and Debugging in Haskell **Topic:** Debugging tools: `trace` and GHCi debugger. ### Introduction Debugging is an essential part of the development process. In Haskell, we can use various tools to identify and fix errors in our code. In this topic, we will explore two essential debugging tools: the `trace` function and the GHCi debugger. These tools will help you understand how your code is executed, identify bottlenecks, and fix bugs. ### The `trace` Function The `trace` function is a simple yet powerful tool for debugging. It allows you to print messages at specific points in your code without modifying the code's behavior. `trace` is part of the `Debug.Trace` module, so you'll need to import it: ```haskell import Debug.Trace myFunction :: Int -> Int myFunction x = trace "myFunction called" (x * 2) ``` In this example, when `myFunction` is called, it will print "myFunction called" to the console. However, be aware that `trace` can be potentially slow, as it involves printing messages to the console. Also, because of Haskell's lazy evaluation, `trace` may not always behave as expected. To illustrate this, consider the following example: ```haskell myList :: [Int] myList = [1..10000000] main :: IO () main = do putStrLn (head myList) putStrLn (show myList) -- Not evaluated yet putStrLn (show [x | x <- myList, x `mod` 2 == 0]) -- Now, trace statements will be executed during evaluation putStrLn "Done" -- With trace, for example: tracedList :: [Int] tracedList = trace "List evaluated" [x | x <- [1..10000000], x `mod` 2 == 0] main' :: IO () main' = do putStrLn "Start" putStrLn (show [x | x <- take 10 tracedList]) putStrLn "Done" ``` When running `main'`, because of lazy evaluation, you will only see the first ten elements being "evaluated" and printed. ### GHCi Debugger GHCi provides an integrated debugger that allows you to step through your code line by line, inspect variables, and set breakpoints. To use the debugger, you'll need to compile your code with the `-debug` flag: ```bash ghc -O0 -debug -DS DEBUG_GHCi -rtsopts All.hs ``` Now you can load your code in GHCi and use the debugger commands: ```haskell ghci> :break MyModule.myFunction ghci> :step ghci> :list ghci> :print x ghci> :trace ``` Some other useful commands in the GHCi debugger include: * `:break <module>.<function>`: Sets a breakpoint at the specified function. * `:list [expression]`: Displays the current source code line and optionally evaluates an expression. * `:step`: Single-steps the execution of the program. * `:steplocal`: Single-steps the execution of the program, only stopping at the current module. * `:continue`: Continues execution until the next breakpoint is reached. * `:print <expression>`: Evaluates the specified expression and prints the result. * `:abandon`: Abandons the current breakpoint. * `:delete [number]`: Deletes the specified breakpoint or the current one if no number is provided. * `:force <expression>`: Evaluates the specified expression to head-normal form. * `:history`: Prints the command history. * `:trace`: Evaluates the current expression to normal form, printing the steps. To try the debugger, here is a simple example: ```haskell module MyModule where factorial 0 = 0 factorial n = n * factorial (n - 1) main :: IO () main = putStrLn ("3! is " ++ show (factorial 3)) ``` Now open GHCi and compile your module with the `-debug` flag. You can then use the debugger to step through `factorial`. ### Practical Takeaways * The `trace` function is a quick and easy way to debug your code. * However, `trace` can be slow and might not behave as expected due to lazy evaluation. * The GHCi debugger is a more powerful tool for debugging, allowing you to step through your code, inspect variables, and set breakpoints. * Use `break` to set a breakpoint, `step` to single-step the execution, and `print` to evaluate an expression. ### Example Use Cases * Debugging a complex algorithm by using the GHCi debugger to step through the code and inspect variables. * Using the `trace` function to identify the source of a memory leak. * Setting a breakpoint with `:break` to stop execution at a specific point in the code. We hope this explanation has helped you understand how to use the `trace` function and the GHCi debugger to debug your Haskell code. Please try these examples and let us know if you have any questions or comments about the GHCi debugger and the `trace` function. ### External Resources: * [GHC User's Guide - The GHCi debugger](https://downloads.haskell.org/ghc/latest/docs/html/users_guide/ghci.html#the-ghci-debugger) After this topic, we will cover 'Profiling and optimizing Haskell code.'