| Maintainer | Ralf Laemmel, Joost Visser |
|---|---|
| Stability | experimental |
| Portability | portable |
| Safe Haskell | None |
| Language | Haskell98 |
Data.Generics.Strafunski.StrategyLib.StrategyLib
Description
This module is part of StrategyLib, a library of functional strategy
combinators, including combinators for generic traversal. This is the
top-level module of the library. One only needs to import this module to
use the entire library. Some base modules are exported as well because
they are commonly used.
Synopsis
- module Control.Monad
- module Control.Monad.Fix
- module Control.Monad.Trans
- newtype Identity a = Identity {
- runIdentity :: a
- type State s = StateT s Identity
- newtype StateT s (m :: * -> *) a = StateT {
- runStateT :: s -> m (a, s)
- module Data.Monoid
- module Data.Generics.Strafunski.StrategyLib.MoreMonoids
- module Data.Generics.Strafunski.StrategyLib.StrategyPrelude
- module Data.Generics.Strafunski.StrategyLib.StrategyInfix
- module Data.Generics.Strafunski.StrategyLib.OverloadingTheme
- module Data.Generics.Strafunski.StrategyLib.TraversalTheme
- module Data.Generics.Strafunski.StrategyLib.FlowTheme
- module Data.Generics.Strafunski.StrategyLib.FixpointTheme
- module Data.Generics.Strafunski.StrategyLib.KeyholeTheme
- module Data.Generics.Strafunski.StrategyLib.NameTheme
- module Data.Generics.Strafunski.StrategyLib.PathTheme
- module Data.Generics.Strafunski.StrategyLib.EffectTheme
- type Coder = (Int, TU Int Maybe)
- type GList = (Integer -> TP Maybe, Integer)
- type GMap value = TU value Maybe
- type GSet = TU () Maybe
- modifyTP :: (MonadPlus m, Eq t, Term t) => TP m -> t -> m t -> TP m
- modifyTU :: (MonadPlus m, Eq t, Term t) => TU a m -> t -> m a -> TU a m
- emptyGSet :: GSet
- fullGSet :: GSet
- addGSet :: (Eq t, Term t) => t -> GSet -> GSet
- removeGSet :: (Eq t, Term t) => t -> GSet -> GSet
- containsGSet :: (Eq t, Term t) => t -> GSet -> Bool
- emptyGMap :: GMap v
- removeGMap :: (Eq t, Term t) => t -> GMap v -> GMap v
- containsGMap :: (Eq t, Term t) => t -> GMap v -> Bool
- putGMap :: (Eq t, Term t) => t -> v -> GMap v -> GMap v
- getGMap :: (Eq t, Term t) => t -> GMap v -> Maybe v
- sizeGList :: (a, b) -> b
- indxGList :: (a, b) -> a
- emptyGList :: GList
- addGList :: Term t => t -> GList -> GList
- putGList :: Term t => Integer -> t -> GList -> GList
- getGList :: Term t => Integer -> GList -> Maybe t
- mapGListTP :: TP Maybe -> GList -> GList
- mapGListTU :: Term t => (t -> ()) -> TU a Maybe -> GList -> [Maybe a]
- elemsGList :: Term t => (t -> ()) -> GList -> [t]
- nth :: [a] -> Integer -> a
- noCode :: Coder
- getCode :: Term x => Coder -> x -> Maybe Int
- setCode :: (Term x, Eq x) => Coder -> x -> Int -> Coder
- nextCode :: Coder -> (Int, Coder)
- enCode :: (Term x, Eq x) => Coder -> x -> Coder
- module Data.Generics.Strafunski.StrategyLib.RefactoringTheme
- module Data.Generics.Strafunski.StrategyLib.MetricsTheme
- module Data.Generics.Strafunski.StrategyLib.ChaseImports
Documentation
module Control.Monad
module Control.Monad.Fix
module Control.Monad.Trans
Identity functor and monad. (a non-strict monad)
Since: base-4.8.0.0
Constructors
| Identity | |
Fields
| |
Instances
type State s = StateT s Identity #
A state monad parameterized by the type s of the state to carry.
The return function leaves the state unchanged, while >>= uses
the final state of the first computation as the initial state of
the second.
newtype StateT s (m :: * -> *) a #
A state transformer monad parameterized by:
s- The state.m- The inner monad.
The return function leaves the state unchanged, while >>= uses
the final state of the first computation as the initial state of
the second.
Instances
| Monad m => MonadState s (StateT s m) | |
| MonadError e m => MonadError e (StateT s m) | |
Defined in Control.Monad.Error.Class Methods throwError :: e -> StateT s m a # catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a # | |
| MonadTrans (StateT s) | |
Defined in Control.Monad.Trans.State.Lazy | |
| MonadUnTrans (StateAlg s) (StateT s) # | Unlifting the state monad transformer |
| MonadRun (StateAlg s) (State s) # | Running the |
Defined in Control.Monad.Run | |
| Monad m => Monad (StateT s m) | |
| Functor m => Functor (StateT s m) | |
| MonadFix m => MonadFix (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
| MonadFail m => MonadFail (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
| (Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
| MonadIO m => MonadIO (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
| (Functor m, MonadPlus m) => Alternative (StateT s m) | |
| MonadPlus m => MonadPlus (StateT s m) | |
module Data.Monoid
modifyTP :: (MonadPlus m, Eq t, Term t) => TP m -> t -> m t -> TP m #
Pointwise modification of type-preserving strategies
modifyTU :: (MonadPlus m, Eq t, Term t) => TU a m -> t -> m a -> TU a m #
Pointwise modification of type-unifying strategies
containsGSet :: (Eq t, Term t) => t -> GSet -> Bool #
Test whether a given element is contained in a generic set
removeGMap :: (Eq t, Term t) => t -> GMap v -> GMap v #
Remove an element from a generic map (my key)
containsGMap :: (Eq t, Term t) => t -> GMap v -> Bool #
Test whether an element with given key is contained in a generic map
putGMap :: (Eq t, Term t) => t -> v -> GMap v -> GMap v #
Add an entry with given key and value to a generic map
getGMap :: (Eq t, Term t) => t -> GMap v -> Maybe v #
Obtain the value for a given key from a generic map
emptyGList :: GList #
elemsGList :: Term t => (t -> ()) -> GList -> [t] #