GHC.Debug.Types.Graph

Types

data HeapGraph a

The whole graph. The suggested interface is to only use lookupHeapGraph, as the internal representation may change. Nevertheless, we export it here: Sometimes the user knows better what he needs than we do.

Constructors

HeapGraph

Fields

• roots :: !(NonEmpty ClosurePtr)
• graph :: !(IntMap (HeapGraphEntry a))

Instances

Foldable HeapGraph

Defined in GHC.Debug.Types.Graph

Methods

fold :: Monoid m => HeapGraph m -> m

foldMap :: Monoid m => (a -> m) -> HeapGraph a -> m

foldMap' :: Monoid m => (a -> m) -> HeapGraph a -> m

foldr :: (a -> b -> b) -> b -> HeapGraph a -> b

foldr' :: (a -> b -> b) -> b -> HeapGraph a -> b

foldl :: (b -> a -> b) -> b -> HeapGraph a -> b

foldl' :: (b -> a -> b) -> b -> HeapGraph a -> b

foldr1 :: (a -> a -> a) -> HeapGraph a -> a

foldl1 :: (a -> a -> a) -> HeapGraph a -> a

toList :: HeapGraph a -> [a]

null :: HeapGraph a -> Bool

length :: HeapGraph a -> Int

elem :: Eq a => a -> HeapGraph a -> Bool

maximum :: Ord a => HeapGraph a -> a

minimum :: Ord a => HeapGraph a -> a

sum :: Num a => HeapGraph a -> a

product :: Num a => HeapGraph a -> a

Traversable HeapGraph

Defined in GHC.Debug.Types.Graph

Methods

traverse :: Applicative f => (a -> f b) -> HeapGraph a -> f (HeapGraph b)

sequenceA :: Applicative f => HeapGraph (f a) -> f (HeapGraph a)

mapM :: Monad m => (a -> m b) -> HeapGraph a -> m (HeapGraph b)

sequence :: Monad m => HeapGraph (m a) -> m (HeapGraph a)

Functor HeapGraph

Defined in GHC.Debug.Types.Graph

Methods

fmap :: (a -> b) -> HeapGraph a -> HeapGraph b

(<$) :: a -> HeapGraph b -> HeapGraph a

Show a => Show (HeapGraph a)

Defined in GHC.Debug.Types.Graph

Methods

showsPrec :: Int -> HeapGraph a -> ShowS

show :: HeapGraph a -> String

showList :: [HeapGraph a] -> ShowS

data HeapGraphEntry a

For heap graphs, i.e. data structures that also represent sharing and cyclic structures, these are the entries. If the referenced value is Nothing, then we do not have that value in the map, most likely due to exceeding the recursion bound passed to buildHeapGraph.

Besides a pointer to the stored value and the closure representation we have a slot for arbitrary data, for the user's convenience.

Constructors

HeapGraphEntry

Fields

• hgeClosurePtr :: ClosurePtr
• hgeClosure :: DebugClosure SrtHI PapHI ConstrDesc StackHI (Maybe HeapGraphIndex)
• hgeData :: a

Instances

Foldable HeapGraphEntry

Defined in GHC.Debug.Types.Graph

Methods

fold :: Monoid m => HeapGraphEntry m -> m

foldMap :: Monoid m => (a -> m) -> HeapGraphEntry a -> m

foldMap' :: Monoid m => (a -> m) -> HeapGraphEntry a -> m

foldr :: (a -> b -> b) -> b -> HeapGraphEntry a -> b

foldr' :: (a -> b -> b) -> b -> HeapGraphEntry a -> b

foldl :: (b -> a -> b) -> b -> HeapGraphEntry a -> b

foldl' :: (b -> a -> b) -> b -> HeapGraphEntry a -> b

foldr1 :: (a -> a -> a) -> HeapGraphEntry a -> a

foldl1 :: (a -> a -> a) -> HeapGraphEntry a -> a

toList :: HeapGraphEntry a -> [a]

null :: HeapGraphEntry a -> Bool

length :: HeapGraphEntry a -> Int

elem :: Eq a => a -> HeapGraphEntry a -> Bool

maximum :: Ord a => HeapGraphEntry a -> a

minimum :: Ord a => HeapGraphEntry a -> a

sum :: Num a => HeapGraphEntry a -> a

product :: Num a => HeapGraphEntry a -> a

Traversable HeapGraphEntry

Defined in GHC.Debug.Types.Graph

Methods

traverse :: Applicative f => (a -> f b) -> HeapGraphEntry a -> f (HeapGraphEntry b)

sequenceA :: Applicative f => HeapGraphEntry (f a) -> f (HeapGraphEntry a)

mapM :: Monad m => (a -> m b) -> HeapGraphEntry a -> m (HeapGraphEntry b)

sequence :: Monad m => HeapGraphEntry (m a) -> m (HeapGraphEntry a)

Functor HeapGraphEntry

Defined in GHC.Debug.Types.Graph

Methods

fmap :: (a -> b) -> HeapGraphEntry a -> HeapGraphEntry b

(<$) :: a -> HeapGraphEntry b -> HeapGraphEntry a

Show a => Show (HeapGraphEntry a)

Defined in GHC.Debug.Types.Graph

Methods

showsPrec :: Int -> HeapGraphEntry a -> ShowS

show :: HeapGraphEntry a -> String

showList :: [HeapGraphEntry a] -> ShowS

type HeapGraphIndex = ClosurePtr

type PapHI = GenPapPayload (Maybe HeapGraphIndex)

type StackHI = GenStackFrames (GenSrtPayload (Maybe HeapGraphIndex)) (Maybe HeapGraphIndex)

type SrtHI = GenSrtPayload (Maybe HeapGraphIndex)

Building a heap graph

type DerefFunction m a = ClosurePtr -> m (DebugClosureWithExtra a SrtPayload PapPayload ConstrDesc (GenStackFrames SrtPayload ClosurePtr) ClosurePtr)

buildHeapGraph

Arguments

:: MonadFix m

=> DerefFunction m a

-> Maybe Int

-> ClosurePtr

The value to start with

-> m (HeapGraph a)

Creates a HeapGraph for the value in the box, but not recursing further than the given limit.

multiBuildHeapGraph

Arguments

:: MonadFix m

=> DerefFunction m a

-> Maybe Int

-> NonEmpty ClosurePtr

Starting values with associated data entry

-> m (HeapGraph a)

Creates a HeapGraph for the values in multiple boxes, but not recursing further than the given limit.

generalBuildHeapGraph :: forall m a. MonadFix m => DerefFunction m a -> Maybe Int -> HeapGraph a -> NonEmpty ClosurePtr -> m (HeapGraph a)

Printing a heap graph

ppHeapGraph :: (a -> String) -> HeapGraph a -> String

Pretty-prints a HeapGraph. The resulting string contains newlines. Example for let s = "Ki" in (s, s, cycle "Ho"):

let x1 = "Ki"
    x6 = C# 'H' : C# 'o' : x6
in (x1,x1,x6)

ppClosure :: (Int -> c -> String) -> Int -> DebugClosure (GenSrtPayload c) p ConstrDesc s c -> String

A pretty-printer that tries to generate valid Haskell for evalutated data. It assumes that for the included boxes, you already replaced them by Strings using map or, if you need to do IO, mapM.

The parameter gives the precedendence, to avoid avoidable parenthesises.

Utility

lookupHeapGraph :: HeapGraphIndex -> HeapGraph a -> Maybe (HeapGraphEntry a)

traverseHeapGraph :: Applicative m => (HeapGraphEntry a -> m (HeapGraphEntry b)) -> HeapGraph a -> m (HeapGraph b)

updateHeapGraph :: (HeapGraphEntry a -> Maybe (HeapGraphEntry a)) -> HeapGraphIndex -> HeapGraph a -> HeapGraph a

heapGraphSize :: HeapGraph a -> Int

annotateHeapGraph :: (a -> a) -> HeapGraphIndex -> HeapGraph a -> HeapGraph a

Adds the given annotation to the entry at the given index, using the mappend operation of its Monoid instance.

Reverse Graph

data ReverseGraph

mkReverseGraph :: HeapGraph a -> ReverseGraph

reverseEdges :: ClosurePtr -> ReverseGraph -> Maybe [ClosurePtr]