Text.Dot.Gen

Generating graph contents

Documentation

graph

Arguments

:: GraphType

-> GraphName

Internal graph name

-> DotGen a

Content

-> DotGraph

Generate a haphviz graph with a given name and content

>>> graph directed "mygraph" $ do
        a <- node "a"
        b <- node "b"
        a --> b
> graph mygraph {
>   0 [label="a"];
>   1 [label="b"];
>   0 -- 1;
> }

graph_

Arguments

:: GraphType

-> DotGen a

Content

-> DotGraph

Like graph but without an internal graph name

graph_ gt func = graph gt "haphviz" func

genDot :: DotGen a -> Dot

Generate Internal dot content AST

genSubDot :: Int -> DotGen a -> Dot

Utility function to generate a graph with nameless nodes starting from a given starting number.

genSubDot' :: Int -> DotGen a -> ((a, State), Dot)

Graph types

directed :: GraphType

Directed graph

>>> directed
> digraph

undirected :: GraphType

Undirected graph

>>> undirected
> graph

Nodes

genNode :: NodeId -> [Attribute] -> DotGen ()

Most general node declaration

This allows you to specify a node identifier for the node.

In general it is more efficient to use nameless nodes and have the identifiers generated for you.

It also allows you to specify attributes. In general it is better to use namelessNode.

>>> n <- newNode
>>> genNode n [color =: green]
> 0 [color="green"];

namedNode

Arguments

:: Text

Name

-> [Attribute]

-> DotGen NodeId

Node with given (internal) name and attributes

Aside from human-readable output, there is no reason to use named nodes. Use node instead.

>>> void $ namedNode "woohoo" [color =: red]
> wohoo [color="red"];

namelessNode :: [Attribute] -> DotGen NodeId

Nameless node with attributes

This generates a nameless node for you but still allows you to specify its individual attributes. In general it is better to use nodeDec and then node.

>>> void $ namelessNode [color =: blue]
> 0 [color="blue"];

node

Arguments

:: Text

Label

-> DotGen NodeId

Node with a label but no other attributes

A node with a given label and no other attributes. Usually used in conjunction with nodeDec.

>>> void $ node "server"
> 0 [label="server"];

node_

Arguments

:: NodeId

given Node ID

-> Text

Label

-> DotGen ()

Node with given node Id and label

node_ ni l = genNode ni [label =: l]

newNode :: DotGen NodeId

Generate a new internally nameless node ID

It is not generally a good idea to use this directly but it can be used to define node identifiers before a subgraph to reference them both in- and outside of it.

Edges

genEdge :: NodeId -> NodeId -> [Attribute] -> DotGen ()

Most general edge declaration

This allows you to specify attributes for a single edge.

Usually it is better to use edgeDec and then -->.

>>> genEdge a b [label =: "MyEdge"]
> a -> b [label="MyEdge"];

(-->) :: NodeId -> NodeId -> DotGen ()

Infix edge constructor. (No attributes)

This takes care of using the right edge declaration for the given graph.

For undirected graphs, the output would be -- ...

>>> a --> b
> a -- b;

... and for directed graphs it would be ->.

>>> a --> b
> a -> b;

Attributes

(=:) :: AttributeName -> AttributeValue -> Attribute

Infix operator for an attribute pair

>>> [label =: "MyNode"]
> [label="MyNode"]

Declarations

genDec :: DecType -> [Attribute] -> DotGen ()

General declaration of common attributes

graphDec :: [Attribute] -> DotGen ()

Graph declaration

>>> graphDec [compound =: true]
> graph [compound=true];

nodeDec :: [Attribute] -> DotGen ()

Node declaration

>>> nodeDec [shape =: none]
> node [shape=none];

edgeDec :: [Attribute] -> DotGen ()

Edge declaration

>>> edgeDec [color =: "red:blue"]
> edge [color="red:blue"];

Subgraphs

cluster :: Text -> DotGen a -> DotGen (GraphName, a)

Cluster with a given name

The cluster_ prefix is taken care of.

cluster_ :: Text -> DotGen a -> DotGen a

Like cluster, discarding the graph name.

subgraph :: Text -> DotGen a -> DotGen (GraphName, a)

Subgraph declaration

This is rarely useful. Just use cluster.

Miscelaneous

Rankdir

rankdir :: RankdirType -> DotGen ()

The rankdir declaration

This changes the default layout of nodes

>>> rankdir leftRight
> rankdir = LR;

leftRight :: RankdirType

>>> leftRight
> LR

rightLeft :: RankdirType

>>> rightLeft
> RL

topBottom :: RankdirType

>>> topBottom
> TB

bottomTop :: RankdirType

>>> bottomTop
> BT

Labels

labelDec :: Text -> DotGen ()

Label declaration for graphs or subgraphs

Ports

(.:)

Arguments

:: NodeId

-> Text

Port

-> NodeId

Use a certain port on a given node's label as an endpoint for an edge

Ranks

ranksame :: DotGen a -> DotGen a

{rank=same ... } declaration

>>> ranksame $ node [shape =: none]
> node [shape=none];

Internals

type DotGen = StateT State (WriterT Dot Identity)

Generation monad

type State = Int

The next id for a nameless node

module Text.Dot.Attributes

data Dot

Haphviz internal graph content AST

Instances

Eq Dot

Methods

(==) :: Dot -> Dot -> Bool

(/=) :: Dot -> Dot -> Bool

Show Dot

Methods

showsPrec :: Int -> Dot -> ShowS

show :: Dot -> String

showList :: [Dot] -> ShowS

Monoid Dot

Dot is a monoid, duh, that's the point.

Methods

mempty :: Dot

mappend :: Dot -> Dot -> Dot

mconcat :: [Dot] -> Dot

data DotGraph

A Haphviz Graph

Instances

Eq DotGraph

Methods

(==) :: DotGraph -> DotGraph -> Bool

(/=) :: DotGraph -> DotGraph -> Bool

Show DotGraph

Methods

showsPrec :: Int -> DotGraph -> ShowS

show :: DotGraph -> String

showList :: [DotGraph] -> ShowS

data NodeId

A node identifier.

This is either a user supplied name or a generated numerical identifier.

Instances

Eq NodeId

Methods

(==) :: NodeId -> NodeId -> Bool

(/=) :: NodeId -> NodeId -> Bool

Show NodeId

Methods

showsPrec :: Int -> NodeId -> ShowS

show :: NodeId -> String

showList :: [NodeId] -> ShowS

type Attribute = (AttributeName, AttributeValue)

Attribute: a tuple of name and value.

type AttributeName = Text

Attribute name: just text

type AttributeValue = Text

Attribute value: just text

data DecType

Declaration type

Used to declare common attributes for nodes or edges.

Instances

Eq DecType

Methods

(==) :: DecType -> DecType -> Bool

(/=) :: DecType -> DecType -> Bool

Show DecType

Methods

showsPrec :: Int -> DecType -> ShowS

show :: DecType -> String

showList :: [DecType] -> ShowS

data RankdirType

Rankdir Type

Used to specify the default node layout direction

Instances

Eq RankdirType

Methods

(==) :: RankdirType -> RankdirType -> Bool

(/=) :: RankdirType -> RankdirType -> Bool

Show RankdirType

Methods

showsPrec :: Int -> RankdirType -> ShowS

show :: RankdirType -> String

showList :: [RankdirType] -> ShowS