Text.XML.DOM.Parser.Combinators

Generic combinators to traverse descendants

traverseElems

Arguments

:: (Monad m, Foldable g, Traversable f)

=> ([Element] -> DomParserT g m (f ([Text], Element)))

Takes set of current elements and

-> DomParserT Identity m a

Parser will be runned for each element found in traversable

-> DomParserT g m (f a)

Generic function to traverse arbitrary inner cursors.

inFilteredTrav

Arguments

:: (Monad m, Foldable g, DomTraversable f)

=> ([Element] -> ([Text], [Element]))

Function returning some filtered elements with path suffixes which will be appended to parser's state

-> DomParserT Identity m a

-> DomParserT g m (f a)

Takes function filtering

Using DomTraversable

inElemTrav :: (Monad m, Foldable g, DomTraversable f) => Text -> DomParserT Identity m a -> DomParserT g m (f a)

inElem :: (Monad m, Foldable g) => Text -> DomParserT Identity m a -> DomParserT g m a

Runs parser inside first children element with given name

inElemAll :: (Monad m, Foldable g) => Text -> DomParserT Identity m a -> DomParserT g m [a]

inElemMay :: (Monad m, Foldable g) => Text -> DomParserT Identity m a -> DomParserT g m (Maybe a)

inElemNe :: (Monad m, Foldable g) => Text -> DomParserT Identity m a -> DomParserT g m (NonEmpty a)

Dive combinators

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

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 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.

diveElem :: (Monad m, Foldable g) => Text -> DomParserT [] m a -> DomParserT g m a

Explicit ignoring elements

ignoreElem

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)

If current element has no children nodes does not run parser and returns Nothing. Otherwise runs parser inside current element. Usefull 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)

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

Checking current element properties

checkCurrentName :: Monad m => Text -> DomParserT Identity m ()

If name of current tag differs from first argument throws PENotFound with tag name replaced in last path's segment. Usefull for checking root document's element name.

Parsing arbitrary content

parseContent :: Monad m => (Text -> DomParserT Identity m a) -> DomParserT Identity m a

Parses content inside current tag. It expects current element set consists of exactly ONE element. Throws error if current elements set contains multiple of them.

readContent :: forall m g a. (Read a, Typeable a, Monad m) => Text -> DomParserT g m a