dom-parser-2.0.0: Simple monadic DOM parser

Safe HaskellNone
LanguageHaskell2010

Text.XML.DOM.Parser.Combinators

Contents

Synopsis

Generic combinators to traverse descendants

traverseElems Source #

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.

inFilteredTrav Source #

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

inElemTrav Source #

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

ignoreElem Source #

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.