Portability | ghc |
---|---|

Stability | beta |

Maintainer | Neil Sculthorpe <neil@ittc.ku.edu> |

Safe Haskell | Safe-Inferred |

- idR :: Monad m => Rewrite c m a
- successT :: Monad m => Translate c m a ()
- contextT :: Monad m => Translate c m a c
- exposeT :: Monad m => Translate c m a (c, a)
- liftContext :: (c -> c') -> Translate c' m a b -> Translate c m a b
- readerT :: (a -> Translate c m a b) -> Translate c m a b
- resultT :: (m b -> n d) -> Translate c m a b -> Translate c n a d
- catchesT :: MonadCatch m => [Translate c m a b] -> Translate c m a b
- mapT :: (Traversable t, Monad m) => Translate c m a b -> Translate c m (t a) (t b)
- joinT :: Translate c m (m a) a
- guardT :: Monad m => Translate c m Bool ()
- tryR :: MonadCatch m => Rewrite c m a -> Rewrite c m a
- andR :: (Foldable f, Monad m) => f (Rewrite c m a) -> Rewrite c m a
- orR :: (Functor f, Foldable f, MonadCatch m) => f (Rewrite c m a) -> Rewrite c m a
- (>+>) :: MonadCatch m => Rewrite c m a -> Rewrite c m a -> Rewrite c m a
- repeatR :: MonadCatch m => Rewrite c m a -> Rewrite c m a
- acceptR :: Monad m => (a -> Bool) -> Rewrite c m a
- acceptWithFailMsgR :: Monad m => (a -> Bool) -> String -> Rewrite c m a
- accepterR :: Monad m => Translate c m a Bool -> Rewrite c m a
- changedR :: (MonadCatch m, Eq a) => Rewrite c m a -> Rewrite c m a
- changedByR :: MonadCatch m => (a -> a -> Bool) -> Rewrite c m a -> Rewrite c m a
- sideEffectR :: Monad m => (c -> a -> m ()) -> Rewrite c m a
- data AnyR m a
- wrapAnyR :: MonadCatch m => Rewrite c m a -> Rewrite c (AnyR m) a
- unwrapAnyR :: Monad m => Rewrite c (AnyR m) a -> Rewrite c m a
- data OneR m a
- wrapOneR :: MonadCatch m => Rewrite c m g -> Rewrite c (OneR m) g
- unwrapOneR :: Monad m => Rewrite c (OneR m) a -> Rewrite c m a

# Translate Combinators

liftContext :: (c -> c') -> Translate c' m a b -> Translate c m a bSource

Lift a `Translate`

to operate on a derived context.

resultT :: (m b -> n d) -> Translate c m a b -> Translate c n a dSource

Convert the monadic result of a `Translate`

into a result in another monad.

catchesT :: MonadCatch m => [Translate c m a b] -> Translate c m a bSource

mapT :: (Traversable t, Monad m) => Translate c m a b -> Translate c m (t a) (t b)Source

Map a `Translate`

over a list.

guardT :: Monad m => Translate c m Bool ()Source

Fail if the Boolean is False, succeed if the Boolean is True.

# Rewrite Combinators

tryR :: MonadCatch m => Rewrite c m a -> Rewrite c m aSource

Catch a failing `Rewrite`

, making it into an identity.

andR :: (Foldable f, Monad m) => f (Rewrite c m a) -> Rewrite c m aSource

Perform a collection of rewrites in sequence, requiring all to succeed.

orR :: (Functor f, Foldable f, MonadCatch m) => f (Rewrite c m a) -> Rewrite c m aSource

Perform a collection of rewrites in sequence, succeeding if any succeed.

(>+>) :: MonadCatch m => Rewrite c m a -> Rewrite c m a -> Rewrite c m aSource

Perform two rewrites in sequence, succeeding if one or both succeed.

repeatR :: MonadCatch m => Rewrite c m a -> Rewrite c m aSource

Repeat a `Rewrite`

until it fails, then return the result before the failure.
Requires at least the first attempt to succeed.

acceptWithFailMsgR :: Monad m => (a -> Bool) -> String -> Rewrite c m aSource

As `acceptR`

, but takes a custom failure message.

changedR :: (MonadCatch m, Eq a) => Rewrite c m a -> Rewrite c m aSource

Makes an `Rewrite`

fail if the result value equals the argument value.

changedByR :: MonadCatch m => (a -> a -> Bool) -> Rewrite c m a -> Rewrite c m aSource

sideEffectR :: Monad m => (c -> a -> m ()) -> Rewrite c m aSource

An identity `Rewrite`

with side-effects.

# Monad Transformers

## anyR Support

These are useful when defining congruence combinators that succeed if *any* child rewrite succeeds.
See the "Expr" example, or the HERMIT package.

The `AnyR`

transformer, in combination with `wrapAnyR`

and `unwrapAnyR`

,
causes a sequence of rewrites to succeed if at least one succeeds, converting failures to
identity rewrites.

Monad m => Monad (AnyR m) | |

Monad m => Functor (AnyR m) | |

Monad m => Applicative (AnyR m) | |

MonadCatch m => MonadCatch (AnyR m) |

## oneR Support

These are useful when defining congruence combinators that succeed if one child rewrite succeeds (and the remainder are then discarded). See the "Expr" example, or the HERMIT package.

The `OneR`

transformer, in combination with `wrapOneR`

and `unwrapOneR`

,
causes a sequence of rewrites to only apply the first success, converting the remainder (and failures) to identity rewrites.

Monad m => Monad (OneR m) | |

Monad m => Functor (OneR m) | |

Monad m => Applicative (OneR m) | |

MonadCatch m => MonadCatch (OneR m) |