Ideas.Common.Rule.Transformation

This module defines transformations. Given a term, a transformation returns a list of results (often a singleton list or the empty list).

Trans data type

type Transformation a = Trans a a

data Trans a b

Instances

Arrow Trans

Methods

arr :: (b -> c) -> Trans b c

first :: Trans b c -> Trans (b, d) (c, d)

second :: Trans b c -> Trans (d, b) (d, c)

(***) :: Trans b c -> Trans b' c' -> Trans (b, b') (c, c')

(&&&) :: Trans b c -> Trans b c' -> Trans b (c, c')

ArrowZero Trans

Methods

zeroArrow :: Trans b c

ArrowPlus Trans

Methods

(<+>) :: Trans b c -> Trans b c -> Trans b c

ArrowChoice Trans

Methods

left :: Trans b c -> Trans (Either b d) (Either c d)

right :: Trans b c -> Trans (Either d b) (Either d c)

(+++) :: Trans b c -> Trans b' c' -> Trans (Either b b') (Either c c')

(|||) :: Trans b d -> Trans c d -> Trans (Either b c) d

Functor (Trans a)

Methods

fmap :: (a -> b) -> Trans a a -> Trans a b

(<$) :: a -> Trans a b -> Trans a a

Applicative (Trans a)

Methods

pure :: a -> Trans a a

(<*>) :: Trans a (a -> b) -> Trans a a -> Trans a b

liftA2 :: (a -> b -> c) -> Trans a a -> Trans a b -> Trans a c

(*>) :: Trans a a -> Trans a b -> Trans a b

(<*) :: Trans a a -> Trans a b -> Trans a a

Alternative (Trans a)

Methods

empty :: Trans a a

(<|>) :: Trans a a -> Trans a a -> Trans a a

some :: Trans a a -> Trans a [a]

many :: Trans a a -> Trans a [a]

Category * Trans

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

Semigroup (Trans a b)

Methods

(<>) :: Trans a b -> Trans a b -> Trans a b

sconcat :: NonEmpty (Trans a b) -> Trans a b

stimes :: Integral b => b -> Trans a b -> Trans a b

Monoid (Trans a b)

Methods

mempty :: Trans a b

mappend :: Trans a b -> Trans a b -> Trans a b

mconcat :: [Trans a b] -> Trans a b

HasRefs (Trans a b)

Methods

getRefs :: Trans a b -> [Some Ref]

allRefs :: Trans a b -> [Some Ref]

getRefIds :: Trans a b -> [Id]

Constructor functions

class MakeTrans f where

A type class for constructing a transformation. If possible, makeTrans should be used. Use specialized constructor functions for disambiguation.

Minimal complete definition

makeTrans

Methods

makeTrans :: (a -> f b) -> Trans a b

Instances

MakeTrans []

Methods

makeTrans :: (a -> [b]) -> Trans a b

MakeTrans Maybe

Methods

makeTrans :: (a -> Maybe b) -> Trans a b

transPure :: (a -> b) -> Trans a b

transMaybe :: (a -> Maybe b) -> Trans a b

transList :: (a -> [b]) -> Trans a b

transGuard :: (a -> Bool) -> Trans a a

transRewrite :: RewriteRule a -> Trans a a

Reading and writing (with references)

readRef :: Ref a -> Trans x a

readRefDefault :: a -> Ref a -> Trans x a

readRefMaybe :: Ref a -> Trans x (Maybe a)

writeRef :: Ref a -> Trans a a

writeRef_ :: Ref a -> Trans a ()

writeRefMaybe :: Ref a -> Trans (Maybe a) ()

Lifting transformations

transUseEnvironment :: Trans a b -> Trans (a, Environment) (b, Environment)

transLiftView :: View a b -> Transformation b -> Transformation a

transLiftViewIn :: View a (b, c) -> Transformation b -> Transformation a

transLiftContext :: Transformation a -> Transformation (Context a)

transLiftContextIn :: Transformation (a, Environment) -> Transformation (Context a)

Using transformations

transApply :: Trans a b -> a -> [(b, Environment)]

transApplyWith :: Environment -> Trans a b -> a -> [(b, Environment)]

getRewriteRules :: Trans a b -> [Some RewriteRule]