diff --git a/Text/XML/Expat/Annotated.hs b/Text/XML/Expat/Annotated.hs --- a/Text/XML/Expat/Annotated.hs +++ b/Text/XML/Expat/Annotated.hs @@ -31,8 +31,8 @@ module Text.XML.Expat.Internal.Namespaced, -- * Parse to tree - ParserOptions(..), - defaultParserOptions, + ParseOptions(..), + defaultParseOptions, Encoding(..), parse, parse', @@ -59,15 +59,17 @@ parseTree, parseTree', parseTreeThrowing, - unannotate + unannotate, + ParserOptions, + defaultParserOptions ) where import Control.Arrow import qualified Text.XML.Expat.Tree as Tree import Text.XML.Expat.SAX ( Encoding(..) , GenericXMLString(..) - , ParserOptions(..) - , defaultParserOptions + , ParseOptions(..) + , defaultParseOptions , SAXEvent(..) , XMLParseError(..) , XMLParseException(..) @@ -75,7 +77,9 @@ , parseSAX , parseSAXThrowing , parseSAXLocations - , parseSAXLocationsThrowing ) + , parseSAXLocationsThrowing + , ParserOptions + , defaultParserOptions ) import qualified Text.XML.Expat.SAX as SAX import Text.XML.Expat.Internal.Namespaced import Text.XML.Expat.Internal.NodeClass @@ -188,13 +192,13 @@ mapAllTags _ (Text t) = Text t mapAllTags f (Element n a c ann) = Element (f n) (map (first f) a) (fmap (mapAllTags f) c) ann - mapElement _ (Text t) = Text t - mapElement f (Element n a c ann) = + modifyElement _ (Text t) = Text t + modifyElement f (Element n a c ann) = let (n', a', c') = f (n, a, c) in Element n' a' c' ann mapNodeContainer f (Element n a ch an) = do - ch' <- f ch + ch' <- mapNodeListContainer f ch return $ Element n a ch' an mapNodeContainer _ (Text t) = return $ Text t @@ -270,7 +274,7 @@ -- will force the entire parse. Therefore, to ensure lazy operation, don't -- check the error status until you have processed the tree. parse :: (GenericXMLString tag, GenericXMLString text) => - ParserOptions tag text -- ^ Optional encoding override + ParseOptions tag text -- ^ Optional encoding override -> L.ByteString -- ^ Input text (a lazy ByteString) -> (LNode tag text, Maybe XMLParseError) parse opts bs = saxToTree $ SAX.parseLocations opts bs @@ -285,7 +289,7 @@ -> L.ByteString -- ^ Input text (a lazy ByteString) -> (LNode tag text, Maybe XMLParseError) {-# DEPRECATED parseTree "use Text.XML.Annotated.parse instead" #-} -parseTree mEnc = parse (ParserOptions mEnc Nothing) +parseTree mEnc = parse (ParseOptions mEnc Nothing) -- | Lazily parse XML to tree. In the event of an error, throw 'XMLParseException'. -- @@ -295,7 +299,7 @@ -- situations where it's not expected during normal operation, depending on the -- design of your program. parseThrowing :: (GenericXMLString tag, GenericXMLString text) => - ParserOptions tag text -- ^ Optional encoding override + ParseOptions tag text -- ^ Optional encoding override -> L.ByteString -- ^ Input text (a lazy ByteString) -> LNode tag text parseThrowing opts bs = fst $ saxToTree $ SAX.parseLocationsThrowing opts bs @@ -308,11 +312,11 @@ -> L.ByteString -- ^ Input text (a lazy ByteString) -> LNode tag text {-# DEPRECATED parseTreeThrowing "use Text.XML.Annotated.parseThrowing instead" #-} -parseTreeThrowing mEnc = parseThrowing (ParserOptions mEnc Nothing) +parseTreeThrowing mEnc = parseThrowing (ParseOptions mEnc Nothing) -- | Strictly parse XML to tree. Returns error message or valid parsed tree. parse' :: (GenericXMLString tag, GenericXMLString text) => - ParserOptions tag text -- ^ Optional encoding override + ParseOptions tag text -- ^ Optional encoding override -> B.ByteString -- ^ Input text (a strict ByteString) -> Either XMLParseError (LNode tag text) parse' opts bs = case parse opts (L.fromChunks [bs]) of @@ -327,5 +331,5 @@ -> B.ByteString -- ^ Input text (a strict ByteString) -> Either XMLParseError (LNode tag text) {-# DEPRECATED parseTree' "use Text.XML.Expat.parse' instead" #-} -parseTree' mEnc = parse' (ParserOptions mEnc Nothing) +parseTree' mEnc = parse' (ParseOptions mEnc Nothing) diff --git a/Text/XML/Expat/Internal/Namespaced.hs b/Text/XML/Expat/Internal/Namespaced.hs --- a/Text/XML/Expat/Internal/Namespaced.hs +++ b/Text/XML/Expat/Internal/Namespaced.hs @@ -81,7 +81,7 @@ nodeWithNamespaces :: (NodeClass n c, GenericXMLString text, Ord text, Show text) => NsPrefixMap text -> n c (QName text) text -> n c (NName text) text -nodeWithNamespaces bindings = mapElement namespaceify +nodeWithNamespaces bindings = modifyElement namespaceify where namespaceify (qname, qattrs, qchildren) = (nname, nattrs, nchildren) where @@ -123,7 +123,7 @@ -> PrefixNsMap text -> n c (NName text) text -> n c (QName text) text -nodeWithQualifiers cntr bindings = mapElement namespaceify +nodeWithQualifiers cntr bindings = modifyElement namespaceify where namespaceify (nname, nattrs, nchildren) = (qname, qattrs, qchildren) where diff --git a/Text/XML/Expat/Internal/NodeClass.hs b/Text/XML/Expat/Internal/NodeClass.hs --- a/Text/XML/Expat/Internal/NodeClass.hs +++ b/Text/XML/Expat/Internal/NodeClass.hs @@ -1,10 +1,11 @@ -{-# LANGUAGE MultiParamTypeClasses, FlexibleContexts, TypeFamilies #-} +{-# LANGUAGE MultiParamTypeClasses, FlexibleContexts, TypeFamilies, + ScopedTypeVariables, Rank2Types #-} -- | Type classes to allow for XML handling functions to be generalized to -- work with different node types, including the ones defined in /Tree/ and -- /Annotated/. module Text.XML.Expat.Internal.NodeClass where -import Control.Monad (mzero) +import Control.Monad (mzero, liftM) import Data.Functor.Identity import Data.List.Class import Data.Monoid (Monoid) @@ -69,24 +70,61 @@ -> n c tag text -> n c tag text + -- | Map an element non-recursively, allowing the tag type to be changed. + modifyElement :: ((tag, [(tag, text)], c (n c tag text)) + -> (tag', [(tag', text)], c (n c tag' text))) + -> n c tag text + -> n c tag' text + -- | Map all tags (both tag names and attribute names) recursively. mapAllTags :: (tag -> tag') -> n c tag text -> n c tag' text - -- | Map an element non-recursively, allowing the tag type to be changed. - mapElement :: ((tag, [(tag, text)], c (n c tag text)) - -> (tag', [(tag', text)], c (n c tag' text))) - -> n c tag text - -> n c tag' text - - -- | Change a node from one container type to another. - mapNodeContainer :: (c (n c tag text) -> ItemM c (c' (n c' tag text))) + -- | Change a node recursively from one container type to another, with a + -- specified function to convert the container type. + mapNodeContainer :: List c' => + (forall a . c a -> ItemM c (c' a)) -> n c tag text -> ItemM c (n c' tag text) -- | Generic text node constructor. mkText :: text -> n c tag text + +-- | DEPRECATED. Map an element non-recursively, allowing the tag type to be changed. +mapElement :: NodeClass n c => + ((tag, [(tag, text)], c (n c tag text)) + -> (tag', [(tag', text)], c (n c tag' text))) + -> n c tag text + -> n c tag' text +{-# DEPRECATED mapElement "renamed to modifyElement" #-} +mapElement = modifyElement + +-- | Change a list of nodes recursively from one container type to another, with +-- a specified function to convert the container type. +mapNodeListContainer :: (NodeClass n c, List c') => + (forall a . c a -> ItemM c (c' a)) + -> c (n c tag text) + -> ItemM c (c' (n c' tag text)) +mapNodeListContainer f = f . mapL (mapNodeContainer f) + +-- | Change a node recursively from one container type to another. This +-- extracts the entire tree contents to standard lists and re-constructs them +-- with the new container type. For monadic list types used in +-- @hexpat-iteratee@ this operation forces evaluation. +fromNodeContainer :: (NodeClass n c, List c') => + n c tag text + -> ItemM c (n c' tag text) +fromNodeContainer = mapNodeContainer (\l -> fromList `liftM` toList l) + +-- | Change a list of nodes recursively from one container type to another. This +-- extracts the entire tree contents to standard lists and re-constructs them +-- with the new container type. For monadic list types used in +-- @hexpat-iteratee@ this operation forces evaluation. +fromNodeListContainer :: (NodeClass n c, List c') => + c (n c tag text) + -> ItemM c (c' (n c' tag text)) +fromNodeListContainer = mapNodeListContainer (\l -> fromList `liftM` toList l) -- | A class of node types where an Element can be constructed given a tag, -- attributes and children. diff --git a/Text/XML/Expat/SAX.hs b/Text/XML/Expat/SAX.hs --- a/Text/XML/Expat/SAX.hs +++ b/Text/XML/Expat/SAX.hs @@ -13,7 +13,7 @@ XMLParseLocation(..), -- * SAX-style parse - ParserOptions(..), + ParseOptions(..), SAXEvent(..), textFromCString, @@ -21,22 +21,24 @@ parseLocations, parseLocationsThrowing, parseThrowing, - defaultParserOptions, + defaultParseOptions, -- * Variants that throw exceptions XMLParseException(..), + -- * Helpers + setEntityDecoder, + + -- * Abstraction of string types + GenericXMLString(..), + -- * Deprecated parse functions parseSAX, parseSAXLocations, parseSAXLocationsThrowing, parseSAXThrowing, - - -- * Helpers - setEntityDecoder, - - -- * Abstraction of string types - GenericXMLString(..) + ParserOptions, + defaultParserOptions ) where import Text.XML.Expat.Internal.IO hiding (parse) @@ -59,8 +61,8 @@ import Foreign.Ptr -data ParserOptions tag text = ParserOptions - { parserEncoding :: Maybe Encoding +data ParseOptions tag text = ParseOptions + { defaultEncoding :: Maybe Encoding -- ^ The encoding parameter, if provided, overrides the document's -- encoding declaration. , entityDecoder :: Maybe (tag -> Maybe text) @@ -68,10 +70,18 @@ -- be decoded into text using the supplied lookup function } -defaultParserOptions :: ParserOptions tag text -defaultParserOptions = ParserOptions Nothing Nothing +{-# DEPRECATED ParserOptions "renamed to ParseOptions" #-} +type ParserOptions tag text = ParseOptions tag text +defaultParseOptions :: ParseOptions tag text +defaultParseOptions = ParseOptions Nothing Nothing +-- | DEPRECATED. Renamed to defaultParseOptions. +defaultParserOptions :: ParseOptions tag text +{-# DEPRECATED defaultParserOptions "renamed to defaultParseOptions" #-} +defaultParserOptions = defaultParseOptions + + -- | An abstraction for any string type you want to use as xml text (that is, -- attribute values or element text content). If you want to use a -- new string type with /hexpat/, you must make it an instance of @@ -181,11 +191,11 @@ -- | Lazily parse XML to SAX events. In the event of an error, FailDocument is -- the last element of the output list. parse :: (GenericXMLString tag, GenericXMLString text) => - ParserOptions tag text -- ^ Parser options + ParseOptions tag text -- ^ Parser options -> L.ByteString -- ^ Input text (a lazy ByteString) -> [SAXEvent tag text] parse opts input = unsafePerformIO $ do - let enc = parserEncoding opts + let enc = defaultEncoding opts let mEntityDecoder = entityDecoder opts parser <- newParser enc @@ -244,7 +254,7 @@ -> L.ByteString -- ^ Input text (a lazy ByteString) -> [SAXEvent tag text] {-# DEPRECATED parseSAX "use Text.XML.Expat.SAX.parse instead" #-} -parseSAX enc = parse (ParserOptions enc Nothing) +parseSAX enc = parse (ParseOptions enc Nothing) -- | An exception indicating an XML parse error, used by the /..Throwing/ variants. @@ -256,11 +266,11 @@ -- | A variant of parseSAX that gives a document location with each SAX event. parseLocations :: (GenericXMLString tag, GenericXMLString text) => - ParserOptions tag text -- ^ Parser options + ParseOptions tag text -- ^ Parser options -> L.ByteString -- ^ Input text (a lazy ByteString) -> [(SAXEvent tag text, XMLParseLocation)] parseLocations opts input = unsafePerformIO $ do - let enc = parserEncoding opts + let enc = defaultEncoding opts let mEntityDecoder = entityDecoder opts -- Done with cut & paste coding for maximum speed. @@ -326,7 +336,7 @@ -> L.ByteString -- ^ Input text (a lazy ByteString) -> [(SAXEvent tag text, XMLParseLocation)] {-# DEPRECATED parseSAXLocations "use Text.XML.Expat.SAX.parseLocations instead" #-} -parseSAXLocations enc = parseLocations (ParserOptions enc Nothing) +parseSAXLocations enc = parseLocations (ParseOptions enc Nothing) -- | Lazily parse XML to SAX events. In the event of an error, throw @@ -338,7 +348,7 @@ -- situations where it's not expected during normal operation, depending on the -- design of your program. parseThrowing :: (GenericXMLString tag, GenericXMLString text) => - ParserOptions tag text -- ^ Parser options + ParseOptions tag text -- ^ Parser options -> L.ByteString -- ^ input text (a lazy ByteString) -> [SAXEvent tag text] parseThrowing opts bs = map freakOut $ parse opts bs @@ -356,7 +366,7 @@ -> L.ByteString -- ^ Input text (a lazy ByteString) -> [SAXEvent tag text] {-# DEPRECATED parseSAXThrowing "use Text.XML.Expat.SAX.parseThrowing instead" #-} -parseSAXThrowing mEnc = parseThrowing (ParserOptions mEnc Nothing) +parseSAXThrowing mEnc = parseThrowing (ParseOptions mEnc Nothing) -- | A variant of parseSAX that gives a document location with each SAX event. @@ -368,7 +378,7 @@ -- situations where it's not expected during normal operation, depending on the -- design of your program. parseLocationsThrowing :: (GenericXMLString tag, GenericXMLString text) => - ParserOptions tag text -- ^ Optional encoding override + ParseOptions tag text -- ^ Optional encoding override -> L.ByteString -- ^ Input text (a lazy ByteString) -> [(SAXEvent tag text, XMLParseLocation)] parseLocationsThrowing opts bs = map freakOut $ parseLocations opts bs @@ -387,4 +397,4 @@ -> [(SAXEvent tag text, XMLParseLocation)] {-# DEPRECATED parseSAXLocationsThrowing "use Text.XML.Expat.SAX.parseLocationsThrowing instead" #-} parseSAXLocationsThrowing mEnc = - parseLocationsThrowing (ParserOptions mEnc Nothing) + parseLocationsThrowing (ParseOptions mEnc Nothing) diff --git a/Text/XML/Expat/Tree.hs b/Text/XML/Expat/Tree.hs --- a/Text/XML/Expat/Tree.hs +++ b/Text/XML/Expat/Tree.hs @@ -36,7 +36,7 @@ -- > inputText <- L.readFile filename -- > -- Note: Because we're not using the tree, Haskell can't infer the type of -- > -- strings we're using so we need to tell it explicitly with a type signature. --- > let (xml, mErr) = parse defaultParserOptions inputText :: (UNode String, Maybe XMLParseError) +-- > let (xml, mErr) = parse defaultParseOptions inputText :: (UNode String, Maybe XMLParseError) -- > -- Process document before handling error, so we get lazy processing. -- > L.hPutStr stdout $ format xml -- > putStrLn "" @@ -46,7 +46,7 @@ -- > hPutStrLn stderr $ "XML parse failed: "++show err -- > exitWith $ ExitFailure 2 -- --- Error handling in strict parses is very straight forward - just check the +-- Error handling in strict parses is very straightforward - just check the -- 'Either' return value. Lazy parses are not so simple. Here are two working -- examples that illustrate the ways to handle errors. Here they are: -- @@ -58,7 +58,7 @@ -- > -- > -- This is the recommended way to handle errors in lazy parses -- > main = do --- > let (tree, mError) = parse defaultParserOptions +-- > let (tree, mError) = parse defaultParseOptions -- > (L.pack $ map c2w $ "") -- > print (tree :: UNode String) -- > @@ -82,7 +82,7 @@ -- > -- This is not the recommended way to handle errors. -- > main = do -- > do --- > let tree = parseThrowing defaultParserOptions +-- > let tree = parseThrowing defaultParseOptions -- > (L.pack $ map c2w $ "") -- > print (tree :: UNode String) -- > -- Because of lazy evaluation, you should not process the tree outside @@ -110,8 +110,8 @@ module Text.XML.Expat.Internal.Namespaced, -- * Parse to tree - ParserOptions(..), - defaultParserOptions, + ParseOptions(..), + defaultParseOptions, Encoding(..), parse, parse', @@ -141,22 +141,26 @@ parseSAXLocations, parseTreeThrowing, parseSAXThrowing, - parseSAXLocationsThrowing + parseSAXLocationsThrowing, + ParserOptions, + defaultParserOptions ) where import Text.XML.Expat.Internal.IO hiding (parse,parse') import qualified Text.XML.Expat.Internal.IO as IO -import Text.XML.Expat.SAX ( ParserOptions(..) +import Text.XML.Expat.SAX ( ParseOptions(..) , XMLParseException(..) , SAXEvent(..) - , defaultParserOptions + , defaultParseOptions , textFromCString , parseSAX , parseSAXLocations , parseSAXLocationsThrowing , parseSAXThrowing , GenericXMLString(..) - , setEntityDecoder ) + , setEntityDecoder + , ParserOptions + , defaultParserOptions ) import qualified Text.XML.Expat.SAX as SAX import Text.XML.Expat.Internal.Namespaced import Text.XML.Expat.Internal.NodeClass @@ -293,13 +297,13 @@ mapAllTags _ (Text t) = Text t mapAllTags f (Element n a c) = Element (f n) (map (first f) a) (fmap (mapAllTags f) c) - mapElement _ (Text t) = Text t - mapElement f (Element n a c) = + modifyElement _ (Text t) = Text t + modifyElement f (Element n a c) = let (n', a', c') = f (n, a, c) in Element n' a' c' mapNodeContainer f (Element n a ch) = do - ch' <- f ch + ch' <- mapNodeListContainer f ch return $ Element n a ch' mapNodeContainer _ (Text t) = return $ Text t @@ -310,12 +314,12 @@ -- | Strictly parse XML to tree. Returns error message or valid parsed tree. parse' :: (GenericXMLString tag, GenericXMLString text) => - ParserOptions tag text -- ^ Parser options + ParseOptions tag text -- ^ Parser options -> ByteString -- ^ Input text (a strict ByteString) -> Either XMLParseError (Node tag text) parse' opts doc = unsafePerformIO $ runParse where runParse = do - let enc = parserEncoding opts + let enc = defaultEncoding opts let mEntityDecoder = entityDecoder opts parser <- newParser enc @@ -370,7 +374,7 @@ -> ByteString -- ^ Input text (a strict ByteString) -> Either XMLParseError (Node tag text) {-# DEPRECATED parseTree' "use Text.XML.Expat.parse' instead" #-} -parseTree' enc = parse' (ParserOptions enc Nothing) +parseTree' enc = parse' (ParseOptions enc Nothing) -- | A lower level function that lazily converts a SAX stream into a tree structure. @@ -400,7 +404,7 @@ -- will force the entire parse. Therefore, to ensure lazy operation, don't -- check the error status until you have processed the tree. parse :: (GenericXMLString tag, GenericXMLString text) => - ParserOptions tag text -- ^ Parser options + ParseOptions tag text -- ^ Parser options -> L.ByteString -- ^ Input text (a lazy ByteString) -> (Node tag text, Maybe XMLParseError) parse opts bs = saxToTree $ SAX.parse opts bs @@ -416,7 +420,7 @@ -> L.ByteString -- ^ Input text (a lazy ByteString) -> (Node tag text, Maybe XMLParseError) {-# DEPRECATED parseTree "use Text.XML.Expat.Tree.parse instead" #-} -parseTree mEnc = parse (ParserOptions mEnc Nothing) +parseTree mEnc = parse (ParseOptions mEnc Nothing) -- | Lazily parse XML to tree. In the event of an error, throw 'XMLParseException'. @@ -427,7 +431,7 @@ -- situations where it's not expected during normal operation, depending on the -- design of your program. parseThrowing :: (GenericXMLString tag, GenericXMLString text) => - ParserOptions tag text -- ^ Parser options + ParseOptions tag text -- ^ Parser options -> L.ByteString -- ^ Input text (a lazy ByteString) -> Node tag text parseThrowing opts bs = fst $ saxToTree $ SAX.parseThrowing opts bs @@ -441,4 +445,4 @@ -> L.ByteString -- ^ Input text (a lazy ByteString) -> Node tag text {-# DEPRECATED parseTreeThrowing "use Text.XML.Expat.Tree.parseThrowing instead" #-} -parseTreeThrowing mEnc = parseThrowing (ParserOptions mEnc Nothing) +parseTreeThrowing mEnc = parseThrowing (ParseOptions mEnc Nothing) diff --git a/hexpat.cabal b/hexpat.cabal --- a/hexpat.cabal +++ b/hexpat.cabal @@ -1,6 +1,6 @@ Cabal-Version: >= 1.6 Name: hexpat -Version: 0.16 +Version: 0.17 Synopsis: XML parser/formatter based on expat Description: This package provides a general purpose Haskell XML library using Expat to @@ -41,7 +41,7 @@ . ChangeLog: 0.15 changes intended to fix a (rare) \"error: a C finalizer called back into Haskell.\" that seemed only to happen only on ghc6.12.X; 0.15.1 Fix broken Annotated parse; - 0.16 switch from mtl to transformers + 0.16 switch from mtl to transformers; 0.17 fix mapNodeContainer & rename some things. Category: XML License: BSD3 License-File: LICENSE diff --git a/test/suite/Text/XML/Expat/UnitTests.hs b/test/suite/Text/XML/Expat/UnitTests.hs --- a/test/suite/Text/XML/Expat/UnitTests.hs +++ b/test/suite/Text/XML/Expat/UnitTests.hs @@ -38,7 +38,7 @@ fromByteString = map w2c . B.unpack testDoc :: (Show tag, Show text) => - (ParserOptions tag text + (ParseOptions tag text -> bs -> Either XMLParseError (Node tag text)) -> (Node tag text -> L.ByteString) @@ -58,7 +58,7 @@ hPutStrLn stderr $ "parse failed: "++show error assertFailure descr where - popts = defaultParserOptions { parserEncoding = Just UTF8 } + popts = defaultParseOptions { defaultEncoding = Just UTF8 } eitherify f mEnc bs = do @@ -68,7 +68,7 @@ test_error1 :: IO () test_error1 = do - let eDoc = Tree.parse' defaultParserOptions (toByteString "") :: Either XMLParseError (UNode String) + let eDoc = Tree.parse' defaultParseOptions (toByteString "") :: Either XMLParseError (UNode String) assertEqual "error1" (Left $ XMLParseError "mismatched tag" (XMLParseLocation 1 9 9 0)) eDoc test_error2 :: IO () @@ -76,7 +76,7 @@ assertEqual "error2" ( Element {eName = "hello", eAttributes = [], eChildren = []}, Just (XMLParseError "mismatched tag" (XMLParseLocation 1 9 9 0)) - ) (Tree.parse defaultParserOptions + ) (Tree.parse defaultParseOptions (toByteStringL "") :: (UNode String, Maybe XMLParseError)) test_error3 :: IO () @@ -87,12 +87,12 @@ Element {eName = "hello", eAttributes = [], eChildren = []} ]}, Just (XMLParseError "mismatched tag" (XMLParseLocation 1 35 35 0)) - ) $ Tree.parse defaultParserOptions + ) $ Tree.parse defaultParseOptions (toByteStringL "Hello") test_error4 :: IO () test_error4 = do - let eDoc = Tree.parse' defaultParserOptions (toByteString "!") :: Either XMLParseError (UNode String) + let eDoc = Tree.parse' defaultParseOptions (toByteString "!") :: Either XMLParseError (UNode String) assertEqual "error1" (Left $ XMLParseError "not well-formed (invalid token)" (XMLParseLocation 1 0 0 0)) eDoc @@ -126,7 +126,7 @@ where xml = "&entity;" - popts = defaultParserOptions { entityDecoder = Just entityLookup } + popts = defaultParseOptions { entityDecoder = Just entityLookup } (tree,merr) = Tree.parse popts $ toByteStringL xml @@ -184,7 +184,7 @@ "\n \n strength\n \n") ] forM_ tests $ \(name, inp, outSB) -> do - let eree = Tree.parse' defaultParserOptions inp :: Either XMLParseError (UNode String) + let eree = Tree.parse' defaultParseOptions inp :: Either XMLParseError (UNode String) case eree of Left err -> assertFailure $ show err Right tree -> do @@ -229,32 +229,32 @@ tests = hUnitTestToTests $ TestList [ t' ("String", - Tree.parse' :: ParserOptions String String + Tree.parse' :: ParseOptions String String -> B.ByteString -> Either XMLParseError (Node String String), formatTree), t' ("ByteString", - Tree.parse' :: ParserOptions B.ByteString B.ByteString + Tree.parse' :: ParseOptions B.ByteString B.ByteString -> B.ByteString -> Either XMLParseError (Node B.ByteString B.ByteString), formatTree), t' ("Text", - Tree.parse' :: ParserOptions T.Text T.Text + Tree.parse' :: ParseOptions T.Text T.Text -> B.ByteString -> Either XMLParseError (Node T.Text T.Text), formatTree), t ("String/Lazy", - eitherify $ Tree.parse :: ParserOptions String String + eitherify $ Tree.parse :: ParseOptions String String -> L.ByteString -> Either XMLParseError (Node String String), formatTree), t ("ByteString/Lazy", - eitherify $ Tree.parse :: ParserOptions B.ByteString B.ByteString + eitherify $ Tree.parse :: ParseOptions B.ByteString B.ByteString -> L.ByteString -> Either XMLParseError (Node B.ByteString B.ByteString), formatTree), t ("Text/Lazy", - eitherify $ Tree.parse :: ParserOptions T.Text T.Text + eitherify $ Tree.parse :: ParseOptions T.Text T.Text -> L.ByteString -> Either XMLParseError (Node T.Text T.Text), formatTree),