Text.XML.DOM.Parser.Combinators

Synopsis

# Generic combinators to traverse descendants

Arguments

 :: (Monad m, Foldable g, Traversable f) => ([Element] -> DomParserT g m (f (DomPath, Element))) Takes list of current elements and returns container with pairs of subpath (relatively to current elements) and element to run parser in -> DomParserT Identity m a Parser to run for each element found in traversable f -> DomParserT g m (f a)

Generic function to traverse arbitrary inner elements.

Arguments

 :: (Monad m, Foldable g, Buildable f) => ([Element] -> (DomPath, [Element])) Takes list of current elements and returns some descendants subset and path this descendants located at. Path is should be same for all descendants and required for error message -> DomParserT Identity m a -> DomParserT g m (f a)

Traverses elements located in same path using filtering function

# Using Buildable

Arguments

 :: (Monad m, Foldable g, Buildable f) => ElemMatcher Tag(s) matcher to traverse in -> DomParserT Identity m a -> DomParserT g m (f a)

Runs parser arbitrary times, depending on Buildable instance of f. For example if f becomes NonEmpty then inElemTrav finds one or more elements matched by given ElemMatcher and run parser in each found element, then returns NonEmpty a of results.

inElem :: (Monad m, Foldable g) => ElemMatcher -> DomParserT Identity m a -> DomParserT g m a Source #

Runs parser inside first children element matched by macher

# Dive combinators

divePath :: forall m g a. (Monad m, Foldable g) => [ElemMatcher] -> DomParserT [] m a -> DomParserT g m a Source #

Dive given parser's current tags set into the given path. The divePath ["a", "b"] differs from inElem "a" $inElem "b". Namely the first variant will not fail if occured tag "a" which does not contains tag "b". This behaviour is desireable when you dont want to parse whole XML and just want to pull tags located in some path. The other difference is in traversing inner elements. Consider this code inElem "a"$ inElem "b" $inElemAll "c" fromDom  which translates to pseudo-CSS query like: a:nth(1) > b:nth(1) > c > fromDom divePath ["a", "b"]$ inElemAll "c" fromDom


which translates like: a > b > c > fromDom

As you can see, inElem always takes first element and runs inner parser in this single element, unlike divePath which runs inner parser in all descendants in given path.

Note also that divePath takes parser parameterized by [] not by Identity. This because when you dive using some path you will get a list of found elements and all these elements will be current for parser.

# Explicit ignoring elements

Arguments

 :: Monad m => (Element -> Bool) Predicate checking that we must ignore some current tag. If returns True then parser will not be runned and combinator just returns Nothing. -> DomParserT Identity m a -> DomParserT Identity m (Maybe a)

Ignore arbitrary current element if it conforms to predicate.

ignoreEmpty :: Monad m => DomParserT Identity m a -> DomParserT Identity m (Maybe a) Source #

If current element has no children nodes does not run parser and returns Nothing. Otherwise runs parser inside current element. Useful when you got XML with strange empty elements which must be just ignored, but inElem runs parser inside of this elements which causes to parser error.

ignoreBlank :: Monad m => DomParserT Identity m a -> DomParserT Identity m (Maybe a) Source #

If all current elements contains blank content, or contains nothing at all , then returns Nothing, else runs parser.