GraphRewriting.Pattern

Patterns allow monadic scrutinisation of the graph (modifications are not possible) while keeping track of matched nodes. A Pattern is interpreted by runPattern that returns a result for each position in the graph where the pattern matches. It is allowed to fail inside the Pattern monad, indicating that the pattern does not match, which corresponds to conditional rewriting.

Documentation

runPattern :: Pattern n a -> Graph n -> [(Match, a)]

Apply a pattern on a graph returning a result for each matching position in the graph together with the matched nodes.

evalPattern :: Pattern n a -> Graph n -> [a]

execPattern :: Pattern n a -> Graph n -> [Match]

matches :: Pattern n a -> Pattern n [Match]

probe a pattern returning the matches it has on the graph

(<|>) :: Pattern n a -> Pattern n a -> Pattern n a

choice

anyOf :: [Pattern n a] -> Pattern n a

choice over a list of patterns

require :: Monad m => Bool -> m ()

fail if given pattern succeeds, succeed if it fails. requireFailure  Pattern n a  Pattern n () requireFailure p = require . not =<< probe p

conditional rewriting: fail when predicate is not met

requireM :: Monad m => m Bool -> m ()

fail when monadic predicate is not met

liftReader :: Reader (Graph n) a -> Pattern n a

Lift a scrutinisation from Reader to Pattern. Attention: This does not contribute to returned Match.

node :: View v n => Pattern n v

any node anywhere in the graph

previous :: Pattern n Node

a reference to the lastly matched node

edge :: Pattern n Edge

any edge anywhere in the graph

nodeAt :: View v n => Edge -> Pattern n v

node that is connected to given edge

edgeOf :: View [Port] n => Node -> Pattern n Edge

edge that is attached to given node

neighbour :: (View [Port] n, View v n) => Node -> Pattern n v

node that is connected to the given node, but not that node itself

relative :: (View [Port] n, View v n) => Node -> Pattern n v

node that is connected to the given node, permitting the node itself

adverse :: (View [Port] n, View v n) => Port -> Node -> Pattern n v

nodes connected to given port of the specified node, not including the node itself

history :: Pattern n Match

list of nodes matched until now with the most recent node in head position

nextFresh :: Pattern n a -> Pattern n a

only match nodes in the next node pattern that have not been matched before

nextIs :: Node -> Pattern n a -> Pattern n a

only accept the given node in the next match

restrictOverlap :: (Match -> Match -> Bool) -> Pattern n a -> Pattern n a

First match is the history with the most recently matched node in head position. Second match is the future with the next matched node in head position.

linear :: Pattern n a -> Pattern n a

Nodes in the future may not be matched more than once.

data Pattern n a

Instances

Monad (Pattern n)

MonadPlus (Pattern n)

type Match = [Node]