Safe Haskell | None |
---|---|
Language | Haskell2010 |
- traverseElems :: (Monad m, Foldable g, Traversable f) => ([Element] -> DomParserT g m (f (DomPath, Element))) -> DomParserT Identity m a -> DomParserT g m (f a)
- inFilteredTrav :: (Monad m, Foldable g, Buildable f) => ([Element] -> (DomPath, [Element])) -> DomParserT Identity m a -> DomParserT g m (f a)
- inElemTrav :: (Monad m, Foldable g, Buildable f) => ElemMatcher -> DomParserT Identity m a -> DomParserT g m (f a)
- inElem :: (Monad m, Foldable g) => ElemMatcher -> DomParserT Identity m a -> DomParserT g m a
- inElemAll :: (Monad m, Foldable g) => ElemMatcher -> DomParserT Identity m a -> DomParserT g m [a]
- inElemMay :: (Monad m, Foldable g) => ElemMatcher -> DomParserT Identity m a -> DomParserT g m (Maybe a)
- inElemNe :: (Monad m, Foldable g) => ElemMatcher -> DomParserT Identity m a -> DomParserT g m (NonEmpty a)
- divePath :: forall m g a. (Monad m, Foldable g) => [ElemMatcher] -> DomParserT [] m a -> DomParserT g m a
- diveElem :: (Monad m, Foldable g) => ElemMatcher -> DomParserT [] m a -> DomParserT g m a
- ignoreElem :: Monad m => (Element -> Bool) -> DomParserT Identity m a -> DomParserT Identity m (Maybe a)
- ignoreEmpty :: Monad m => DomParserT Identity m a -> DomParserT Identity m (Maybe a)
- ignoreBlank :: Monad m => DomParserT Identity m a -> DomParserT Identity m (Maybe a)
Generic combinators to traverse descendants
:: (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 |
-> DomParserT g m (f a) |
Generic function to traverse arbitrary inner elements.
:: (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
:: (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
inElemAll :: (Monad m, Foldable g) => ElemMatcher -> DomParserT Identity m a -> DomParserT g m [a] Source #
inElemMay :: (Monad m, Foldable g) => ElemMatcher -> DomParserT Identity m a -> DomParserT g m (Maybe a) Source #
inElemNe :: (Monad m, Foldable g) => ElemMatcher -> DomParserT Identity m a -> DomParserT g m (NonEmpty a) Source #
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.
diveElem :: (Monad m, Foldable g) => ElemMatcher -> DomParserT [] m a -> DomParserT g m a Source #
Explicit ignoring elements
:: Monad m | |
=> (Element -> Bool) | Predicate checking that we must ignore some current tag. If returns
|
-> 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.