graph-rewriting-0.7.0: Monadic graph rewriting of hypergraphs with ports and multiedges

GraphRewriting.Rule

Description

Rewrite rules are represented as nested monads: a `Rule` is a `Pattern` that returns a `Rewrite` the latter directly defining the transformation of the graph.

For rule construction a few functions a provided: The most basic one is `rewrite`. But in most cases `erase`, `rewire`, and 'replace*' should be more convenient. These functions express rewrites that replace the matched nodes of the `Pattern`, which comes quite close to the `L -> R` form in which graph rewriting rules are usually expressed.

Synopsis

Documentation

data Replace n a Source

Instances

 Monad (Replace n) Functor (Replace n) Applicative (Replace n) Monoid (Replace n ())

type Rule n = Pattern n (Rewrite n ())Source

A rewriting rule is defined as a `Pattern` that returns a `Rewrite`

apply :: Rule n -> Rewrite n ()Source

Apply rule at an arbitrary position if applicable

rewrite :: (Match -> Rewrite n a) -> Rule nSource

primitive rule construction with the matched nodes of the left hand side as a parameter

erase :: View [Port] n => Rule nSource

constructs a rule that deletes all of the matched nodes from the graph

rewire :: View [Port] n => [[Edge]] -> Rule nSource

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.

byNode :: (View [Port] n, View v n) => v -> Replace n ()Source

(>>>) :: Rule n -> Rule n -> Rule nSource

Apply two rules consecutively. Second rule is only applied if first one succeeds. Fails if (and only if) first rule fails.

exhaustive :: Rule n -> Rule nSource

Make a rule exhaustive, i.e. such that (when applied) it reduces redexes until no redexes are occur in the graph.

everywhere :: Rule n -> Rule nSource

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.