Data.Generics.Strafunski.StrategyLib.ContainerTheme

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.

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 :: (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

type Coder = (Int, TU Int Maybe)

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