úÎ{Ïsīs      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm n o p q r None$Hypergraph that holds nodes of type n". Nodes can be referenced by type , edges by type , see GraphRewriting.Graph.Read and GraphRewriting.Graph.Write sallocate and reserve a new ref tOHand out an infinite number of fresh refs, without reserving them (obviously). >a hyperedge really, connecting a non-empty subset of the graph' s nodes (see  attachedNodes) uvwxyz {|}~st€‚uvwxyz {|}~stuvwxyz {|}~st€‚None None VNodes matched in the evaluation of a pattern with the lastly matched node at the head fA pattern represents a graph scrutinisation that memorises all the scrutinised nodes during matching.  ƒ„… ƒ„… ƒ„…None6Each edge corresponds to the set of nodes it connects Iunsafe, since no checks are performed to ensure that the invariants from  GraphRewriting.Graph.Write are preserved Kmap that supplies an additional unique key to the mapping function; unsafe  in the same way as  .apply a monadic graph modification to a graph      NoneMinimal complete definition: inspect and one of {update, adjust} Rconvenience function that can be used to access record fields of the exposed type †‡ˆ‰†‡ˆ‰NoneThis forces the use of the ŠĄ monad. Wrapping a sequence of monadic read-only operations (such as those defined below) into a read-only block can save much overhead e.g. in the state monad.  a wrapper to  the given node  a wrapper to  the given node all of the graph's nodes !all of the graph's edges "!edges attached to the given node #2non-empty set of nodes attached to the given edge $4amount of ports the given hyperedge is connected to %Rlist of nodes that are connected to the given node, not including the node itself &Nlist of nodes that are connected to the given node, including the node itself 'Snodes connected to given port of the specified node, not including the node itself ( whether two nodes are connected )1whether the given ports features a dangling edge *7Map node-relative enquiry over the nodes of the graph.  !"#$%&'()* !"#$%&'()* !"#$%&'()* !"#$%&'()*None+fA pattern represents a graph scrutinisation that memorises all the scrutinised nodes during matching. -wApply a pattern on a graph returning a result for each matching position in the graph together with the matched nodes. 0'Something like an implicit monadic map 104 on each node, add it to the history, and return it 2\Probe whether a pattern matches somewhere on the graph. You might want to combine this with C. 3_probe a pattern returning the matches it has on the graph. You might want to combine this with C. 4_probe a pattern returning the matches it has on the graph. You might want to combine this with C. 5choice over a list of patterns 6conditional rewriting: ‹ when predicate is not met 7‹1 if given pattern succeeds, succeed if it fails. 8‹# when monadic predicate is not met 9Lift a scrutinisation from Š to + leaving the history unchanged. :any node anywhere in the graph ;A specific node <any edge anywhere in the graph =%node that is connected to given edge >$edge that is attached to given node ?Cnode that is connected to the given node, but not that node itself @Enode that is connected to the given node, permitting the node itself ATnodes connected to given port of the specified node, not including the node itself.  Consider as an alternative I combined with =. BA specific node CADo not remember any of the nodes matched by the supplied pattern DKlist of nodes matched until now with the most recent node in head position E'a reference to the lastly matched node FGonly match nodes in the next pattern that have not been matched before G-only accept the given node in the next match Hĸ=Restrict a pattern based on the which of nodes have matched been previously and which nodes will be matched in the future. The first parameter of the supplied function is the history with the most recently matched node in head position. The second parameter is the future with the next matched node in head position. I7Nodes in the future may not be matched more than once. &+,-./0123456789:;<=>?@ABCDEFGHIŒŽ‘’" +,-./0123456789:;<=>?@ABCDEFGHI"+,-./0123456789:;<=>?@ABCDEFGHI &+,-./0123456789:;<=>?@ABCDEFGHIŒŽ‘’NoneJKLMNOP JKLMNOPJKLMNOPJKLMNOPNone Qassign new value to given node Rmodify the node value SWraps  to update aspect v of a node. TWraps  to adjust aspect v of a node. Vadd a new node with value n to the graph WGCreate a new node by cloning another, at the same time updating aspect vF. When defining rewrites in a context where it is not known what type nR the nodes of the graph have, this is the only way to add new nodes to the graph. XĄCreate a new (unconnected) edge. It is expected that the created edge is connected to a port sooner or later. Otherwise the graph will invove unconnected edges. Yremove node from the graph Z€Disconnect ports connected to the given edge by assigning a new (dangling) edge to each of the ports. Then the edge is deleted. [eReconnects the ports connected to the second edge to the first one. Then the second edge is deleted. QRSTUVWXYZ[QRSTUVWXYZ[ QRSTUVWXYZ[ QRSTUVWXYZ[ None“FJoin pairs of sets with a common element until all sets are disjoint. ”Add to a list of disjoint sets a further set and join sets with common elements such that the resulting list again only contains disjoint sets. •\–—˜™“”•\–—˜™“”•\–—˜™“”None ]!A rewriting rule is defined as a + that returns a  ^2Apply rule at an arbitrary position if applicable _ZApply rule at an arbitrary position. Return value states whether the rule was applicable. `Xprimitive rule construction with the matched nodes of the left hand side as a parameter aGconstructs a rule that deletes all of the matched nodes from the graph b―Constructs a rule from a list of rewirings. Each rewiring specifies a list of hyperedges that are to be merged into a single hyperedge. All matched nodes of the left-hand side are removed. i{Apply two rules consecutively. Second rule is only applied if first one succeeds. Fails if (and only if) first rule fails. jrMake a rule exhaustive, i.e. such that (when applied) it reduces redexes until no redexes are occur in the graph. k™Make a rule parallel, i.e. such that (when applied) all current redexes are contracted one by one. Neither new redexes or destroyed redexes are reduced. lJRepeatedly apply the rules from the given list prefering earlier entries. M Returns a list of indexes reporting the sequence of rules that has applied. ]^_`abcdefghijklš›œ\]^_`abcdefghijkl\]^_`abcdefghijkl]^_`abcdefghijklš›œ Nonef  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIQRSTUVWXYZ[\]^_`abcdefghijkl Nonem Instead of (,) to save parentheses oBIndex that identifies the principal port within the list of ports mnopqržmnopqropmnqrmnopqržŸ            !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_YZ[\]`abcde fghijklmnopqrstuv w x y z { | } ~    €  j  ‚ ƒ „ … † ‡ ˆ  ‰ Š‹ŒŽ‘’“”•–—˜™š › œ  f ž Ÿ  ĄĒĢĪ ĨĶgraph-rewriting-0.7.2GraphRewriting.PatternGraphRewriting.Graph.TypesGraphRewriting.Graph Data.ViewGraphRewriting.Graph.Read!GraphRewriting.Graph.Write.UnsafeGraphRewriting.Graph.WriteGraphRewriting.Rule%GraphRewriting.Pattern.InteractionNetGraphRewriting.Graph.InternalGraphRewriting.Pattern.InternalGraphRewriting.Rule.InternalGraphRewritingbaseControl.Applicative<|>EdgePortNodeRewriteGraphnodeMapedgeMapnextKeyMatchPatternT emptyGraphnodesedgesunsafeMapNodesunsafeMapNodesUniquerunGraph evalGraph execGraphViewinspectupdateadjustexamineadjustM WithGraphreadOnly existNodereadNode inspectNode examineNode readNodeList readEdgeList attachedEdges attachedNodesedgeCardinality neighbours relatives adverseNodes connecteddangling withNodesPattern runPatternT runPattern evalPattern execPatternbranch branchNodesprobematchesmatchanyOfrequirerequireFailurerequireM liftReadernodenodeAtedgenodeWithedgeOf neighbourrelativeadversevisitamnesiahistoryprevious nextFreshnextIsrestrictOverlaplinear writeNode modifyNode updateNode adjustNode adjustNodeM unregisterregisternewNodecopyNodenewEdge deleteNode deleteEdge mergeEdgesReplaceRuleapplyapply'rewriteeraserewirereplacebyNode byNewNodebyEdgebyWire byConnector>>> exhaustive everywhere benchmarkPair:-:INet principalPortpair activePairnewReffreeRefseKeynKeyreadRefreadEdge modifyNodeMap modifyEdgeMap reserveRefs$fMonadReaderGraphRewrite $fShowPort $fShowNodepatternT runPatternT' $fView(,,,)n $fView(,,)n $fView(,)n$fViewnntransformers-0.2.2.0Control.Monad.Trans.ReaderReaderGHC.Basefail$fMonadPlusPatternT$fMonoidPatternT$fAlternativePatternT$fApplicativePatternT$fFunctorPatternT$fMonadTransPatternT$fMonadPatternTjoinjoin1Set MergeEdgesmergeEs joinEdges$fMonoidReplace$fApplicativeReplace$fFunctorReplace$fMonadReplace $fFunctorPair