Language.KURE.Combinators

This module contains various combinators that use Translate and Rewrite. The convension is that Translate based combinators end with T, and Rewrite based combinators end with R. Of course, because Rewrite is a type synomim of Translate, the Rewrite functions also operate with on Translate, and the Translate functions operate with Rewrite.

The Translate combinators

(<+) :: (Monoid dec, Monad m) => Translate m dec a b -> Translate m dec a b -> Translate m dec a b

like a catch, <+ does the first translate , and if it fails, then does the second translate.

(>->) :: (Monoid dec, Monad m) => Translate m dec a b -> Translate m dec b c -> Translate m dec a c

like a ; If the first translate succeeds, then do to the second translate after the first translate.

failT :: (Monad m, Monoid dec) => String -> Translate m dec a b

failing translation.

readerT :: (Monoid dec, Monad m) => (a -> Translate m dec a b) -> Translate m dec a b

look at the argument for the translation before choosing which translation to perform.

readEnvT :: (Monad m, Monoid dec) => (dec -> Translate m dec a b) -> Translate m dec a b

look at the dec before choosing which translation to do.

mapEnvT :: (Monoid dec, Monad m) => (dec -> dec) -> Translate m dec a r -> Translate m dec a r

change the dec's for a scoped translation.

writeEnvT :: (Monad m, Monoid dec) => dec -> Rewrite m dec a

add to the context dec, which is propogated using a writer monad.

pureT :: (Monad m, Monoid dec) => (a -> b) -> Translate m dec a b

pureT promotes a function into an unfailable, non-identity Translate.

constT :: (Monad m, Monoid dec) => b -> Translate m dec a b

constT always translates into an unfailable Translate that returns the first argument.

concatT :: (Monad m, Monoid dec, Monoid r) => [Translate m dec a r] -> Translate m dec a r

concatT composes a list of Translate into a single Translate which mconcats its result.

The Rewrite combinators

(.+) :: (Monoid dec, Monad m) => Rewrite m dec a -> Rewrite m dec a -> Rewrite m dec a

if the first rewrite is an identity, then do the second rewrite.

(!->) :: (Monoid dec, Monad m) => Rewrite m dec a -> Rewrite m dec a -> Rewrite m dec a

if the first rewrite was not an identity, then also do the second rewrite.

tryR :: (Monoid dec, Monad m) => Rewrite m dec a -> Rewrite m dec a

catch a failing Rewrite, making it into an identity.

changedR :: (Monoid dec, Monad m) => Rewrite m dec a -> Rewrite m dec a

if this is an identity rewrite, make it fail. To succeed, something must have changed.

repeatR :: (Monoid dec, Monad m) => Rewrite m dec a -> Rewrite m dec a

repeat a rewrite until it fails, then return the result before the failure.

acceptR :: (Monoid dec, Monad m) => (a -> Bool) -> Rewrite m dec a

look at the argument to a rewrite, and choose to be either a failure of trivial success.

idR :: (Monad m, Monoid dec) => Rewrite m dec exp

identity rewrite.

failR :: (Monad m, Monoid dec) => String -> Rewrite m dec a

failing rewrite.

The Prelude combinators

tuple2R :: (Monoid dec, Monad m) => Rewrite m dec a -> Rewrite m dec b -> Rewrite m dec (a, b)

listR :: (Monoid dec, Monad m) => Rewrite m dec a -> Rewrite m dec [a]

maybeR :: (Monoid dec, Monad m) => Rewrite m dec a -> Rewrite m dec (Maybe a)

tuple2U :: (Monoid dec, Monad m, Monoid r) => Translate m dec a r -> Translate m dec b r -> Translate m dec (a, b) r

listU :: (Monoid dec, Monad m, Monoid r) => Translate m dec a r -> Translate m dec [a] r

maybeU :: (Monoid dec, Monad m, Monoid r) => Translate m dec a r -> Translate m dec (Maybe a) r

Generic failure, over both Monads and Translates.

(?) :: Failable f => Bool -> f a -> f a

Guarded translate or monadic action.

class Failable f where

Failable structure.

Methods

failure :: String -> f a

Instances

(Monad m, Monoid dec) => Failable (RewriteM m dec)

(Monad m, Monoid dec) => Failable (Translate m dec a)