graphviz-2999.13.0.3: Bindings to Graphviz for graph visualisation.
Safe HaskellSafe-Infered




Four different representations of Dot graphs are available, all of which are based loosely upon the specifications at: The DotRepr class provides a common interface for them (the PrintDotRepr, ParseDotRepr and PPDotRepr classes are used until class aliases are implemented).

Every representation takes in a type parameter: this indicates the node type (e.g. DotGraph Int is a Dot graph with integer nodes). Sum types are allowed, though care must be taken when specifying their ParseDot instances if there is the possibility of overlapping definitions. The GraphID type is an existing sum type that allows textual and numeric values.

If you require using more than one Dot representation, you will most likely need to import at least one of them qualified, as they typically all use the same names.

As a comparison, all four representations provide how you would define the following Dot graph (or at least one isomorphic to it) (the original of which can be found at Note that in all the examples, they are not necessarily done the best way (variables rather than repeated constants, etc.); they are just there to provide a comparison on the structure of each representation.

 digraph G {

 	subgraph cluster_0 {
 		node [style=filled,color=white];
 		a0 -> a1 -> a2 -> a3;
 		label = "process #1";

 	subgraph cluster_1 {
 		node [style=filled];
 		b0 -> b1 -> b2 -> b3;
 		label = "process #2";
 	start -> a0;
 	start -> b0;
 	a1 -> b3;
 	b2 -> a3;
 	a3 -> a0;
 	a3 -> end;
 	b3 -> end;

 	start [shape=Mdiamond];
 	end [shape=Msquare];

Each representation is suited for different things:

is ideal for converting other graph-like data structures into Dot graphs (the Data.GraphViz module provides some functions for this). It is a structured representation of Dot code.
matches the actual structure of Dot code. As such, it is suited for parsing in existing Dot code.
provides graph operations for manipulating Dot graphs; this is suited when you want to edit existing Dot code. It uses generalised Dot graphs for parsing and canonical Dot graphs for printing.
is a much easier representation to use when defining relatively static Dot graphs in Haskell code, and looks vaguely like actual Dot code if you squint a bit.

Please also read the limitations section at the end for advice on how to properly use these Dot representations.



class Ord n => DotRepr dg n whereSource

This class is used to provide a common interface to different ways of representing a graph in Dot form.

You will most probably not need to create your own instances of this class.

The type variable represents the current node type of the Dot graph, and the Ord restriction is there because in practice most implementations of some of these methods require it.


fromCanonical :: DotGraph n -> dg nSource

Convert from a graph in canonical form. This is especially useful when using the functions from Data.GraphViz.Algorithms.

getID :: dg n -> Maybe GraphIDSource

Return the ID of the graph.

setID :: GraphID -> dg n -> dg nSource

Set the ID of the graph.

graphIsDirected :: dg n -> BoolSource

Is this graph directed?

setIsDirected :: Bool -> dg n -> dg nSource

Set whether a graph is directed or not.

graphIsStrict :: dg n -> BoolSource

Is this graph strict? Strict graphs disallow multiple edges.

setStrictness :: Bool -> dg n -> dg nSource

A strict graph disallows multiple edges.

mapDotGraph :: (Ord n', DotRepr dg n') => (n -> n') -> dg n -> dg n'Source

Change the node values. This function is assumed to be injective, otherwise the resulting graph will not be identical to the original (modulo labels).

graphStructureInformation :: dg n -> (GlobalAttributes, ClusterLookup)Source

Return information on all the clusters contained within this DotRepr, as well as the top-level GraphAttrs for the overall graph.

nodeInformation :: Bool -> dg n -> NodeLookup nSource

Return information on the DotNodes contained within this DotRepr. The Bool parameter indicates if applicable NodeAttrs should be included.

edgeInformation :: Bool -> dg n -> [DotEdge n]Source

Return information on the DotEdges contained within this DotRepr. The Bool parameter indicates if applicable EdgeAttrs should be included.

unAnonymise :: dg n -> dg nSource

Give any anonymous sub-graphs or clusters a unique identifier (i.e. there will be no Nothing key in the ClusterLookup from graphStructureInformation).


class PrintDot a whereSource

A class used to correctly print parts of the Graphviz Dot language. Minimal implementation is unqtDot.


unqtDot :: a -> DotCodeSource

The unquoted representation, for use when composing values to produce a larger printing value.

toDot :: a -> DotCodeSource

The actual quoted representation; this should be quoted if it contains characters not permitted a plain ID String, a number or it is not an HTML string. Defaults to unqtDot.

unqtListToDot :: [a] -> DotCodeSource

The correct way of representing a list of this value when printed; not all Dot values require this to be implemented. Defaults to Haskell-like list representation.

listToDot :: [a] -> DotCodeSource

The quoted form of unqtListToDot; defaults to wrapping double quotes around the result of unqtListToDot (since the default implementation has characters that must be quoted).


PrintDot Bool 
PrintDot Char 
PrintDot Double 
PrintDot Int 
PrintDot Integer 
PrintDot Word8 
PrintDot Word16 
PrintDot Text 
PrintDot BrewerName 
PrintDot BrewerScheme 
PrintDot ColorScheme 
PrintDot X11Color 
PrintDot CompassPoint 
PrintDot PortPos 
PrintDot PortName 
PrintDot SVGColor 
PrintDot Color 
PrintDot Scale 
PrintDot VAlign 
PrintDot Align 
PrintDot Attribute 
PrintDot Img 
PrintDot Cell 
PrintDot Row 
PrintDot Table 
PrintDot Format 
PrintDot TextItem 
PrintDot Label 
PrintDot Ratios 
PrintDot Justification 
PrintDot ScaleType 
PrintDot Paths 
PrintDot VerticalPlacement 
PrintDot FocusType 
PrintDot ViewPort 
PrintDot StyleName 
PrintDot StyleItem 
PrintDot STStyle 
PrintDot StartType 
PrintDot SmoothType 
PrintDot Shape 
PrintDot RankDir 
PrintDot RankType 
PrintDot Root 
PrintDot QuadType 
PrintDot Spline 
PrintDot PageDir 
PrintDot EdgeType 
PrintDot Pos 
PrintDot PackMode 
PrintDot Pack 
PrintDot OutputMode 
PrintDot Order 
PrintDot LayerList 
PrintDot LayerID 
PrintDot LayerRange 
PrintDot LayerSep 
PrintDot Overlap 
PrintDot Point 
PrintDot LabelScheme 
PrintDot RecordField 
PrintDot Label 
PrintDot Model 
PrintDot ModeType 
PrintDot DPoint 
PrintDot DEConstraints 
PrintDot DirType 
PrintDot ClusterMode 
PrintDot Rect 
PrintDot AspectType 
PrintDot ArrowSide 
PrintDot ArrowFill 
PrintDot ArrowModifier 
PrintDot ArrowShape 
PrintDot ArrowType 
PrintDot Attribute 
PrintDot GlobalAttributes 
PrintDot GraphID 
PrintDot a => PrintDot [a] 
PrintDot n => PrintDot (DotEdge n) 
PrintDot n => PrintDot (DotNode n) 
PrintDot n => PrintDot (DotSubGraph n) 
PrintDot n => PrintDot (DotStatements n) 
PrintDot n => PrintDot (DotGraph n) 
PrintDot n => PrintDot (DotSubGraph n) 
PrintDot n => PrintDot (DotStatement n) 
PrintDot n => PrintDot (DotGraph n) 
(Ord n, PrintDot n) => PrintDot (DotGraph n)

Uses the PrintDot instance for canonical DotGraphs.

class ParseDot a whereSource


ParseDot Bool 
ParseDot Char 
ParseDot Double 
ParseDot Int 
ParseDot Integer 
ParseDot Word8 
ParseDot Word16 
ParseDot Text 
ParseDot BrewerName 
ParseDot BrewerScheme 
ParseDot ColorScheme 
ParseDot X11Color 
ParseDot CompassPoint 
ParseDot PortPos 
ParseDot PortName 
ParseDot SVGColor 
ParseDot Color 
ParseDot Scale 
ParseDot VAlign 
ParseDot Align 
ParseDot Attribute 
ParseDot Img 
ParseDot Cell 
ParseDot Row 
ParseDot Table 
ParseDot Format 
ParseDot TextItem 
ParseDot Label 
ParseDot Ratios 
ParseDot Justification 
ParseDot ScaleType 
ParseDot Paths 
ParseDot VerticalPlacement 
ParseDot FocusType 
ParseDot ViewPort 
ParseDot StyleName 
ParseDot StyleItem 
ParseDot STStyle 
ParseDot StartType 
ParseDot SmoothType 
ParseDot Shape 
ParseDot RankDir 
ParseDot RankType 
ParseDot Root 
ParseDot QuadType 
ParseDot Spline 
ParseDot PageDir 
ParseDot EdgeType 
ParseDot Pos 
ParseDot PackMode 
ParseDot Pack 
ParseDot OutputMode 
ParseDot Order 
ParseDot LayerList 
ParseDot LayerID 
ParseDot LayerRange 
ParseDot LayerSep 
ParseDot Overlap 
ParseDot Point 
ParseDot LabelScheme 
ParseDot RecordField 
ParseDot Label 
ParseDot Model 
ParseDot ModeType 
ParseDot DPoint 
ParseDot DEConstraints 
ParseDot DirType 
ParseDot ClusterMode 
ParseDot Rect 
ParseDot AspectType 
ParseDot ArrowSide 
ParseDot ArrowFill 
ParseDot ArrowModifier 
ParseDot ArrowShape 
ParseDot ArrowType 
ParseDot Attribute 
ParseDot GlobalAttributes 
ParseDot GraphID 
ParseDot a => ParseDot [a] 
ParseDot n => ParseDot (DotEdge n) 
ParseDot n => ParseDot (DotNode n) 
ParseDot n => ParseDot (DotSubGraph n) 
ParseDot n => ParseDot (DotStatements n) 
ParseDot n => ParseDot (DotGraph n) 
ParseDot n => ParseDot (DotSubGraph n) 
ParseDot n => ParseDot (DotStatement n) 
ParseDot n => ParseDot (DotGraph n) 
(Ord n, ParseDot n) => ParseDot (DotGraph n)

Uses the ParseDot instance for generalised DotGraphs.

class (DotRepr dg n, PrintDot (dg n)) => PrintDotRepr dg n Source

This class exists just to make type signatures nicer; all instances of DotRepr should also be an instance of PrintDotRepr.

class (DotRepr dg n, ParseDot (dg n)) => ParseDotRepr dg n Source

This class exists just to make type signatures nicer; all instances of DotRepr should also be an instance of ParseDotRepr.

class (PrintDotRepr dg n, ParseDotRepr dg n) => PPDotRepr dg n Source

This class exists just to make type signatures nicer; all instances of DotRepr should also be an instance of PPDotRepr.


Common sub-types

data GraphID Source

A polymorphic type that covers all possible ID values allowed by Dot syntax. Note that whilst the ParseDot and PrintDot instances for String will properly take care of the special cases for numbers, they are treated differently here.


Str Text 
Int Int 
Dbl Double 

class ToGraphID a whereSource

A convenience class to make it easier to convert data types to GraphID values, e.g. for cluster identifiers.

In most cases, conversion would be via the Text or String instances (e.g. using show).


toGraphID :: a -> GraphIDSource


ToGraphID Char 
ToGraphID Double 
ToGraphID Int 
ToGraphID Integer

This instance loses precision by going via Int.

ToGraphID String 
ToGraphID Text 

textGraphID :: Text -> GraphIDSource

An alias for toGraphID for use with the OverloadedStrings extension.

data GlobalAttributes Source

Represents a list of top-level list of Attributes for the entire graph/sub-graph. Note that GraphAttrs also applies to DotSubGraphs.

Note that Dot allows a single Attribute to be listed on a line; if this is the case then when parsing, the type of Attribute it is determined and that type of GlobalAttribute is created.




attrs :: Attributes


attrs :: Attributes


attrs :: Attributes

data DotNode n Source

A node in DotGraph.




Functor DotNode 
Eq n => Eq (DotNode n) 
Ord n => Ord (DotNode n) 
Read n => Read (DotNode n) 
Show n => Show (DotNode n) 
ParseDot n => ParseDot (DotNode n) 
PrintDot n => PrintDot (DotNode n) 

data DotEdge n Source

An edge in DotGraph.




fromNode :: n
toNode :: n
edgeAttributes :: Attributes


Functor DotEdge 
Eq n => Eq (DotEdge n) 
Ord n => Ord (DotEdge n) 
Read n => Read (DotEdge n) 
Show n => Show (DotEdge n) 
ParseDot n => ParseDot (DotEdge n) 
PrintDot n => PrintDot (DotEdge n) 

Helper types for looking up information within a DotRepr.

type ClusterLookup = Map (Maybe GraphID) ([Path], GlobalAttributes)Source

The available information for each cluster; the [Path] denotes all locations where that particular cluster is located (more than one location can indicate possible problems).

type NodeLookup n = Map n (Path, Attributes)Source

The available information on each DotNode (both explicit and implicit).

type Path = Seq (Maybe GraphID)Source

The path of clusters that must be traversed to reach this spot.

Obtaining the DotNodes and DotEdges.

graphNodes :: DotRepr dg n => dg n -> [DotNode n]Source

Returns all resultant DotNodes in the DotRepr (not including NodeAttrs).

graphEdges :: DotRepr dg n => dg n -> [DotEdge n]Source

Returns all resultant DotEdges in the DotRepr (not including EdgeAttrs).

Printing and parsing a DotRepr.

printDotGraph :: PrintDotRepr dg n => dg n -> TextSource

The actual Dot code for an instance of DotRepr. Note that it is expected that parseDotGraph . printDotGraph == id (this might not be true the other way around due to un-parseable components).

parseDotGraph :: ParseDotRepr dg n => Text -> dg nSource

Parse a limited subset of the Dot language to form an instance of DotRepr. Each instance may have its own limitations on what may or may not be parseable Dot code.

Also removes any comments, etc. before parsing.

Limitations and documentation

Printing of Dot code is done as strictly as possible, whilst parsing is as permissive as possible. For example, if the types allow it then "2" will be parsed as an Int value. Note that quoting and escaping of textual values is done automagically.

A summary of known limitations/differences:

  • When creating GraphID values for graphs and sub-graphs, you should ensure that none of them have the same printed value as one of the node identifiers values to avoid any possible problems.
  • If you want any GlobalAttributes in a sub-graph and want them to only apply to that sub-graph, then you must ensure it does indeed have a valid GraphID.
  • All sub-graphs which represent clusters should have unique identifiers (well, only if you want them to be generated sensibly).
  • If eventually outputting to a format such as SVG, then you should make sure to specify an identifier for the overall graph, as that is used as the title of the resulting image.
  • Whilst the graphs, etc. are polymorphic in their node type, you should ensure that you use a relatively simple node type (that is, it only covers a single line, etc.).
  • Also, whilst Graphviz allows you to mix the types used for nodes, this library requires/assumes that they are all the same type (but you can use a sum-type).
  • DotEdge defines an edge (a, b) (with an edge going from a to b); in Dot parlance the edge has a head at a and a tail at b. Care must be taken when using the related Head* and Tail* Attributes. See the differences section in Data.GraphViz.Attributes for more information.
  • It is common to see multiple edges defined on the one line in Dot (e.g. n1 -> n2 -> n3 means to create a directed edge from n1 to n2 and from n2 to n3). These types of edge definitions are parseable; however, they are converted to singleton edges.
  • It is not yet possible to create or parse edges with subgraphs/clusters as one of the end points.
  • The parser will strip out comments and pre-processor lines, join together multiline statements and concatenate split strings together. However, pre-processing within HTML-like labels is currently not supported.
  • Graphviz allows a node to be "defined" twice (e.g. the actual node definition, and then in a subgraph with extra global attributes applied to it). This actually represents the same node, but when parsing they will be considered as separate DotNodes (such that graphNodes will return both "definitions"). canonicalise from Data.GraphViz.Algorithms can be used to fix this.

See Data.GraphViz.Attributes.Complete for more limitations.