Language.KURE.Term

This module supports the generic walking of Terms.

The key idea here is that for each type of expression (exp), we have a sum of all the interesting children types (Generic exp). There is always a type that its own Generic, which is used for the deeper syntax tree walks.

Documentation

class Term exp where

Terms are things that syntax are built from.

Associated Types

type Generic exp

Generic is a sum of all the interesting sub-types, transitively, of exp. We use Generic e ~ e to signify that something is its own Generic. Simple expression types might be their own sole Generic, more complex examples will have a new datatype for the Generic, which will also be an instance of class Term.

Methods

select :: Generic exp -> Maybe exp

project projects into a Generic, to get the exp inside, or fails.

inject :: exp -> Generic exp

inject injects an exp into a Generic.

class (Monoid dec, Monad m, Term exp) => Walker m dec exp where

Walker captures how we walk over exp, using a specific m and dec.

Methods

allR :: Rewrite m dec (Generic exp) -> Rewrite m dec exp

allR applies Generic rewrites to all the interesting children of this node.

crushU :: Monoid result => Translate m dec (Generic exp) result -> Translate m dec exp result

allU applied a Generic Translation to a common, Monoidal result, to all the interesting children of this node.

extractR :: (Monad m, Term exp, Monoid dec) => Rewrite m dec (Generic exp) -> Rewrite m dec exp

extractR converts a Rewrite over a Generic into a rewrite over a specific expression type.

promoteR :: (Monad m, Term exp, Monoid dec) => Rewrite m dec exp -> Rewrite m dec (Generic exp)

promoteR promotes a Rewrite into a Generic Rewrite; other types inside Generic cause failure. try can be used to convert a failure-by-default promotion into a 'id-by-default' promotion.

extractU :: (Monad m, Term exp, Monoid dec) => Translate m dec (Generic exp) r -> Translate m dec exp r

extractU converts a Translate taking a Generic into a translate over a specific expression type.

promoteU :: (Monad m, Term exp, Monoid dec) => Translate m dec exp r -> Translate m dec (Generic exp) r

promoteU promotes a Translate into a Generic Translate; other types inside Generic cause failure.

topdownR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec (Generic e) -> Rewrite m dec (Generic e)

apply a rewrite in a top down manner.

bottomupR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec (Generic e) -> Rewrite m dec (Generic e)

apply a rewrite in a bottom up manner.

alltdR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec (Generic e) -> Rewrite m dec (Generic e)

apply a rewrite in a top down manner, prunning at successful rewrites.

downupR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec (Generic e) -> Rewrite m dec (Generic e)

apply a rewrite twice, in a topdown and bottom up way, using one single tree traversal.

innermostR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec (Generic e) -> Rewrite m dec (Generic e)

a fixed point traveral, starting with the innermost term.

foldU :: (e ~ Generic e, Walker m dec e, Monoid r) => Translate m dec (Generic e) r -> Translate m dec (Generic e) r