fgl-5.4.2.4: Martin Erwig's Functional Graph Library

Data.Graph.Inductive.NodeMap

Description

Utility methods to automatically generate and keep track of a mapping between node labels and Nodes.

Synopsis

# Functional Construction

data Ord a => NodeMap a Source

Instances

 (Ord a, Show a) => Show (NodeMap a)

## Map Construction

new :: Ord a => NodeMap aSource

Create a new, empty mapping.

fromGraph :: (Ord a, Graph g) => g a b -> NodeMap aSource

Generate a mapping containing the nodes in the given graph.

mkNode :: Ord a => NodeMap a -> a -> (LNode a, NodeMap a)Source

Generate a labelled node from the given label. Will return the same node for the same label.

mkNode_ :: Ord a => NodeMap a -> a -> LNode aSource

Generate a labelled node and throw away the modified NodeMap.

mkNodes :: Ord a => NodeMap a -> [a] -> ([LNode a], NodeMap a)Source

Construct a list of nodes.

mkNodes_ :: Ord a => NodeMap a -> [a] -> [LNode a]Source

Construct a list of nodes and throw away the modified NodeMap.

mkEdge :: Ord a => NodeMap a -> (a, a, b) -> Maybe (LEdge b)Source

Generate a LEdge from the node labels.

mkEdges :: Ord a => NodeMap a -> [(a, a, b)] -> Maybe [LEdge b]Source

Generates a list of LEdges.

## Graph Construction

These functions mirror the construction and destruction functions in Graph, but use the given NodeMap to look up the appropriate Nodes. Note that the insMapNode family of functions will create new nodes as needed, but the other functions will not.

insMapNode :: (Ord a, DynGraph g) => NodeMap a -> a -> g a b -> (g a b, NodeMap a, LNode a)Source

insMapNode_ :: (Ord a, DynGraph g) => NodeMap a -> a -> g a b -> g a bSource

insMapEdge :: (Ord a, DynGraph g) => NodeMap a -> (a, a, b) -> g a b -> g a bSource

delMapNode :: (Ord a, DynGraph g) => NodeMap a -> a -> g a b -> g a bSource

delMapEdge :: (Ord a, DynGraph g) => NodeMap a -> (a, a) -> g a b -> g a bSource

insMapNodes :: (Ord a, DynGraph g) => NodeMap a -> [a] -> g a b -> (g a b, NodeMap a, [LNode a])Source

insMapNodes_ :: (Ord a, DynGraph g) => NodeMap a -> [a] -> g a b -> g a bSource

insMapEdges :: (Ord a, DynGraph g) => NodeMap a -> [(a, a, b)] -> g a b -> g a bSource

delMapNodes :: (Ord a, DynGraph g) => NodeMap a -> [a] -> g a b -> g a bSource

delMapEdges :: (Ord a, DynGraph g) => NodeMap a -> [(a, a)] -> g a b -> g a bSource

mkMapGraph :: (Ord a, DynGraph g) => [a] -> [(a, a, b)] -> (g a b, NodeMap a)Source

type NodeMapM a b g r = State (NodeMap a, g a b) rSource

Graph construction monad; handles passing both the NodeMap and the Graph.

The following mirror the functional construction functions, but handle passing NodeMaps and Graphs behind the scenes.

## Map Construction

run :: (DynGraph g, Ord a) => g a b -> NodeMapM a b g r -> (r, (NodeMap a, g a b))Source

Run a construction; return the value of the computation, the modified NodeMap, and the modified Graph.

run_ :: (DynGraph g, Ord a) => g a b -> NodeMapM a b g r -> g a bSource

Run a construction and only return the Graph.

mkNodeM :: (Ord a, DynGraph g) => a -> NodeMapM a b g (LNode a)Source

mkNodesM :: (Ord a, DynGraph g) => [a] -> NodeMapM a b g [LNode a]Source

mkEdgeM :: (Ord a, DynGraph g) => (a, a, b) -> NodeMapM a b g (Maybe (LEdge b))Source

mkEdgesM :: (Ord a, DynGraph g) => [(a, a, b)] -> NodeMapM a b g (Maybe [LEdge b])Source

## Graph Construction

insMapNodeM :: (Ord a, DynGraph g) => a -> NodeMapM a b g (LNode a)Source

insMapEdgeM :: (Ord a, DynGraph g) => (a, a, b) -> NodeMapM a b g ()Source

delMapNodeM :: (Ord a, DynGraph g) => a -> NodeMapM a b g ()Source

delMapEdgeM :: (Ord a, DynGraph g) => (a, a) -> NodeMapM a b g ()Source

insMapNodesM :: (Ord a, DynGraph g) => [a] -> NodeMapM a b g [LNode a]Source

insMapEdgesM :: (Ord a, DynGraph g) => [(a, a, b)] -> NodeMapM a b g ()Source

delMapNodesM :: (Ord a, DynGraph g) => [a] -> NodeMapM a b g ()Source

delMapEdgesM :: (Ord a, DynGraph g) => [(a, a)] -> NodeMapM a b g ()Source