Strafunski-StrategyLib-5.0.0.10: Library for strategic programming

MaintainerRalf Laemmel, Joost Visser
Stabilityexperimental
Portabilityportable
Safe HaskellNone
LanguageHaskell98

Data.Generics.Strafunski.StrategyLib.ContainerTheme

Contents

Description

This module is part of StrategyLib, a library of functional strategy combinators, including combinators for generic traversal. This module provides combinators which allow one to use strategies to construct generic containers.

Synopsis

Pointwise function update

modify :: Eq x => (x -> y) -> x -> y -> x -> y #

Pointwise modification of monomorphic functions

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

Generic Set (not observable)

type GSet = TU () Maybe #

Type of generic sets

emptyGSet :: GSet #

Empty generic set.

fullGSet :: GSet #

Completely filled generic set

addGSet :: (Eq t, Term t) => t -> GSet -> GSet #

Add an element to a generic set

removeGSet :: (Eq t, Term t) => t -> GSet -> GSet #

Remove an element from a generic set

containsGSet :: (Eq t, Term t) => t -> GSet -> Bool #

Test whether a given element is contained in a generic set

Generic Map (not observable)

type GMap value = TU value Maybe #

Type of generic maps

emptyGMap :: GMap v #

Empty generic map

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

type GList = (Integer -> TP Maybe, Integer) #

sizeGList :: (t, t1) -> t1 #

indxGList :: (t1, t) -> t1 #

addGList :: Term t => t -> GList -> GList #

putGList :: Term t => Integer -> t -> GList -> GList #

getGList :: Term t => Integer -> GList -> Maybe t #

mapGListTU :: Term t => (t -> ()) -> TU a Maybe -> GList -> [Maybe a] #

elemsGList :: Term t => (t -> ()) -> GList -> [t] #

nth :: [a] -> Integer -> a #

type Coder = (Int, TU Int Maybe) #

getCode :: Term x => Coder -> x -> Maybe Int #

setCode :: (Term x, Eq x) => Coder -> x -> Int -> Coder #

enCode :: (Term x, Eq x) => Coder -> x -> Coder #