Debug.Observe

GHood: A graphical viewer for Hood

Created a cabal library package. Improved the search for the GHood.jar file, that is bundled with the library. Changed from Literate Haskell to plain Haskell for better haddock documentation support.

Hugo Pacheco, November 2008

Added ObserveM. Adapted imports to use GHC's hierarchical libraries.

Alcino Cunha, February 2004

Modified version of Hood/Observe.lhs to match GHood, the Graphical Haskell Object Observation Debugger, which is distributed as a Java class file archive GHood.jar. [Apart from two new hooks, modifications are at the end]

Claus Reinke, December 2000

The file is part of the Haskell Object Observation Debugger, (HOOD) July 2000 release. Actually this is all of this version of HOOD, apart from the documentation and examples...

HOOD is a small post-mortem debugger for the lazy functional language Haskell. It is based on the concept of observation of intermediate data structures, rather than the more traditional stepping and variable examination paradigm used by imperative language debuggers.

Copyright (c) Andy Gill, 1992-2000

Documentation

observe :: Observable a => String -> a -> a

Our principle function and class

newtype Observer

Contains a forall typed observe (if supported).

Constructors

O (forall a. Observable a => String -> a -> a)

type Observing a = a -> a

class Observable a where

Minimal complete definition

observer

Methods

observer :: a -> Parent -> a

This reveals the name of a specific constructor. and gets ready to explain the sub-components. We put the context second so we can do eta-reduction with some of our definitions.

observers :: String -> (Observer -> a) -> a

This used used to group several observer instances together.

Instances

Observable Bool

Observable Char

Observable Double

Observable Float

Observable Int

Observable Integer

Observable ()

Observable IOError

Observable a => Observable [a]

Observable a => Observable (IO a)

Observable a => Observable (Maybe a)

(Observable a, Observable b) => Observable (a -> b)

(Observable a, Observable b) => Observable (Either a b)

(Observable a, Observable b) => Observable (a, b)

(Ix a, Observable a, Observable b) => Observable (Array a b)

(Observable a, Observable b, Observable c) => Observable (a, b, c)

(Observable a, Observable b, Observable c, Observable d) => Observable (a, b, c, d)

(Observable a, Observable b, Observable c, Observable d, Observable e) => Observable (a, b, c, d, e)

runO :: IO a -> IO ()

Runs observe ridden code.

printO :: Show a => a -> IO ()

Runs and prints observe ridden code.

putStrO :: String -> IO ()

Prints a string during observation.

newtype ObserverM a

A simple state monad for placing numbers on sub-observations.

Constructors

ObserverM

Fields

runMO :: Int -> Int -> (a, Int)

Instances

Monad ObserverM

Functor ObserverM

Applicative ObserverM

For advanced users, that want to render their own datatypes.

(<<) :: Observable a => ObserverM (a -> b) -> a -> ObserverM b infixl 9

the infix (<<) is a shortcut for constructor arguments.

thunk :: Observable a => a -> ObserverM a

thunk is for marking suspensions.

send :: String -> ObserverM a -> Parent -> a

Sends a packet to the observation agent.

observeBase :: Show a => a -> Parent -> a

The strictness (by using seq) is the same as the pattern matching done on other constructors. We evaluate to WHNF, and not further.

Observe a base type

observeOpaque :: String -> a -> Parent -> a

Observe a base type as an opaque string.

data Parent

Parent book-keeping information.

Constructors

Parent

Fields

observeParent :: !Int

my parent

observePort :: !Int

my branch number

Instances

Show Parent

For users that want to write their own render drivers.

debugO :: IO a -> IO [CDS]

Debugs observe ridden code.

data CDS

Constructors

CDSNamed String CDSSet

CDSCons Int String [CDSSet]

CDSFun Int CDSSet CDSSet

CDSEntered Int

Instances

Eq CDS

Ord CDS

Show CDS

type CDSSet = [CDS]