[Haskell-beginners] Using Debug.Trace

[Daniel Fischer]

On Sunday 08 August 2010 19:14:41, Patrick LeBoutillier wrote:
> Hi all,
>
> I'm writing a parser for a binary format, and I'm trying to debug it
> since I have a bug and the code is getting lost in the bits and bytes.
> Basically my main is like this:
>
>   import Data.Binary.Get
>   import Debug.Trace
>   import qualified Data.ByteString.Lazy as L
>
>   main = do
>     bytes <- L.readFile "song.gp4"
>     let (version, bytes') = getVersion bytes
>     putStrLn version
>
>     let stuff = runGet (getDocument version) bytes'
>     putStrLn $ show stuff

putStrLn $ show stuff === print stuff

>
>     return ()

Unneeded

>
> The getVersion and getDocument functions use the Data.Binary.Get monad
> to decode the byte string into various objects.
> I tried sprinkling "trace" calls a bit everywhere and I realize they
> don't always get called at the expected time.

trace prints its first argument when the second is demanded, so to print 
earlier, you can in general add more strictness to your programme, but I'm 
not sure if that makes a difference for Get, since that has no freedom to 
reorder the sequence in which the values are read. So with traces in the 
right places, you should get tracing output while the deserialisation is 
underway automatically.
Whether in

getSomeObject = do
    foo <- get
    !bar <- trace ("foo is " ++ show foo) get
    let !baz = trace ("bar is " ++ show bar) $ fiddle foo bar
    return $! trace ("baz is " ++ show baz) (wibble baz foo bar)

the bangs make a difference regarding trace output, I don't know.

> Most of them are only
> called when I reach the "putStrLn $ show stuff" statement.
> Unfortunately that doesn't help me because I get a
>
>   *** Exception: too few bytes. Failed reading at byte position 35939
>
> before that.

That usually means the file hasn't the correct format, e.g. some size 
(length of list) has been written in little-endian order and is read in 
big-endian, so get tries to read more items than there are.

>
> Is this happening because I'm using lazy IO to read the file?

Unlikely. What is the file size on disk? If it's larger than 35939 bytes, 
you have an IO problem, but still Data.ByteString.Lazy.readFile wouldn't be 
the first on my list of suspects.

> Is there a way to force the evaluation of these "trace" calls?

Seeing more of the code could help coming up with ideas.

> Are there any other ways to debug this kind of stuff in Haskell?
>

Break things down into smaller pieces and test those.
And there's the ghci-debugger, I hear if one has learned to use it, it's 
quite helpful.

>
> Thanks a lot,
>
> Patrick