Modulefgl-5.8.3.1Haskell98

Data.Graph.Inductive.NodeMap

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

Contents

Functional Construction
Map Construction
Graph Construction
Monadic Construction
Map Construction
Graph Construction
Map inspection

Synopsis

data NodeMap
value new
value fromGraph
value mkNode
value mkNode_
value mkNodes
value mkLookupNode
value mkNodes_
value mkEdge
value mkEdges
value insMapNode
value insMapLookupNode
value insMapNode_
value insMapEdge
value delMapNode
value delMapEdge
value insMapNodes
value insMapNodes_
value insMapEdges
value delMapNodes
value delMapEdges
value mkMapGraph
type NodeMapM
value run
value run_
value mkNodeM
value mkNodesM
value mkEdgeM
value mkEdgesM
value insMapNodeM
value insMapEdgeM
value delMapNodeM
value delMapEdgeM
value insMapNodesM
value insMapEdgesM
value delMapNodesM
value delMapEdgesM
value memberNode
value lookupNode

Packagefgl-5.8.3.1
Exports39
LanguageHaskell98
LicenceBSD-3-Clause
SourceNodeMap.hs

Functional Construction

datadata NodeMap a

Instances4Eq, Read, Show, NFData

Eq a => Eq (NodeMap a)Defined in fgl-5.8.3.1 · Data.Graph.Inductive.NodeMap
(Ord a, Read a) => Read (NodeMap a)Defined in fgl-5.8.3.1 · Data.Graph.Inductive.NodeMap
Show a => Show (NodeMap a)Defined in fgl-5.8.3.1 · Data.Graph.Inductive.NodeMap
NFData a => NFData (NodeMap a)Defined in fgl-5.8.3.1 · Data.Graph.Inductive.NodeMap

Map Construction

valuenew :: NodeMap a

Source#

Create a new, empty mapping.

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

Source#

Generate a mapping containing the nodes in the given graph.

valuemkNode :: 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.

valuemkNode_ :: Ord a => NodeMap a -> a -> LNode a

Source#

Generate a labelled node and throw away the modified NodeMap.

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

Source#

Construct a list of nodes.

valuemkLookupNode :: Ord a => NodeMap a -> a -> (Bool, LNode a, NodeMap a)

Source#

Act as mkNode, but return also a boolean set as True if the node was already in the map.

valuemkNodes_ :: Ord a => NodeMap a -> [a] -> [LNode a]

Source#

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

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

Source#

Generate a LEdge from the node labels.

valuemkEdges :: 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 Data.Graph.Inductive.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.

valueinsMapNode

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

valueinsMapLookupNode

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

Source#

Act as insMapNode, but return also a boolean set as True if the node was already in the map.

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

valueinsMapEdge

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

Source#

Partial function: raises exception if passed nodes that are not in the graph.

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

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

Source#

Partial function: raises exception if passed nodes that are not in the graph.

valueinsMapNodes

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

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

valueinsMapEdges

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

Source#

Partial function: raises exception if passed nodes that are not in the graph.

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

valuedelMapEdges

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

Source#

Partial function: raises exception if passed nodes that are not in the graph.

valuemkMapGraph

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

Source#

Partial function: raises exception if passed a node that is not in the graph.

Monadic Construction

typetype NodeMapM a b (g :: Type -> Type -> Type) r = State (NodeMap a, g a b) r

Source#

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

valuerun

:: (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.

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

Source#

Run a construction and only return the Graph.

valuemkNodeM :: Ord a => a -> NodeMapM a b g (LNode a)

Source#

Monadic node construction.

valuemkNodesM :: Ord a => [a] -> NodeMapM a b g [LNode a]

valuemkEdgeM :: Ord a => (a, a, b) -> NodeMapM a b g (Maybe (LEdge b))

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

Graph Construction

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

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

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

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

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

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

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

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

Map inspection

valuememberNode :: Ord a => a -> NodeMap a -> Bool

Source#

Is the node in the map ?

valuelookupNode :: Ord a => a -> NodeMap a -> Maybe Node

Source#

Lookup for the node in the map.