2.4. Filter combinators

Basic filter combinators

o :: (a -> [b]) -> (c -> [a]) -> c -> [b]

Irish composition. Sequential composition of two filters. The left filter is applied to the result of the right filter. (conjunction)

(+++) :: (a -> [b]) -> (a -> [b]) -> (a -> [b])

Binary parallel composition, the function unifies the results of two filters sequential. Each filter uses a copy of state. (union)

cat :: [a -> [b]] -> (a -> [b])

Concatenates the results of all filters in a list, a list version of union +++. The combinator sticks lots of filters together.

($$) :: (a -> [b]) -> [a] -> [b]

Applies a filter to a list.

processChildren :: TFilter node -> TFilter node

Applies a filter to the child list of a node.

Choice combinators

orElse :: (a -> [b]) -> (a -> [b]) -> (a -> [b])

Directional choice. Second filter is only applied if the first one produces an empty list.

(?>) :: (a -> [b]) -> ThenElse (a -> [b]) -> (a -> [b])

In combination with the type ThenElse a = a :> a this combinator models an expression that resembles the conditional expression "p ? f : g" of C: "p ?> f :> g". If the predicate filter p is true, the filter f is applied otherwise g is applied.

when :: TFilter node -> TFilter node -> TFilter nod

First filter is only applied to the passed node, if the second filter produces a list with contents, otherwise a list with the passed node is returned. The second filter is typically a predicate filter.

Definition: f `when` g = g ?> f :> this

whenNot :: TFilter node -> TFilter node -> TFilter node

First filter is only applied to the passed node, if the second filter produces an empty list, otherwise a list of the passed node is returned. The second filter is typically a predicate filter.

Definition: f `whenNot` g = g ?> this :> f

guards :: TFilter node -> TFilter node -> TFilter node

First filter is only applied to the passed node, if the second filter produces a list with contents, otherwise an empty list is returned. The second filter is typically a predicate filter.

Definition: g `guards` f = g ?> f :> none

containing :: (a -> [b]) -> (b -> [c]) -> a -> [b]

Pruning: Keep only those nodes for which the second filter produces a list with contents and apply the first filter to these nodes.

Definition: f `containing` g = filter (not . null . g) . f

notContaining :: (a -> [b]) -> (b -> [c]) -> a -> [b]

Pruning: Keep only those nodes for which the second filter produces an empty list and apply the first filter to these nodes.

Definition: f `notContaining` g = filter (null . g) . f

(/>) :: TFilter node -> TFilter node -> TFilter node

Interior search, pronounced "slash". First filter is applied to a node, the children of the result are taken and the second filter is applied to them, these children are returned. (meaning g inside f)

Definition: f /> g = g `o` getChildren `o` f

(</) :: TFilter node -> TFilter node -> TFilter node

Exterior search, pronounced "outside". First filter is applied to a node, the second to its children. If both filters return a result, the node is returned. (meaning f containing g)

Definition: f </ g = f `containing` (g `o` getChildren)

Recursive search combinators

deep :: TFilter node -> TFilter node

Filter is applied to each node of the tree. If the filter returns a result, processing is stopped. If not, the filter is applied to the next node of the tree. (top down traversal)

deepest :: TFilter node -> TFilter node

See deep, but bottom up traversal.

multi :: TFilter node -> TFilter node

Returns all successful applications of the filter to the whole tree.

Recursive transformation combinators

applyBottomUp :: TFilter node -> TFilter node

Constructs a new tree by applying the passed filter to each node of the tree. The tree is traversed bottom-up.

applyTopDown :: TFilter node -> TFilter node

Constructs a new tree by applying the passed filter to each node of the tree. The tree is traversed top-down.

applyBottomUpIfNot :: TFilter node -> TFilter node -> TFilter node

Constructs a new tree with a guarded top down transformation. The first filter is only applied to those nodes for which the second filter produces a result.

Monadic composition

liftM :: Monad m => (a -> [b]) -> a -> m [b]

Lift a normal filter to a monadic filter so that it can be used in monads.

(.<) :: Monad m => (b -> m [c]) -> (a -> m[b]) -> (a -> m[c])

Monadic Irish composition. Sequential composition of two filters. The first filter is applied to the result of the second filter (conjunction). Monadic version of the basic filter o.

($$<) :: Monad m => (a -> m [b]) -> [a] -> m [b]

Apply a monadic filter to a list. Monadic version of the basic filter combinator cat.

Special Filter combinators for XmlTree

whenOk :: XmlFilter -> XmlFilter ->XmlFilter

Applies the first filter to a node and checks the result for errors. In case of an error it stops processing and returns the list with the XError node. Otherwise processing is continued and the second filter is applied to the result.

whenOkM :: Monad m => (a -> XmlTrees) -> (XmlTrees -> m XmlTrees) -> a -> m XmlTrees

Monadic version of whenOk.