This is a library for reifying Haskell data structures in GHC.

Haskell values are mapped into representations that we call

graphs (for want of a better name). The representations are

encoded in the Haskell type Graph, which is just an ordinary

algebraic data type.

The method for reification is:

reify :: a -> IO Graph

Note that it can take _any_ value as its argument, there are

no constraints on that type.

The result is returned in the IO monad because the Graph

that it returns depends on the state of evaluation of the

underlying value. To do otherwise would not be pure.

The reification is conservative (or lazy). It will not cause any

further evaluation of the value being observed. So you can safely

apply reify to lazy data structures etc.

reify also detects cycles in the heap representation of a value.

The cycles are visible in the resulting Graph. If a value has

a finite heap representation, then reify will return a finite

Graph! Each node in the Graph structure is tagged with a unique

label that can be used to identify nodes and re-construct cycles.

reify does not observe other forms of sharing within a value

(sharing that does not lead to cycles).

A method for pretty printing Graphs is provided by the module

PrettyGraph.

Sadly, all functions are represented by the same Graph, and

are pretty printed just as "<Function>".

reify also knows a little bit about exceptions and other slightly

weird things inside GHC, but it is not yet exhaustive (GHC has many

heap object types).

Unfortunately, we need to turn on profiling in order to get GHC to

keep the names of data constructors around on the heap. This is

an ugly hack, and I hope that one day it can be avoided (perhaps

with some help from the compiler team).

If you make any modifications please contribute them back to me.

Thanks.

Bernie: bjpop@cs.mu.oz.au