-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Monadic extensions to the xml package.
--   
--   A monadic interface for xml based on transformers and
--   transformers-compose. It provides filter composition, similar to hxt,
--   and a succinct monadic interface.
@package xml-monad
@version 0.4

module Text.XML.Monad.Error

-- | XML error type.
data XmlError

-- | An (invalid) empty input document was observed.
EmptyDocument :: XmlError

-- | Invalid XML, general parse error.
InvalidXml :: XmlError

-- | An immediate child element in an XML tree was not found.
XmlChildNotFound :: XmlError

-- | An immediate child element in an XML tree was not found, with name.
XmlChildNotFoundQ :: QName -> XmlError

-- | An element in an XML tree was not found.
XmlElementNotFound :: XmlError

-- | An element in an XML tree was not found, with name.
XmlElementNotFoundQ :: QName -> XmlError

-- | An XML element attribute was not found.
XmlAttributeNotFound :: XmlError

-- | An XML element attribute was not found, with name.
XmlAttributeNotFoundQ :: QName -> XmlError

-- | An XML element name was different than expected, with actual and
--   expected names.
UnexpectedElementNameQ :: QName -> QName -> XmlError

-- | A general XML error occured.
XmlError :: String -> XmlError

-- | A general error occured.
OtherError :: String -> XmlError

-- | An unspecified general error occured.
UnspecifiedError :: XmlError

-- | An error type that can be constructed from <a>XmlError</a>.
class FromXmlError a
fromXmlError :: FromXmlError a => XmlError -> a

-- | Raise an exception.
raise :: MonadError i m => i -> m a

-- | Raise a defined exception for <a>Nothing</a>, return <a>Just</a>
--   values.
maybeRaise :: MonadError i m => i -> Maybe a -> m a

-- | Raise an exception for <a>Left</a>, return <a>Right</a> values.
raises :: MonadError i m => Either i a -> m a

-- | Like <a>asks</a> for a function that can return an error, as
--   <a>Left</a>.
asksEither :: (MonadReader s m, MonadError e m) => (s -> Either e a) -> m a

-- | Like <a>asks</a> for a function that can return an error, as
--   <a>Nothing</a>.
asksMaybe :: (MonadReader s m, MonadError e m) => e -> (s -> Maybe a) -> m a

-- | Catch errors, and return an <a>Left</a> for errors, <a>Right</a>
--   otherwise.
try :: MonadError e m => m a -> m (Either e a)

-- | Catch errors (like <a>try</a>), and return <a>Nothing</a> for errors.
tryMaybe :: MonadError e m => m a -> m (Maybe a)

-- | Catch errors (like <a>try</a>), and return <a>False</a> for errors and
--   <a>True</a> for success.
tryBool :: MonadError e m => m a -> m Bool
instance Typeable XmlError
instance Show XmlError
instance FromXmlError XmlError
instance Exception XmlError
instance Error XmlError

module Text.XML.Monad.Output
showTopElement :: MonadReader Element m => m String
showContent :: MonadReader Content m => m String
showElement :: MonadReader Element m => m String
showCData :: MonadReader CData m => m String
showAttr :: MonadReader Attr m => m String
ppTopElement :: MonadReader Element m => m String
ppContent :: MonadReader Content m => m String
ppElement :: MonadReader Element m => m String
ppcTopElement :: MonadReader Element m => ConfigPP -> m String
ppcContent :: MonadReader Content m => ConfigPP -> m String
ppcElement :: MonadReader Element m => ConfigPP -> m String

module Text.XML.Monad.Proc
strContent :: MonadReader Element m => m String
readContent :: (MonadReader Element m, Read a) => m a
onlyElems :: MonadReader [Content] m => m [Element]
elChildren :: MonadReader Element m => m [Element]
onlyText :: MonadReader [Content] m => m [CData]
findChildren :: MonadReader Element m => QName -> m [Element]
filterChildren :: MonadReader Element m => (Element -> Bool) -> m [Element]
filterChildrenName :: MonadReader Element m => (QName -> Bool) -> m [Element]
findChild :: (MonadReader Element m, MonadError e m, FromXmlError e) => QName -> m Element
filterChild :: (MonadReader Element m, MonadError e m, FromXmlError e) => (Element -> Bool) -> m Element
filterChildName :: (MonadReader Element m, MonadError e m, FromXmlError e) => (QName -> Bool) -> m Element
findElement :: (MonadReader Element m, MonadError e m, FromXmlError e) => QName -> m Element
filterElement :: (MonadReader Element m, MonadError e m, FromXmlError e) => (Element -> Bool) -> m Element
filterElementName :: (MonadReader Element m, MonadError e m, FromXmlError e) => (QName -> Bool) -> m Element
findElements :: MonadReader Element m => QName -> m [Element]
filterElements :: MonadReader Element m => (Element -> Bool) -> m [Element]
filterElementsName :: MonadReader Element m => (QName -> Bool) -> m [Element]
findAttr :: (MonadReader Element m, MonadError e m, FromXmlError e) => QName -> m String
lookupAttr :: (MonadReader [Attr] m, MonadError e m, FromXmlError e) => QName -> m String
findAttrBy :: (MonadReader Element m, MonadError e m, FromXmlError e) => (QName -> Bool) -> m String
lookupAttrBy :: (MonadReader [Attr] m, MonadError e m, FromXmlError e) => (QName -> Bool) -> m String

module Text.XML.Monad.Input
parseXML :: (MonadReader s m, XmlSource s) => m [Content]
parseXMLDoc :: (MonadReader s m, MonadError e m, FromXmlError e, XmlSource s) => m Element

module Text.XML.Monad.Core

-- | Standard Xml reader + exception transformer type.
newtype XmlT e s m a
XmlT :: ErrorT e (ReaderT s m) a -> XmlT e s m a
fromXmlT :: XmlT e s m a -> ErrorT e (ReaderT s m) a

-- | Standard Xml reader + exception monadic type.
type Xml e s a = XmlT e s Identity a

-- | Run an <a>XmlT</a>.
runXmlT :: XmlT e s m a -> s -> m (Either e a)

-- | Run an <a>Xml</a>.
runXml :: Xml e s a -> s -> Either e a

-- | Run a reader inside a list.
inList :: (MonadCompose m n s t, MonadReader [s] n) => m a -> n [a]
elName :: MonadReader Element m => m QName
elAttribs :: MonadReader Element m => m [Attr]
elContent :: MonadReader Element m => m [Content]
elLine :: MonadReader Element m => m (Maybe Line)
attrKey :: MonadReader Attr m => m QName
attrVal :: MonadReader Attr m => m String
cdVerbatim :: MonadReader CData m => m CDataKind
cdLine :: MonadReader CData m => m (Maybe Line)
cdData :: MonadReader CData m => m String
qName :: MonadReader QName m => m String
qURI :: MonadReader QName m => m (Maybe String)
qPrefix :: MonadReader QName m => m (Maybe String)
instance Functor m => Functor (XmlT e s m)
instance (Monad m, Error e) => Monad (XmlT e s m)
instance (Monad m, Functor m) => Applicative (XmlT e s m)
instance (Monad m, Error e) => MonadPlus (XmlT e s m)
instance (Monad m, Functor m, Error e) => Alternative (XmlT e s m)
instance (MonadIO m, Error e) => MonadIO (XmlT e s m)
instance (Monad m, Error e) => MonadCompose (XmlT e s m) (XmlT e t m) s t
instance (Monad m, Error e) => MonadError e (XmlT e s m)
instance (Monad m, Error e) => MonadReader s (XmlT e s m)
instance Error e => MonadTrans (XmlT e s)

module Text.XML.Monad.Name
findElementNameG :: (MonadReader Element m, MonadError e m, FromXmlError e) => (QName -> QName -> Bool) -> QName -> m Element
findElementName :: (MonadReader Element m, MonadError e m, FromXmlError e) => QName -> m Element
findElementNameU :: (MonadReader Element m, MonadError e m, FromXmlError e) => String -> m Element
findElementNameUI :: (MonadReader Element m, MonadError e m, FromXmlError e) => String -> m Element
findElementsNameG :: MonadReader Element m => (QName -> QName -> Bool) -> QName -> m [Element]
findElementsName :: MonadReader Element m => QName -> m [Element]
findElementsNameU :: MonadReader Element m => String -> m [Element]
findElementsNameUI :: MonadReader Element m => String -> m [Element]
testElementNameG :: (MonadReader Element m, MonadError e m, FromXmlError e) => (QName -> QName -> Bool) -> QName -> m ()
testElementName :: (MonadReader Element m, MonadError e m, FromXmlError e) => QName -> m ()
testElementNameU :: (MonadReader Element m, MonadError e m, FromXmlError e) => String -> m ()
testElementNameUI :: (MonadReader Element m, MonadError e m, FromXmlError e) => String -> m ()
unqualEq :: QName -> QName -> Bool
unqualEqI :: QName -> QName -> Bool

module Text.XML.Monad