Generics.Regular.Rewriting.Rules

Summary: Functions for transforming a rule specification to a rule.

Rule specification.

data RuleSpec a

Specifies a rule as a value of a datatype.

Constructors

a :~> a

Instances

Regular a => Builder (RuleSpec a)

lhsR :: RuleSpec a -> a

Returns the left-hand side of a rule.

rhsR :: RuleSpec a -> a

Returns the right-hand side of a rule.

Representation of a rule.

type Rule a = RuleSpec (SchemeOf a)

Allows metavariables on either side of a rule.

type SchemeOf a = Scheme (PF a)

Extends the pattern functor of a value.

type Metavar = Int

metavar :: Metavar -> Scheme f

Constructs a metavariable.

pf :: f (Scheme f) -> Scheme f

Constructs a pattern functor value.

toScheme :: (Regular a, Functor (PF a)) => a -> SchemeOf a

Recursively converts a value to a SchemeOf value.

data SchemeView f

A view on schemes to easily distinguish metavariables from pattern functor values.

Constructors

Metavar Metavar

PF (f (Scheme f))

schemeView :: Scheme f -> SchemeView f

Returns the value corresponding to the SchemeView.

foldScheme :: Functor f => (Metavar -> a) -> (f a -> a) -> Scheme f -> a

Folds a Scheme value given a function to apply to metavariables and a function to apply to a pattern functor value.

Builder for transforming a rule specification to a rule.

class Regular (Target a) => Builder a where

The type class Builder captures the functions, that are defined by induction on the type argument, that construct appropriate left and right values. These values are used to transform a rule specification to a rule.

Associated Types

type Target a :: *

Methods

base :: a -> RuleSpec (Target a)

diag :: a -> [RuleSpec (Target a)]

Instances

Regular a => Builder (RuleSpec a)

(~ * b (Target a), Builder a, Regular b, LR (PF b)) => Builder (b -> a)

ruleM :: (Builder r, Crush (PF (Target r)), Zip (PF (Target r)), Functor (PF (Target r))) => r -> Maybe (Rule (Target r))

Transforms a rule specification to a rule and returns Nothing if an unbound metavariable occurs in the right-hand side of the rule.

rule :: (Builder r, Crush (PF (Target r)), Functor (PF (Target r)), Zip (PF (Target r))) => r -> Rule (Target r)

Transforms a rule specification to a rule and throws a runtime error if an unbound metavariable occurs in the right-hand side of the rule.