Safe Haskell | None |
---|---|
Language | Haskell2010 |
- traverseElems :: (Monad m, Foldable g, Traversable f) => ([Element] -> DomParserT g m (f ([Text], Element))) -> DomParserT Identity m a -> DomParserT g m (f a)
- inFilteredTrav :: (Monad m, Foldable g, DomTraversable f) => ([Element] -> ([Text], [Element])) -> DomParserT Identity m a -> DomParserT g m (f a)
- 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
- 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)
- divePath :: forall m g a. (Monad m, Foldable g) => [Text] -> DomParserT [] m a -> DomParserT g m a
- diveElem :: (Monad m, Foldable g) => Text -> 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)
- checkCurrentName :: Monad m => Text -> DomParserT Identity m ()
- parseContent :: Monad m => (Text -> DomParserT Identity m a) -> DomParserT Identity m a
- readContent :: forall m g a. (Read a, Typeable a, Monad m) => Text -> DomParserT g m a
Generic combinators to traverse descendants
:: (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.
:: (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) Source #
inElem :: (Monad m, Foldable g) => Text -> DomParserT Identity m a -> DomParserT g m a Source #
Runs parser inside first children element with given name
inElemAll :: (Monad m, Foldable g) => Text -> DomParserT Identity m a -> DomParserT g m [a] Source #
inElemMay :: (Monad m, Foldable g) => Text -> DomParserT Identity m a -> DomParserT g m (Maybe a) Source #
inElemNe :: (Monad m, Foldable g) => Text -> DomParserT Identity m a -> DomParserT g m (NonEmpty a) Source #
Dive combinators
divePath :: forall m g a. (Monad m, Foldable g) => [Text] -> 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 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 Source #
Explicit ignoring elements
:: 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. 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) Source #
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 () Source #
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 Source #
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 Source #