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


-- | A collection of tools for processing XML with Haskell.
--   
--   The Haskell XML Toolbox bases on the ideas of HaXml and HXML, but
--   introduces a more general approach for processing XML with Haskell.
--   The Haskell XML Toolbox uses a generic data model for representing XML
--   documents, including the DTD subset and the document subset, in
--   Haskell. It contains a validating XML parser, a HTML parser, namespace
--   support, an XPath expression evaluator, an XSLT library, a RelaxNG
--   schema validator and funtions for serialization and deserialization of
--   user defined data. The library makes extensive use of the arrow
--   approach for processing XML. Since version 9 the toolbox is
--   partitioned into various (sub-)packages. This package contains the
--   core functionality, hxt-curl, hxt-tagsoup, hxt-relaxng, hxt-xpath,
--   hxt-xslt, hxt-regex-xmlschema contain the extensions. hxt-unicode
--   contains encoding and decoding functions, hxt-charproperties char
--   properties for unicode and XML.
@package hxt
@version 9.2.0


-- | UTF-8 character parser and simple XML token parsers
module Text.XML.HXT.Parser.XmlCharParser
type XParser s a = GenParser Char (XPState s) a
type SimpleXParser a = XParser () a
data XPState s
XPState :: !Bool -> s -> XPState s
xps_normalizeNewline :: XPState s -> !Bool
xps_userState :: XPState s -> s
withNormNewline :: a -> XPState a
withoutNormNewline :: a -> XPState a

-- | parse a single Unicode character
xmlChar :: XParser s Unicode

-- | parse a XML name character
xmlNameChar :: XParser s Unicode

-- | parse a XML name start character
xmlNameStartChar :: XParser s Unicode

-- | parse a XML NCName character
xmlNCNameChar :: XParser s Unicode

-- | parse a XML NCName start character
xmlNCNameStartChar :: XParser s Unicode

-- | parse a XML letter character
xmlLetter :: XParser s Unicode

-- | White Space (2.3)
--   
--   end of line handling (2.11) will be done before or with
--   <a>xmlCRLFChar</a> parser
xmlSpaceChar :: XParser s Char

-- | White Space Normalization
--   
--   end of line handling (2.11) #x0D and #x0D#x0A are mapped to #x0A
xmlCRLFChar :: XParser s Char


-- | A module for regular expression matching based on derivatives of
--   regular expressions.
--   
--   The code was taken from Joe English
--   (<a>http://www.flightlab.com/~joe/sgml/validate.html</a>). Tested and
--   extended by Martin Schmidt.
--   
--   Further references for the algorithm:
--   
--   Janusz A. Brzozowski.
--   
--   Derivatives of Regular Expressions. Journal of the ACM, Volume 11,
--   Issue 4, 1964.
--   
--   Mark Hopkins.
--   
--   Regular Expression Package. Posted to comp.compilers, 1994. Available
--   per FTP at <a>ftp://iecc.com/pub/file/regex.tar.gz</a>.
module Text.XML.HXT.DTDValidation.RE

-- | Data type for regular expressions.
data RE a
RE_ZERO :: String -> RE a
RE_UNIT :: RE a
RE_SYM :: a -> RE a
RE_DOT :: RE a
RE_REP :: (RE a) -> RE a
RE_PLUS :: (RE a) -> RE a
RE_OPT :: (RE a) -> RE a
RE_SEQ :: (RE a) -> (RE a) -> RE a
RE_ALT :: (RE a) -> (RE a) -> RE a

-- | Constructs a regular expression for an empty sequence.
--   
--   <ul>
--   <li>returns : regular expression for an empty sequence</li>
--   </ul>
re_unit :: RE a

-- | Constructs a regular expression for an empty set.
--   
--   <ul>
--   <li>1.parameter errMsg : error message</li>
--   <li>returns : regular expression for an empty set</li>
--   </ul>
re_zero :: String -> RE a

-- | Constructs a regular expression for accepting a symbol
--   
--   <ul>
--   <li>1.parameter sym : the symbol to be accepted</li>
--   <li>returns : regular expression for accepting a symbol</li>
--   </ul>
re_sym :: a -> RE a

-- | Constructs an optional repetition (*) of a regular expression
--   
--   <ul>
--   <li>1.parameter re_a : regular expression to be repeted</li>
--   <li>returns : new regular expression</li>
--   </ul>
re_rep :: RE a -> RE a

-- | Constructs a repetition (+) of a regular expression
--   
--   <ul>
--   <li>1.parameter re_a : regular expression to be repeted</li>
--   <li>returns : new regular expression</li>
--   </ul>
re_plus :: RE a -> RE a

-- | Constructs an option (?) of a regular expression
--   
--   <ul>
--   <li>1.parameter re_a : regular expression to be optional</li>
--   <li>returns : new regular expression</li>
--   </ul>
re_opt :: RE a -> RE a

-- | Constructs a sequence (,) of two regular expressions
--   
--   <ul>
--   <li>1.parameter re_a : first regular expression in sequence</li>
--   <li>2.parameter re_b : second regular expression in sequence</li>
--   <li>returns : new regular expression</li>
--   </ul>
re_seq :: RE a -> RE a -> RE a

-- | Constructs an alternative (|) of two regular expressions
--   
--   <ul>
--   <li>1.parameter re_a : first regular expression of alternative</li>
--   <li>2.parameter re_b : second regular expression of alternative</li>
--   <li>returns : new regular expression</li>
--   </ul>
re_alt :: RE a -> RE a -> RE a

-- | Constructs a regular expression for accepting any singel symbol
--   
--   <ul>
--   <li>returns : regular expression for accepting any singel symbol</li>
--   </ul>
re_dot :: RE a

-- | Checks if an input matched a regular expression. The function should
--   be called after matches.
--   
--   Was the sentence used in <tt>matches</tt> in the language of the
--   regular expression? -&gt; matches e s == s `in` L(e)?
--   
--   <ul>
--   <li>1.parameter re : the derived regular expression</li>
--   <li>returns : empty String if input matched the regular expression,
--   otherwise an error message is returned</li>
--   </ul>
checkRE :: Show a => RE a -> String

-- | Derives a regular expression with respect to a sentence.
--   
--   <ul>
--   <li>1.parameter re : regular expression</li>
--   <li>2.parameter s : sentence to which the regular expression is
--   applied</li>
--   <li>returns : the derived regular expression</li>
--   </ul>
matches :: (Eq a, Show a) => RE a -> [a] -> RE a

-- | Checks if a regular expression matches the empty sequence.
--   
--   nullable e == [] `in` L(e)
--   
--   This check indicates if a regular expression fits to a sentence or
--   not.
--   
--   <ul>
--   <li>1.parameter re : regular expression to be checked</li>
--   <li>returns : true if regular expression matches the empty sequence,
--   otherwise false</li>
--   </ul>
nullable :: Show a => RE a -> Bool

-- | Constructs a string representation of a regular expression.
--   
--   <ul>
--   <li>1.parameter re : a regular expression</li>
--   <li>returns : the string representation of the regular expression</li>
--   </ul>
printRE :: Show a => RE a -> String
instance Show a => Show (RE a)
instance Eq a => Eq (RE a)


-- | default mime type table
--   
--   this file is generated from file <i>etc</i>mime.types
module Text.XML.HXT.DOM.MimeTypeDefaults

-- | the table with the mapping from file name extensions to mime types
mimeTypeDefaults :: [(String, String)]


-- | mime type related data and functions
module Text.XML.HXT.DOM.MimeTypes
type MimeTypeTable = Map String String
application_xhtml, text_xml_external_parsed_entity, text_xml, text_xdtd, text_plain, text_pdf, text_html, application_xml_dtd, application_xml_external_parsed_entity, application_xml :: String
isTextMimeType :: String -> Bool
isHtmlMimeType :: String -> Bool
isXmlMimeType :: String -> Bool
defaultMimeTypeTable :: MimeTypeTable
extensionToMimeType :: String -> MimeTypeTable -> String
readMimeTypeTable :: FilePath -> IO MimeTypeTable
parseMimeTypeTable :: String -> [(String, String)]


-- | Little useful things for strings, lists and other values
module Text.XML.HXT.DOM.Util

-- | remove leading and trailing whitespace with standard Haskell predicate
--   isSpace
stringTrim :: String -> String

-- | convert string to lowercase with standard Haskell toLower function
stringToLower :: String -> String

-- | convert string to uppercase with standard Haskell toUpper function
stringToUpper :: String -> String

-- | find all positions where a string occurs within another string
stringAll :: Eq a => [a] -> [a] -> [Int]

-- | find the position of the first occurence of a string
stringFirst :: Eq a => [a] -> [a] -> Maybe Int

-- | find the position of the last occurence of a string
stringLast :: Eq a => [a] -> [a] -> Maybe Int

-- | Removes leading / trailing whitespaces and leading zeros
normalizeNumber :: String -> String

-- | Reduce whitespace sequences to a single whitespace
normalizeWhitespace :: String -> String

-- | replace all whitespace chars by blanks
normalizeBlanks :: String -> String

-- | Escape all disallowed characters in URI references (see
--   <a>http://www.w3.org/TR/xlink/#link-locators</a>)
escapeURI :: String -> String

-- | escape XML chars &amp;lt; and ampercent by transforming them into
--   character references, used for escaping text nodes
--   
--   see also : <a>attrEscapeXml</a>
textEscapeXml :: String -> String

-- | escape XML chars &amp;lt;, &amp;gt;, &amp;quot;, and ampercent by
--   transforming them into character references
--   
--   see also : <a>attrEscapeXml</a>
stringEscapeXml :: String -> String

-- | escape XML chars in attribute values, same as stringEscapeXml, but
--   none blank whitespace is also escaped
--   
--   see also : <a>stringEscapeXml</a>
attrEscapeXml :: String -> String
stringToInt :: Int -> String -> Int

-- | convert a string into a hexadecimal string applying charToHexString
--   
--   see also : <a>charToHexString</a>
stringToHexString :: String -> String

-- | convert a char (byte) into a 2-digit hexadecimal string
--   
--   see also : <a>stringToHexString</a>, <a>intToHexString</a>
charToHexString :: Char -> String

-- | convert a none negative Int into a hexadecimal string
--   
--   see also : <a>charToHexString</a>
intToHexString :: Int -> String

-- | convert a string of hexadecimal digits into an Int
hexStringToInt :: String -> Int

-- | convert a string of digits into an Int
decimalStringToInt :: String -> Int

-- | take all elements of a list which occur more than once. The result
--   does not contain doubles. (doubles . doubles == doubles)
doubles :: Eq a => [a] -> [a]

-- | drop all elements from a list which occur more than once.
singles :: Eq a => [a] -> [a]

-- | remove duplicates from list
noDoubles :: Eq a => [a] -> [a]
swap :: (a, b) -> (b, a)
partitionEither :: [Either a b] -> ([a], [b])
toMaybe :: Bool -> a -> Maybe a

-- | mothers little helpers for to much curry
uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d
uncurry4 :: (a -> b -> c -> d -> e) -> (a, b, c, d) -> e


-- | Constants for XML keywords, for special attribute names and special
--   attribute values
module Text.XML.HXT.DOM.XmlKeywords
t_xml, t_root :: String
a_default, a_xmlns, a_xml, a_version, a_value, a_url, a_type, a_standalone, a_status, a_source, a_peref, a_output_encoding, a_name, a_modifier, a_module, a_line, a_kind, a_encoding, a_column, a_contentLength :: String
v_0, v_plus, v_star, v_pcdata, v_option, v_null, v_seq, v_mixed, v_empty, v_choice, v_children, v_any, v_no, v_yes, v_2, v_1 :: String
k_any, k_default, k_required, k_pcdata, k_notation, k_ndata, k_implied, k_fixed, k_enumeration, k_system, k_public, k_peref, k_nmtokens, k_nmtoken, k_ignore, k_include, k_idrefs, k_idref, k_id, k_entities, k_entity, k_empty, k_cdata :: String
dtdPrefix :: String
transferPrefix, transferVersion, transferMessage, transferStatus, transferDefaultURI, transferURI, transferEncoding, transferMimeType, transferProtocol :: String
httpPrefix :: String
stringProtocol :: String

-- | the predefined namespace uri for xml:
--   "http://www.w3.org/XML/1998/namespace"
xmlNamespace :: String

-- | the predefined namespace uri for xmlns:
--   "http://www.w3.org/2000/xmlns/"
xmlnsNamespace :: String

-- | Relax NG namespace
relaxNamespace :: String

module Text.XML.HXT.Parser.ProtocolHandlerUtil

-- | Try to extract charset spec from Content-Type header e.g. "text/html;
--   charset=ISO-8859-1"
--   
--   Sometimes the server deliver the charset spec in quotes these are
--   removed
parseContentType :: Parser [(String, String)]

module Text.XML.HXT.Version
hxt_version :: String


-- | Version : $Id$
--   
--   Datatype library for the W3C XML schema datatypes
module Text.XML.HXT.XMLSchema.DataTypeLibW3CNames

-- | Namespace of the W3C XML schema datatype library
w3cNS :: String
xsd_string, xsd_unsignedByte, xsd_unsignedShort, xsd_unsignedInt, xsd_unsignedLong, xsd_byte, xsd_short, xsd_int, xsd_long, xsd_positiveInteger, xsd_nonNegativeInteger, xsd_negativeInteger, xsd_nonPositiveInteger, xsd_integer, xsd_decimal, xsd_base64Binary, xsd_hexBinary, xsd_NOTATION, xsd_QName, xsd_anyURI, xsd_ENTITIES, xsd_ENTITY, xsd_IDREFS, xsd_IDREF, xsd_ID, xsd_NCName, xsd_Name, xsd_NMTOKENS, xsd_NMTOKEN, xsd_language, xsd_token, xsd_normalizedString :: String
xsd_length, xsd_enumeration, xsd_pattern, xsd_fractionDigits, xsd_totalDigits, xsd_minInclusive, xsd_maxInclusive, xsd_minExclusive, xsd_maxExclusive, xsd_minLength, xsd_maxLength :: String


-- | Predefined XML Entity References
--   
--   This module defines a table of all predefined XML entity references
module Text.XML.HXT.Parser.XmlEntities

-- | list of predefined XML entity names and their unicode values
xmlEntities :: [(String, Int)]


-- | XHTML Entity References
--   
--   This module defines a table of all predefined XHTML entity references
--   for special or none ASCII chars including the predefined XML entity
--   refs
module Text.XML.HXT.Parser.XhtmlEntities

-- | table with all XHTML entity refs and corresponding unicode values
xhtmlEntities :: [(String, Int)]


-- | The GET method for file protocol
module Text.XML.HXT.IO.GetFILE
getStdinCont :: Bool -> IO (Either ([(String, String)], String) ByteString)
getCont :: Bool -> String -> IO (Either ([(String, String)], String) ByteString)

module Data.Function.Selector

-- | A Selector is a pair of an access function and a modifying function
--   for reading and updating parts of a composite type
data Selector s a
S :: (s -> a) -> (a -> s -> s) -> Selector s a
getS :: Selector s a -> s -> a
setS :: Selector s a -> a -> s -> s
chgS :: Selector s a -> (a -> a) -> (s -> s)
chgM :: Monad m => Selector s a -> (a -> m a) -> (s -> m s)

-- | Alias for constructor S
mkSelector :: (s -> a) -> (a -> s -> s) -> Selector s a
idS :: Selector s s
(.&&&.) :: Selector s a -> Selector s b -> Selector s (a, b)

-- | Selectors for pairs and 3-tuples: comp1, comp2, comp3, this can be
--   extended to n-tuples
class Comp1 s a | s -> a
comp1 :: Comp1 s a => Selector s a
class Comp2 s a | s -> a
comp2 :: Comp2 s a => Selector s a
class Comp3 s a | s -> a
comp3 :: Comp3 s a => Selector s a
instance Comp3 (a, b, c) c
instance Comp2 (a, b, c) b
instance Comp1 (a, b, c) a
instance Comp2 (a, b) b
instance Comp1 (a, b) a
instance Category Selector


-- | Unique Atoms generated from Strings and managed as flyweights
--   
--   Data.Atom can be used for caching and storage optimisation of
--   frequently used strings. An <tt>Atom</tt> is constructed from a
--   <tt>String</tt>. For two equal strings the identical atom is returned.
--   
--   This module can be used for optimizing memory usage when working with
--   strings or names. Many applications use data types like <tt>Map String
--   SomeAttribute</tt> where a rather fixed set of keys is used.
--   Especially XML applications often work with a limited set of element
--   and attribute names. For these applications it becomes more memory
--   efficient when working with types like <tt>Map Atom SomeAttribute</tt>
--   and convert the keys into atoms before operating on such a map.
--   
--   Internally this module manages a map of atoms. The atoms are
--   internally represented by <tt>ByteString</tt>s. When creating a new
--   atom from a string, the string is first converted into an UTF8
--   <tt>Word8</tt> sequence, which is packed into a <tt>ByteString</tt>.
--   This <tt>ByteString</tt> is looked up in the table of atoms. If it is
--   already there, the value in the map is used as atom, else the new
--   <tt>ByteString</tt> is inserted into the map.
--   
--   Of course the implementation of this name cache uses
--   <tt>unsavePerformIO</tt>. The global cache is managed by ue of an
--   <tt>IORef</tt> and atomicModifyIORef.
--   
--   The following laws hold for atoms
--   
--   <pre>
--   s  ==       t =&gt; newAtom s  ==       newAtom t
--   s `compare` t =&gt; newAtom s `compare` newAtom t
--   show . newAtom == id
--   </pre>
--   
--   Equality test for <tt>Atom</tt>s runs in <i>O(1)</i>, it is just a
--   pointer comarison. The <tt>Ord</tt> comparisons have the same runtime
--   like the <tt>ByteString</tt> comparisons. Internally there is an UTF8
--   comparison, but UTF8 encoding preserves the total order.
--   
--   Warning: The internal cache never shrinks during execution. So using
--   it in a undisciplined way can lead to memory leaks.
module Data.Atom
data Atom

-- | creation of an <tt>Atom</tt> from a <tt>String</tt>
newAtom :: String -> Atom

-- | Insert a <tt>String</tt> into the atom cache and convert the atom back
--   into a <tt>String</tt>.
--   
--   locically <tt>share == id</tt> holds, but internally equal strings
--   share the same memory.
share :: String -> String
instance Typeable Atom
instance NFData Atom
instance Show Atom
instance Read Atom
instance Ord Atom
instance Eq Atom


-- | Simple key value assocciation list implemented as unordered list of
--   pairs
module Data.AssocList
type AssocList k v = [(k, v)]

-- | lookup with default value
lookupDef :: Eq k => v -> k -> AssocList k v -> v

-- | lookup with empty list (empty string) as default value
lookup1 :: Eq k => k -> AssocList k [e] -> [e]

-- | test for existence of a key
hasEntry :: Eq k => k -> AssocList k v -> Bool

-- | add an entry, remove an existing entry before adding the new one at
--   the top of the list, addEntry is strict
addEntry :: Eq k => k -> v -> AssocList k v -> AssocList k v

-- | add a whole list of entries with <a>addEntry</a>
addEntries :: Eq k => AssocList k v -> AssocList k v -> AssocList k v

-- | delete an entry, delEntry is strict
delEntry :: Eq k => k -> AssocList k v -> AssocList k v

-- | delete a list of entries with <a>delEntry</a>
delEntries :: Eq k => [k] -> AssocList k v -> AssocList k v


-- | Interface definition for trees
module Data.Tree.Class

-- | The interface for trees
class Tree t
mkTree :: Tree t => a -> [t a] -> t a
mkLeaf :: Tree t => a -> t a
isLeaf :: Tree t => t a -> Bool
isInner :: Tree t => t a -> Bool
getNode :: Tree t => t a -> a
getChildren :: Tree t => t a -> [t a]
changeNode :: Tree t => (a -> a) -> t a -> t a
changeChildren :: Tree t => ([t a] -> [t a]) -> t a -> t a
setNode :: Tree t => a -> t a -> t a
setChildren :: Tree t => [t a] -> t a -> t a
foldTree :: Tree t => (a -> [b] -> b) -> t a -> b
nodesTree :: Tree t => t a -> [a]
depthTree :: Tree t => t a -> Int
cardTree :: Tree t => t a -> Int
formatTree :: Tree t => (a -> String) -> t a -> String

-- | convert a tree into a pseudo graphical string representation
formatNTree' :: Tree t => (a -> String) -> (String -> String) -> (String -> String) -> t a -> String -> String


-- | Arrows for managing an explicit state
--   
--   State arrows work similar to state monads. A state value is threaded
--   through the application of arrows.
module Control.Arrow.ArrowState

-- | The interface for accessing and changing the state component.
--   
--   Multi parameter classes and functional dependencies are required.
class Arrow a => ArrowState s a | a -> s
changeState :: ArrowState s a => (s -> b -> s) -> a b b
accessState :: ArrowState s a => (s -> b -> c) -> a b c
getState :: ArrowState s a => a b s
setState :: ArrowState s a => a s s
nextState :: ArrowState s a => (s -> s) -> a b s


-- | Interface definition for navigatable trees. Navigatable trees need to
--   have operations to move up, down, left and right. With these
--   elementary operations, most of the XPath axises can be defined.
module Data.Tree.NavigatableTree.Class

-- | The interface for navigatable trees
class NavigatableTree t
mvUp :: NavigatableTree t => t a -> Maybe (t a)
mvDown :: NavigatableTree t => t a -> Maybe (t a)
mvLeft :: NavigatableTree t => t a -> Maybe (t a)
mvRight :: NavigatableTree t => t a -> Maybe (t a)

-- | Conversion between trees and navigatable trees,
--   
--   There is only a single navigatable tree implementation for a given
--   tree allowed (see the functional dependencies)
class NavigatableTreeToTree nt t | t -> nt, nt -> t
fromTree :: NavigatableTreeToTree nt t => t a -> nt a
toTree :: NavigatableTreeToTree nt t => nt a -> t a

-- | Edit operation on navigatable trees
--   
--   There is only a single navigatable tree implementation for a given
--   tree allowed (see the functional dependencies)
class NavigatableTreeModify nt t | t -> nt, nt -> t
addTreeLeft :: NavigatableTreeModify nt t => t a -> nt a -> Maybe (nt a)
addTreeRight :: NavigatableTreeModify nt t => t a -> nt a -> Maybe (nt a)
dropTreeLeft :: NavigatableTreeModify nt t => nt a -> Maybe (nt a)
dropTreeRight :: NavigatableTreeModify nt t => nt a -> Maybe (nt a)
substThisTree :: NavigatableTreeModify nt t => t a -> nt a -> nt a


-- | Navigatable trees need to have operations to move up, down, left and
--   right. With these elementary operations, the XPath axises can be
--   defined.
module Data.Tree.NavigatableTree.XPathAxis

-- | collect all trees by moving into one direction, starting tree is
--   included
maybeStar :: (a -> Maybe a) -> (a -> [a])

-- | collect all trees by moving into one direction, starting tree is not
--   included
maybePlus :: (a -> Maybe a) -> (a -> [a])

-- | XPath axis: parent
parentAxis :: NavigatableTree t => t a -> [t a]

-- | XPath axis: ancestor
ancestorAxis :: NavigatableTree t => t a -> [t a]

-- | XPath axis: ancestor or self
ancestorOrSelfAxis :: NavigatableTree t => t a -> [t a]

-- | XPath axis: child
childAxis :: NavigatableTree t => t a -> [t a]

-- | XPath axis: descendant
descendantAxis :: NavigatableTree t => t a -> [t a]

-- | XPath axis: descendant or self
descendantOrSelfAxis :: NavigatableTree t => t a -> [t a]

-- | not an official XPath axis but useful: reverse descendant or self,
--   used in preceding axis
revDescendantOrSelfAxis :: NavigatableTree t => t a -> [t a]

-- | XPath axis: following sibling
followingSiblingAxis :: NavigatableTree t => t a -> [t a]

-- | XPath axis: preceeding sibling
precedingSiblingAxis :: NavigatableTree t => t a -> [t a]

-- | XPath axis: self
selfAxis :: NavigatableTree t => t a -> [t a]

-- | XPath axis: following
followingAxis :: NavigatableTree t => t a -> [t a]

-- | XPath axis: preceding
precedingAxis :: NavigatableTree t => t a -> [t a]

-- | move to the root
mvToRoot :: NavigatableTree t => t a -> t a
isAtRoot :: NavigatableTree t => t a -> Bool


-- | Force evaluation like deepseq in Control.DeepSeq, but control the
--   depth of evaluation. flatseq may evaluate more than seq but less than
--   deepseq
module Control.FlatSeq
($!!) :: WNFData a => (a -> b) -> a -> b
flatseq :: WNFData a => a -> b -> b
rlnf :: (a -> ()) -> [a] -> ()

-- | A class of types that can be partially evaluated, but evaluation can
--   be propagated deeper than WHNF
class WNFData a
rwnf :: WNFData a => a -> ()
rwnf2 :: WNFData a => a -> ()
instance (WNFData a, WNFData b, WNFData c, WNFData d) => WNFData (a, b, c, d)
instance (WNFData a, WNFData b, WNFData c) => WNFData (a, b, c)
instance (WNFData a, WNFData b) => WNFData (a, b)
instance WNFData a => WNFData [a]
instance WNFData Word64
instance WNFData Word32
instance WNFData Word16
instance WNFData Word8
instance WNFData Word
instance WNFData ()
instance WNFData Bool
instance WNFData Char
instance WNFData Double
instance WNFData Float
instance WNFData Integer
instance WNFData Int


-- | Interface definition for trees
--   
--   n-ary tree structure (rose trees)
module Data.Tree.NTree.TypeDefs

-- | n-ary ordered tree (rose trees)
--   
--   a tree consists of a node and a possible empty list of children. If
--   the list of children is empty, the node is a leaf, else it's an inner
--   node.
--   
--   NTree implements Eq, Ord, Show and Read
data NTree a
NTree :: a -> (NTrees a) -> NTree a

-- | shortcut for a sequence of n-ary trees
type NTrees a = [NTree a]
instance Typeable1 NTree
instance Eq a => Eq (NTree a)
instance Ord a => Ord (NTree a)
instance Show a => Show (NTree a)
instance Read a => Read (NTree a)
instance Tree NTree
instance Functor NTree
instance Binary a => Binary (NTree a)
instance WNFData a => WNFData (NTree a)
instance NFData a => NFData (NTree a)


-- | Space and time efficient editing of rose trees
module Data.Tree.NTree.Edit

-- | editNTreeBottomUp is a space optimized tree edit function
--   
--   The nodes in a tree are visited bottom up. An edit function is applied
--   to all nodes. A Nothing result of the editing function indicates no
--   changes. This is used to share the input tree within the resulting
--   tree.
--   
--   The following law holds:
--   
--   <pre>
--   editNTreeBottomUp (const Nothing) t == [t]
--   </pre>
--   
--   In this case the resulting tree does not only represent the same value
--   but it is the same machine value (relative to some evaluations of
--   closures during the tree walk
--   
--   With a simple fold like editing function the whole tree would be
--   reconstructed in memory
editNTreeBottomUp :: (NTree a -> Maybe [NTree a]) -> NTree a -> [NTree a]

-- | A space optimized map for NTrees
--   
--   Subtrees, that are not changed are reused in the resulting tree See
--   also: editNTreeBottomUp
mapNTree' :: (a -> Maybe a) -> NTree a -> NTree a


-- | Implementation of navigateble trees for rose trees. The implementation
--   is done with zippers. A description and introductory tutorial about
--   zippers can be found in <a>http://learnyouahaskell.com/zippers</a>
module Data.Tree.NTree.Zipper.TypeDefs

-- | Zipper for rose trees
--   
--   A zipper consist of the current tree and the branches on the way back
--   to the root
data NTZipper a
NTZ :: (NTree a) -> (NTBreadCrumbs a) -> NTZipper a
ntree :: NTZipper a -> (NTree a)
context :: NTZipper a -> (NTBreadCrumbs a)

-- | The list of unzipped nodes from a current tree back to the root
type NTBreadCrumbs a = [NTCrumb a]

-- | One unzipped step consists of the left siblings, the node info and the
--   right siblings
data NTCrumb a
NTC :: (NTrees a) -> a -> (NTrees a) -> NTCrumb a

-- | Conversion of a rose tree into a navigatable rose tree
toNTZipper :: NTree a -> NTZipper a

-- | Conversion of a navigatable rose tree into an ordinary rose tree.
--   
--   The context, the parts for moving up to the root are just removed from
--   the tree. So when transforming a navigatable tree by moving around and
--   by changing some nodes, one has to navigate back to the root, else
--   that parts are removed from the result
fromNTZipper :: NTZipper a -> NTree a
up :: NTZipper a -> Maybe (NTZipper a)
down :: NTZipper a -> Maybe (NTZipper a)
toTheRight :: NTZipper a -> Maybe (NTZipper a)
toTheLeft :: NTZipper a -> Maybe (NTZipper a)
addToTheLeft :: NTree a -> NTZipper a -> Maybe (NTZipper a)
addToTheRight :: NTree a -> NTZipper a -> Maybe (NTZipper a)
dropFromTheLeft :: NTZipper a -> Maybe (NTZipper a)
dropFromTheRight :: NTZipper a -> Maybe (NTZipper a)
isTop :: NTZipper a -> Bool
up1 :: NTree a -> NTCrumb a -> NTree a
instance Show a => Show (NTCrumb a)
instance Show a => Show (NTZipper a)
instance NavigatableTreeModify NTZipper NTree
instance NavigatableTreeToTree NTZipper NTree
instance NavigatableTree NTZipper
instance Tree NTZipper
instance Functor NTCrumb
instance Functor NTZipper


-- | The types and functions for qualified names
module Text.XML.HXT.DOM.QualifiedName

-- | Namespace support for element and attribute names.
--   
--   A qualified name consists of a name prefix, a local name and a
--   namespace uri. All modules, which are not namespace aware, use only
--   the <a>localPart</a> component. When dealing with namespaces, the
--   document tree must be processed by
--   <tt>Text.XML.HXT.Arrow.Namespace.propagateNamespaces</tt> to split
--   names of structure "prefix:localPart" and label the name with the
--   apropriate namespace uri
data QName

-- | XML names are represented by Strings, but these strings do not mix up
--   with normal strings. Names are always reduced to normal form, and they
--   are stored internally in a name cache for sharing equal names by the
--   same data structure
data XName

-- | Type for the namespace association list, used when propagating
--   namespaces by modifying the <a>QName</a> values in a tree
type NsEnv = AssocList XName XName

-- | constructs a complete qualified name with <a>namePrefix</a>,
--   <a>localPart</a> and <a>namespaceUri</a>. This function can be used to
--   build not wellformed prefix:localpart names. The XPath module uses
--   wildcard names like <tt>xxx:*</tt>. These must be build with
--   <a>mkQName</a> and not with mkName.
mkQName :: String -> String -> String -> QName

-- | constructs a simple, namespace unaware name. If the name is in
--   <tt>prefix:localpart</tt> form and the prefix is not empty the name is
--   split internally into a prefix and a local part.
mkName :: String -> QName

-- | constructs a simple, namespace aware name, with prefix:localPart as
--   first parameter, namspace uri as second.
--   
--   see also <a>mkName</a>, <a>mkPrefixLocalPart</a>
mkNsName :: String -> String -> QName

-- | old name for <a>mkName</a>
mkSNsName :: String -> QName

-- | constructs a simple name, with prefix and localPart but without a
--   namespace uri.
--   
--   see also <a>mkQName</a>, <a>mkName</a>
mkPrefixLocalPart :: String -> String -> QName

-- | Equivalent QNames are defined as follows: The URIs are normalized
--   before comparison. Comparison is done with <a>equalQNameBy</a> and
--   <a>equivUri</a>
equivQName :: QName -> QName -> Bool

-- | Comparison of normalized namespace URIs using <a>normalizeNsUri</a>
equivUri :: String -> String -> Bool

-- | Sometimes a weaker equality relation than <tt>equalQName</tt> is
--   appropriate, e.g no case significance in names, ... a name
--   normalization function can be applied to the strings before comparing.
--   Called by <tt>equalQName</tt> and <a>equivQName</a>
equalQNameBy :: (String -> String -> Bool) -> QName -> QName -> Bool
namePrefix :: QName -> String
localPart :: QName -> String
namespaceUri :: QName -> String
newXName :: String -> XName
nullXName, xmlXName, xmlNamespaceXName, xmlnsXName, xmlnsNamespaceXName :: XName
isNullXName :: XName -> Bool
newQName :: XName -> XName -> XName -> QName
mkQName' :: XName -> XName -> XName -> QName
namePrefix' :: QName -> XName
localPart' :: QName -> XName
namespaceUri' :: QName -> XName

-- | set name prefix
setNamePrefix' :: XName -> QName -> QName

-- | set local part
setLocalPart' :: XName -> QName -> QName

-- | set name prefix
setNamespaceUri' :: XName -> QName -> QName

-- | builds the full name "prefix:localPart", if prefix is not null, else
--   the local part is the result
qualifiedName :: QName -> String

-- | functional list version of qualifiedName used in xshow
qualifiedName' :: QName -> String -> String

-- | builds the "universal" name, that is the namespace uri surrounded with
--   "{" and "}" followed by the local part (specialisation of
--   <a>buildUniversalName</a>)
universalName :: QName -> String

-- | builds an "universal" uri, that is the namespace uri followed by the
--   local part. This is usefull for RDF applications, where the subject,
--   predicate and object often are concatenated from namespace uri and
--   local part (specialisation of <a>buildUniversalName</a>)
universalUri :: QName -> String

-- | builds a string from the namespace uri and the local part. If the
--   namespace uri is empty, the local part is returned, else namespace uri
--   and local part are combined with the combining function given by the
--   first parameter
buildUniversalName :: (String -> String -> String) -> QName -> String

-- | Normalization of URIs: Normalization is done by conversion into
--   lowercase letters. A trailing "/" is ignored
normalizeNsUri :: String -> String

-- | Compute the name prefix and the namespace uri for a qualified name.
--   
--   This function does not test whether the name is a wellformed qualified
--   name. see Namespaces in XML Rule [6] to [8]. Error checking is done
--   with separate functions, see <a>isWellformedQName</a> and
--   <a>isWellformedQualifiedName</a> for error checking.
setNamespace :: NsEnv -> QName -> QName

-- | test for wellformed NCName, rule [4] XML Namespaces
isNCName :: String -> Bool

-- | test for wellformed QName, rule [6] XML Namespaces predicate is used
--   in filter <tt>valdateNamespaces</tt>.
isWellformedQualifiedName :: String -> Bool

-- | test for wellformed QName values. A QName is wellformed, if the local
--   part is a NCName, the namePrefix, if not empty, is also a NCName.
--   predicate is used in filter <tt>valdateNamespaces</tt>.
isWellformedQName :: QName -> Bool

-- | test whether an attribute name is a namesapce declaration name. If
--   this is not the case True is the result, else the name must be a well
--   formed namespace name: All namespace prefixes starting with "xml" are
--   reserved for XML related definitions. predicate is used in filter
--   <tt>valdateNamespaces</tt>.
isWellformedNSDecl :: QName -> Bool

-- | test for a namespace name to be well formed
isWellformedNameSpaceName :: QName -> Bool

-- | test whether a name is a namespace declaration attribute name
isNameSpaceName :: QName -> Bool

-- | predicate is used in filter <tt>valdateNamespaces</tt>.
isDeclaredNamespace :: QName -> Bool
xmlnsQN :: QName
toNsEnv :: AssocList String String -> NsEnv
instance Typeable XName
instance Typeable QName
instance Binary QName
instance Show QName
instance WNFData QName
instance NFData QName
instance Eq QName
instance Binary XName
instance WNFData XName
instance NFData XName
instance Ord XName
instance Eq XName


-- | The core data types of the HXT DOM.
module Text.XML.HXT.DOM.TypeDefs

-- | Rose tree with XML nodes (XNode)
type XmlTree = NTree XNode

-- | List of rose trees with XML nodes
type XmlTrees = NTrees XNode

-- | Navigatable rose tree with XML nodes
type XmlNavTree = NTZipper XNode

-- | List of navigatable rose trees with XML nodes
type XmlNavTrees = [NTZipper XNode]

-- | Represents elements
data XNode

-- | ordinary text (leaf)
XText :: String -> XNode

-- | text represented more space efficient as bytestring (leaf)
XBlob :: Blob -> XNode

-- | character reference (leaf)
XCharRef :: Int -> XNode

-- | entity reference (leaf)
XEntityRef :: String -> XNode

-- | comment (leaf)
XCmt :: String -> XNode

-- | CDATA section (leaf)
XCdata :: String -> XNode

-- | Processing Instr with qualified name (leaf) with list of attributes.
--   If tag name is xml, attributs are "version", "encoding", "standalone",
--   else attribute list is empty, content is a text child node
XPi :: QName -> XmlTrees -> XNode

-- | tag with qualified name and list of attributes (inner node or leaf)
XTag :: QName -> XmlTrees -> XNode

-- | DTD element with assoc list for dtd element features
XDTD :: DTDElem -> Attributes -> XNode

-- | attribute with qualified name, the attribute value is stored in
--   children
XAttr :: QName -> XNode

-- | error message with level and text
XError :: Int -> String -> XNode

-- | Evaluate an assoc list of strings
rwnfAttributes :: Attributes -> ()

-- | Represents a DTD element
data DTDElem

-- | attr: name, system, public, XDTD elems as children
DOCTYPE :: DTDElem

-- | attr: name, kind
--   
--   name: element name
--   
--   kind: "EMPTY" | "ANY" | "#PCDATA" | children | mixed
ELEMENT :: DTDElem

-- | element content
--   
--   attr: kind, modifier
--   
--   modifier: "" | "?" | "*" | "+"
--   
--   kind: seq | choice
CONTENT :: DTDElem

-- | attributes: name - name of element
--   
--   value - name of attribute
--   
--   type: "CDATA" | "ID" | "IDREF" | "IDREFS" | "ENTITY" | "ENTITIES" |
--   
--   "NMTOKEN" | "NMTOKENS" |"NOTATION" | "ENUMTYPE"
--   
--   kind: "IMPLIED" | "DEFAULT"
ATTLIST :: DTDElem

-- | for entity declarations
ENTITY :: DTDElem

-- | for parameter entity declarations
PENTITY :: DTDElem

-- | for notations
NOTATION :: DTDElem

-- | for INCLUDEs, IGNOREs and peRefs: attr: type
--   
--   type = INCLUDE, IGNORE or %...;
CONDSECT :: DTDElem

-- | attr: name
--   
--   for lists of names in notation types or nmtokens in enumeration types
NAME :: DTDElem

-- | for Parameter Entity References in DTDs
PEREF :: DTDElem

-- | Binary large object implemented as a lazy bytestring
type Blob = ByteString
blobToString :: Blob -> String
stringToBlob :: String -> Blob

-- | Attribute list
--   
--   used for storing option lists and features of DTD parts
type Attributes = AssocList String String

-- | no error, everything is ok
c_ok :: Int

-- | Error level for XError, type warning
c_warn :: Int

-- | Error level for XError, type error
c_err :: Int

-- | Error level for XError, type fatal error
c_fatal :: Int

-- | data type for representing a set of nodes as a tree structure
--   
--   this structure is e.g. used to repesent the result of an XPath query
--   such that the selected nodes can be processed or selected later in
--   processing a document tree
data XmlNodeSet
XNS :: Bool -> [QName] -> ChildNodes -> XmlNodeSet

-- | is this node part of the set ?
thisNode :: XmlNodeSet -> Bool

-- | the set of attribute nodes
attrNodes :: XmlNodeSet -> [QName]

-- | the set of child nodes, a list of pairs of index and node set
childNodes :: XmlNodeSet -> ChildNodes
type ChildNodes = [(Int, XmlNodeSet)]
instance Typeable DTDElem
instance Typeable XNode
instance Typeable XmlNodeSet
instance Eq DTDElem
instance Ord DTDElem
instance Enum DTDElem
instance Show DTDElem
instance Read DTDElem
instance Eq XNode
instance Show XNode
instance Eq XmlNodeSet
instance Show XmlNodeSet
instance Binary DTDElem
instance WNFData DTDElem
instance NFData DTDElem
instance Binary XNode
instance WNFData XNode
instance NFData XNode


-- | The interface to the primitive DOM data types and constants and
--   utility functions
module Text.XML.HXT.DOM.Interface


-- | Interface for XmlArrow to basic data types NTree and XmlTree
--   
--   If this module must be used in code working with arrows, it should be
--   imported qualified e.g. <tt>as XN</tt>, to prevent name clashes.
--   
--   For code working on the "node and tree level" this module is the
--   interface for writing code without using the constructor functions of
--   <a>XNode</a> and <a>NTree</a> directly
module Text.XML.HXT.DOM.XmlNode
class XmlNode a
isText :: XmlNode a => a -> Bool
isBlob :: XmlNode a => a -> Bool
isCharRef :: XmlNode a => a -> Bool
isEntityRef :: XmlNode a => a -> Bool
isCmt :: XmlNode a => a -> Bool
isCdata :: XmlNode a => a -> Bool
isPi :: XmlNode a => a -> Bool
isElem :: XmlNode a => a -> Bool
isRoot :: XmlNode a => a -> Bool
isDTD :: XmlNode a => a -> Bool
isAttr :: XmlNode a => a -> Bool
isError :: XmlNode a => a -> Bool
mkText :: XmlNode a => String -> a
mkBlob :: XmlNode a => Blob -> a
mkCharRef :: XmlNode a => Int -> a
mkEntityRef :: XmlNode a => String -> a
mkCmt :: XmlNode a => String -> a
mkCdata :: XmlNode a => String -> a
mkPi :: XmlNode a => QName -> XmlTrees -> a
mkError :: XmlNode a => Int -> String -> a
getText :: XmlNode a => a -> Maybe String
getBlob :: XmlNode a => a -> Maybe Blob
getCharRef :: XmlNode a => a -> Maybe Int
getEntityRef :: XmlNode a => a -> Maybe String
getCmt :: XmlNode a => a -> Maybe String
getCdata :: XmlNode a => a -> Maybe String
getPiName :: XmlNode a => a -> Maybe QName
getPiContent :: XmlNode a => a -> Maybe XmlTrees
getElemName :: XmlNode a => a -> Maybe QName
getAttrl :: XmlNode a => a -> Maybe XmlTrees
getDTDPart :: XmlNode a => a -> Maybe DTDElem
getDTDAttrl :: XmlNode a => a -> Maybe Attributes
getAttrName :: XmlNode a => a -> Maybe QName
getErrorLevel :: XmlNode a => a -> Maybe Int
getErrorMsg :: XmlNode a => a -> Maybe String
getName :: XmlNode a => a -> Maybe QName
getQualifiedName :: XmlNode a => a -> Maybe String
getUniversalName :: XmlNode a => a -> Maybe String
getUniversalUri :: XmlNode a => a -> Maybe String
getLocalPart :: XmlNode a => a -> Maybe String
getNamePrefix :: XmlNode a => a -> Maybe String
getNamespaceUri :: XmlNode a => a -> Maybe String
changeText :: XmlNode a => (String -> String) -> a -> a
changeBlob :: XmlNode a => (Blob -> Blob) -> a -> a
changeCmt :: XmlNode a => (String -> String) -> a -> a
changeName :: XmlNode a => (QName -> QName) -> a -> a
changeElemName :: XmlNode a => (QName -> QName) -> a -> a
changeAttrl :: XmlNode a => (XmlTrees -> XmlTrees) -> a -> a
changeAttrName :: XmlNode a => (QName -> QName) -> a -> a
changePiName :: XmlNode a => (QName -> QName) -> a -> a
changeDTDAttrl :: XmlNode a => (Attributes -> Attributes) -> a -> a
setText :: XmlNode a => String -> a -> a
setBlob :: XmlNode a => Blob -> a -> a
setCmt :: XmlNode a => String -> a -> a
setName :: XmlNode a => QName -> a -> a
setElemName :: XmlNode a => QName -> a -> a
setElemAttrl :: XmlNode a => XmlTrees -> a -> a
setAttrName :: XmlNode a => QName -> a -> a
setPiName :: XmlNode a => QName -> a -> a
setDTDAttrl :: XmlNode a => Attributes -> a -> a
mkElementNode :: QName -> XmlTrees -> XNode
mkAttrNode :: QName -> XNode
mkDTDNode :: DTDElem -> Attributes -> XNode
mkElement :: QName -> XmlTrees -> XmlTrees -> XmlTree
mkRoot :: XmlTrees -> XmlTrees -> XmlTree
mkAttr :: QName -> XmlTrees -> XmlTree
mkDTDElem :: DTDElem -> Attributes -> XmlTrees -> XmlTree
addAttr :: XmlTree -> XmlTrees -> XmlTrees
mergeAttrl :: XmlTrees -> XmlTrees -> XmlTrees

-- | weak normalform versions of constructors
mkElement' :: QName -> XmlTrees -> XmlTrees -> XmlTree
mkRoot' :: XmlTrees -> XmlTrees -> XmlTree
mkAttr' :: QName -> XmlTrees -> XmlTree
mkText' :: String -> XmlTree
mkCharRef' :: Int -> XmlTree
mkEntityRef' :: String -> XmlTree
mkCmt' :: String -> XmlTree
mkCdata' :: String -> XmlTree
mkPi' :: QName -> XmlTrees -> XmlTree
mkError' :: Int -> String -> XmlTree
mkDTDElem' :: DTDElem -> Attributes -> XmlTrees -> XmlTree
toText :: XmlTree -> XmlTree
concText :: XmlTree -> XmlTree -> XmlTrees
mergeText :: XmlTree -> XmlTree -> XmlTrees
instance (XmlNode a, Tree t) => XmlNode (t a)
instance XmlNode XNode


-- | Parsec parser for XML tokens
module Text.XML.HXT.Parser.XmlTokenParser
allBut :: (XParser s Char -> XParser s String) -> String -> XParser s String
allBut1 :: (XParser s Char -> XParser s String) -> (Char -> Bool) -> String -> XParser s String
dq, amp, semi, gt, lt, sq :: XParser s ()
asciiLetter :: XParser s Char
attrChar :: String -> XParser s String
attrValue :: XParser s String
bar, rpar, lpar, eq, comma :: XParser s ()
charRef :: XParser s Int
checkString :: String -> XParser s ()
encName :: XParser s String
entityRef :: XParser s String
entityValue :: XParser s String
keyword :: String -> XParser s String
keywords :: [String] -> XParser s String
name :: XParser s String
names :: XParser s [String]
ncName :: XParser s String
nmtoken :: XParser s String
nmtokens :: XParser s [String]
peReference :: XParser s String
pubidLiteral :: XParser s String
qName :: XParser s (String, String)
quoted :: XParser s a -> XParser s a
reference :: XParser s String
separator :: Char -> XParser s ()
singleChar :: String -> XParser s Char
singleChars :: String -> XParser s String
skipS :: XParser s ()
skipS0 :: XParser s ()
sPace :: XParser s String
sPace0 :: XParser s String
systemLiteral :: XParser s String
versionNum :: XParser s String
concRes :: XParser s [[a]] -> XParser s [a]
mkList :: XParser s a -> XParser s [a]
nameT :: XParser s XmlTree
nmtokenT :: XParser s XmlTree
entityValueT :: XParser s XmlTrees
entityTokensT :: String -> XParser s XmlTrees
entityCharT :: String -> XParser s XmlTree
attrValueT :: XParser s XmlTrees
attrValueT' :: String -> XParser s XmlTrees
referenceT :: XParser s XmlTree
charRefT :: XParser s XmlTree
entityRefT :: XParser s XmlTree
peReferenceT :: XParser s XmlTree
singleCharsT :: String -> XParser s XmlTree
mergeTextNodes :: XmlTrees -> XmlTrees


-- | Parsec parser for tokenizing DTD declarations for ELEMENT, ATTLIST,
--   ENTITY and NOTATION
module Text.XML.HXT.Parser.XmlDTDTokenParser
dtdDeclTokenizer :: XParser s XmlTree
dtdDeclStart :: XParser s (DTDElem, Attributes)
dtdDeclEnd :: XParser s ()
dtdToken :: XParser s XmlTree
peReference :: XParser s XmlTree
entityValue :: XParser s XmlTree
dtdChars :: XParser s XmlTree
percent :: XParser s XmlTree


-- | XML tree conversion to external string representation
module Text.XML.HXT.DOM.ShowXml

-- | convert a list of trees into a string
--   
--   see also : <tt>xmlTreesToText</tt> for filter version,
--   <tt>Text.XML.HXT.Parser.XmlParsec.xread</tt> for the inverse operation
xshow :: XmlTrees -> String

-- | convert an XML tree into a binary large object (a bytestring)
xshowBlob :: XmlTrees -> Blob

-- | convert a list of trees into a blob.
--   
--   Apply a quoting function for XML quoting of content, a 2. quoting
--   funtion for attribute values and an encoding function after tree
--   conversion
xshow' :: (Char -> StringFct) -> (Char -> StringFct) -> (Char -> StringFct) -> XmlTrees -> Blob
xshow'' :: (Char -> StringFct) -> (Char -> StringFct) -> XmlTrees -> String


-- | Format a xml tree in tree representation
module Text.XML.HXT.DOM.FormatXmlTree
formatXmlTree :: XmlTree -> String
formatXmlContents :: XmlTree -> XmlTrees


-- | Xml Parsec parser with pure filter interface
module Text.XML.HXT.Parser.XmlParsec
charData :: XParser s XmlTrees
charData' :: XParser s XmlTree
comment :: XParser s XmlTree
pI :: XParser s XmlTree
cDSect :: XParser s XmlTree
document :: XParser s XmlTree
document' :: XParser s XmlTrees
prolog :: XParser s XmlTrees
xMLDecl :: XParser s XmlTrees
xMLDecl' :: XParser s XmlTrees
versionInfo :: XParser s XmlTrees
misc :: XParser s XmlTree
doctypedecl :: XParser s XmlTrees
markupdecl :: XParser s XmlTrees
sDDecl :: XParser s XmlTrees
element :: XParser s XmlTree
content :: XParser s XmlTrees
contentWithTextDecl :: XParser s XmlTrees
textDecl :: XParser s XmlTrees
encodingDecl :: XParser s XmlTrees

-- | the inverse function to <a>xshow</a>, (for XML content).
--   
--   the string parameter is parsed with the XML content parser. result is
--   the list of trees or in case of an error a single element list with
--   the error message as node. No entity or character subtitution is done
--   here, but the XML parser can do this for the predefined XML or the
--   char references for performance reasons
--   
--   see also: <a>parseXmlContent</a>
xread :: String -> XmlTrees

-- | the filter version of <a>xread</a>
parseXmlContent :: XmlTree -> XmlTrees
parseXmlDocEncodingSpec :: XmlTree -> XmlTrees
parseXmlDocument :: String -> String -> XmlTrees

-- | Parser for parts of a DTD
parseXmlDTDPart :: String -> XmlTree -> XmlTrees

-- | try to parse a xml encoding spec.
--   
--   <ul>
--   <li>1.parameter encParse : the parser for the encoding decl</li>
--   <li>2.parameter root : a document root</li>
--   <li>returns : the same tree, but with an additional attribute
--   "encoding" in the root node in case of a valid encoding spec else the
--   unchanged tree</li>
--   </ul>
parseXmlEncodingSpec :: SimpleXParser XmlTree -> XmlTree -> XmlTrees
parseXmlEntityEncodingSpec :: XmlTree -> XmlTrees

-- | Parser for entity substitution within attribute values
parseXmlEntityValueAsAttrValue :: String -> XmlTree -> XmlTrees

-- | Parser for general entites
parseXmlEntityValueAsContent :: String -> XmlTree -> XmlTrees

-- | general parser for parsing arbitray parts of a XML document
parseXmlPart :: SimpleXParser XmlTrees -> String -> String -> XmlTree -> XmlTrees

-- | a more general version of <a>parseXmlContent</a>. The parser to be
--   used and the context are extra parameter
parseXmlText :: SimpleXParser XmlTrees -> XPState () -> String -> XmlTree -> XmlTrees

-- | Parser for NMTOKENs
parseNMToken :: String -> XmlTree -> XmlTrees

-- | Parser for XML names
parseName :: String -> XmlTree -> XmlTrees
removeEncodingSpec :: XmlTree -> XmlTrees


-- | This parser tries to interprete everything as HTML no errors are
--   emitted during parsing. If something looks weired, warning messages
--   are inserted in the document tree.
--   
--   All filter are pure XmlFilter, errror handling and IO is done in
--   <tt>Text.XML.HXT.Parser.HtmlParser</tt> or other modules
module Text.XML.HXT.Parser.HtmlParsec
parseHtmlText :: String -> XmlTree -> XmlTrees
parseHtmlDocument :: String -> String -> XmlTrees
parseHtmlContent :: String -> XmlTrees
isEmptyHtmlTag :: String -> Bool
isInnerHtmlTagOf :: String -> String -> Bool
closesHtmlTag :: String -> String -> Bool
emptyHtmlTags :: [String]


-- | Parsec parser for DTD declarations for ELEMENT, ATTLIST, ENTITY and
--   NOTATION declarations
module Text.XML.HXT.Parser.XmlDTDParser

-- | parse a tokenized DTD declaration represented by a DTD tree. The
--   content is represented by the children containing text and parameter
--   entity reference nodes. The parameter entity reference nodes contain
--   their value in the children list, consisting of text and possibly
--   again parameter entity reference nodes. This structure is build by the
--   parameter entity substitution. Output is again a DTD declaration node,
--   but this time completely parsed and ready for further DTD processing
parseXmlDTDdecl :: XmlTree -> XmlTrees
parseXmlDTDdeclPart :: XmlTree -> XmlTrees
parseXmlDTDEntityValue :: XmlTree -> XmlTrees
elementDecl :: SParser XmlTrees
attlistDecl :: SParser XmlTrees
entityDecl :: SParser XmlTrees
notationDecl :: SParser XmlTrees


-- | Version : $Id$
--   
--   Datatypes and functions for building a content model for XML picklers.
--   A schema is part of every pickler and can be used to derive a
--   corrensponding DTD (or Relax NG schema). This schema further enables
--   checking the picklers.
module Text.XML.HXT.Arrow.Pickle.Schema

-- | The datatype for modelling the structure of an
data Schema
Any :: Schema
Seq :: [Schema] -> Schema
sc_l :: Schema -> [Schema]
Alt :: [Schema] -> Schema
sc_l :: Schema -> [Schema]
Rep :: Int -> Int -> Schema -> Schema
sc_lb :: Schema -> Int
sc_ub :: Schema -> Int
sc_1 :: Schema -> Schema
Element :: Name -> Schema -> Schema
sc_n :: Schema -> Name
sc_1 :: Schema -> Schema
Attribute :: Name -> Schema -> Schema
sc_n :: Schema -> Name
sc_1 :: Schema -> Schema
ElemRef :: Name -> Schema
sc_n :: Schema -> Name
CharData :: DataTypeDescr -> Schema
sc_dt :: Schema -> DataTypeDescr
type Name = String
type Schemas = [Schema]
data DataTypeDescr
DTDescr :: String -> String -> Attributes -> DataTypeDescr
dtLib :: DataTypeDescr -> String
dtName :: DataTypeDescr -> String
dtParams :: DataTypeDescr -> Attributes

-- | test: is schema a simple XML Schema datatype
isScXsd :: (String -> Bool) -> Schema -> Bool

-- | test: is type a fixed value attribute type
isScFixed :: Schema -> Bool
isScEnum :: Schema -> Bool
isScElem :: Schema -> Bool
isScAttr :: Schema -> Bool
isScElemRef :: Schema -> Bool
isScCharData :: Schema -> Bool
isScSARE :: Schema -> Bool
isScList :: Schema -> Bool
isScOpt :: Schema -> Bool

-- | access an attribute of a descr of an atomic type
xsdParam :: String -> Schema -> String
scDT :: String -> String -> Attributes -> Schema
scDTxsd :: String -> Attributes -> Schema
scString :: Schema
scString1 :: Schema
scFixed :: String -> Schema
scEnum :: [String] -> Schema
scNmtoken :: Schema
scNmtokens :: Schema
scEmpty :: Schema
scSeq :: Schema -> Schema -> Schema
scSeqs :: [Schema] -> Schema
scNull :: Schema
scAlt :: Schema -> Schema -> Schema
scAlts :: [Schema] -> Schema
scOption :: Schema -> Schema
scList :: Schema -> Schema
scList1 :: Schema -> Schema
scOpt :: Schema -> Schema
scRep :: Int -> Int -> Schema -> Schema
scElem :: String -> Schema -> Schema
scAttr :: String -> Schema -> Schema
instance Show DataTypeDescr
instance Eq Schema
instance Show Schema
instance Eq DataTypeDescr


-- | Version : $Id$
--   
--   Functions for converting a pickler schema into a DTD
module Text.XML.HXT.Arrow.Pickle.DTD
data DTDdescr
DTDdescr :: Name -> Schemas -> [(Name, Schemas)] -> DTDdescr

-- | convert a DTD descr into XmlTrees
dtdDescrToXml :: DTDdescr -> XmlTrees
checkAttrModell :: Name -> Schemas -> XmlTrees
checkAM :: Name -> Schema -> XmlTrees
checkAMC :: Name -> Name -> Schema -> XmlTrees
checkContentModell :: Name -> Schema -> XmlTrees
scContToXml :: Schema -> (Attributes, XmlTrees)
scWrap :: Schema -> Schema
scCont :: Attributes -> Schema -> XmlTrees
scConts :: Attributes -> Schemas -> XmlTrees
scAttrToXml :: Schema -> (Attributes, XmlTrees)
checkErr :: Bool -> String -> XmlTrees
foundErr :: String -> XmlTrees

-- | convert a pickler schema into a DTD descr
dtdDescr :: Schema -> DTDdescr
elementDeclarations :: Schema -> Schemas
elementDecs :: Schemas -> Schemas -> Schemas
elemNames :: Schemas -> [Name]
elemName :: Schema -> Maybe Name
elemRefs :: Schemas -> Schemas
attrDec :: Schema -> [(Name, Schemas)]
remAttrDec :: Schema -> Schema
instance Show DTDdescr


-- | The list arrow class
--   
--   This module defines the interface for list arrows.
--   
--   A list arrow is a function, that gives a list of results for a given
--   argument. A single element result represents a normal function. An
--   empty list oven indicates, the function is undefined for the given
--   argument. The empty list may also represent False, none empty lists
--   True. A list with more than one element gives all results for a
--   nondeterministic function.
module Control.Arrow.ArrowList

-- | The interface for list arrows
--   
--   Only <tt>mkA</tt>, <a>isA</a> '(&gt;&gt;.)' don't have default
--   implementations
class (Arrow a, ArrowPlus a, ArrowZero a, ArrowApply a) => ArrowList a
arr2 :: ArrowList a => (b1 -> b2 -> c) -> a (b1, b2) c
arr3 :: ArrowList a => (b1 -> b2 -> b3 -> c) -> a (b1, (b2, b3)) c
arr4 :: ArrowList a => (b1 -> b2 -> b3 -> b4 -> c) -> a (b1, (b2, (b3, b4))) c
arr2A :: ArrowList a => (b -> a c d) -> a (b, c) d
arrL :: ArrowList a => (b -> [c]) -> a b c
arr2L :: ArrowList a => (b -> c -> [d]) -> a (b, c) d
constA :: ArrowList a => c -> a b c
constL :: ArrowList a => [c] -> a b c
isA :: ArrowList a => (b -> Bool) -> a b b
(>>.) :: ArrowList a => a b c -> ([c] -> [d]) -> a b d
(>.) :: ArrowList a => a b c -> ([c] -> d) -> a b d
listA :: ArrowList a => a b c -> a b [c]
unlistA :: ArrowList a => a [b] b
this :: ArrowList a => a b b
none :: ArrowList a => a b c
withDefault :: ArrowList a => a b c -> c -> a b c
single :: ArrowList a => a b c -> a b c
applyA :: ArrowList a => a b (a b c) -> a b c
($<) :: ArrowList a => (c -> a b d) -> a b c -> a b d
($<<) :: ArrowList a => (c1 -> c2 -> a b d) -> a b (c1, c2) -> a b d
($<<<) :: ArrowList a => (c1 -> c2 -> c3 -> a b d) -> a b (c1, (c2, c3)) -> a b d
($<<<<) :: ArrowList a => (c1 -> c2 -> c3 -> c4 -> a b d) -> a b (c1, (c2, (c3, c4))) -> a b d
($<$) :: ArrowList a => (c -> (a b b)) -> a b c -> a b b
mergeA :: ArrowList a => (a (a1, b1) a1 -> a (a1, b1) b1 -> a (a1, b1) c) -> a (a1, b1) c
perform :: ArrowList a => a b c -> a b b
catA :: ArrowList a => [a b c] -> a b c
seqA :: ArrowList a => [a b b] -> a b b


-- | Arrows for evaluation of normal form results
module Control.Arrow.ArrowNF

-- | complete evaluation of an arrow result using <tt>Control.DeepSeq</tt>
--   
--   this is sometimes useful for preventing space leaks, especially after
--   reading and validation of a document, all DTD stuff is not longer in
--   use and can be recycled by the GC.
strictA :: (Arrow a, NFData b) => a b b
class Arrow a => ArrowNF a
rnfA :: (ArrowNF a, NFData c) => a b c -> a b c

-- | partial evaluation of an arrow result using <tt>Control.FlatSeq</tt>
--   
--   There are tow arrows with force the partial evaluation. By convention
--   the 2. should be less lazy than the 1.
--   
--   These arrows are sometimes useful for preventing space leaks,
--   especially when parsing complex data structures. In many cases the
--   evaluated AST is more space efficient than the unevaluaded with a lot
--   of closures.
class (Arrow a, ArrowList a) => ArrowWNF a
rwnfA :: (ArrowWNF a, WNFData c) => a b c -> a b c
rwnf2A :: (ArrowWNF a, WNFData c) => a b c -> a b c


-- | Conditionals for List Arrows
--   
--   This module defines conditional combinators for list arrows.
--   
--   The empty list as result represents False, none empty lists True.
module Control.Arrow.ArrowIf

-- | The interface for arrows as conditionals.
--   
--   Requires list arrows because False is represented as empty list, True
--   as none empty lists.
--   
--   Only <a>ifA</a> and <a>orElse</a> don't have default implementations
class ArrowList a => ArrowIf a
ifA :: ArrowIf a => a b c -> a b d -> a b d -> a b d
ifP :: ArrowIf a => (b -> Bool) -> a b d -> a b d -> a b d
neg :: ArrowIf a => a b c -> a b b
when :: ArrowIf a => a b b -> a b c -> a b b
whenP :: ArrowIf a => a b b -> (b -> Bool) -> a b b
whenNot :: ArrowIf a => a b b -> a b c -> a b b
whenNotP :: ArrowIf a => a b b -> (b -> Bool) -> a b b
guards :: ArrowIf a => a b c -> a b d -> a b d
guardsP :: ArrowIf a => (b -> Bool) -> a b d -> a b d
filterA :: ArrowIf a => a b c -> a b b
containing :: ArrowIf a => a b c -> a c d -> a b c
notContaining :: ArrowIf a => a b c -> a c d -> a b c
orElse :: ArrowIf a => a b c -> a b c -> a b c
choiceA :: ArrowIf a => [IfThen (a b c) (a b d)] -> a b d
tagA :: ArrowIf a => a b c -> a b (Either b b)
spanA :: ArrowIf a => a b b -> a [b] ([b], [b])
partitionA :: ArrowIf a => a b b -> a [b] ([b], [b])

-- | an auxiliary data type for <a>choiceA</a>
data IfThen a b
(:->) :: a -> b -> IfThen a b


-- | List arrows for navigatable trees
--   
--   Trees that implement the <a>Data.Tree.NavigatableTree.Class</a>
--   interface, can be processed with these arrows.
module Control.Arrow.ArrowNavigatableTree

-- | The interface for navigatable tree arrows
--   
--   all functions have default implementations
class ArrowList a => ArrowNavigatableTree a
moveUp :: (ArrowNavigatableTree a, NavigatableTree t) => a (t b) (t b)
moveDown :: (ArrowNavigatableTree a, NavigatableTree t) => a (t b) (t b)
moveLeft :: (ArrowNavigatableTree a, NavigatableTree t) => a (t b) (t b)
moveRight :: (ArrowNavigatableTree a, NavigatableTree t) => a (t b) (t b)
parentAxis :: (ArrowList a, NavigatableTree t) => a (t b) (t b)

-- | XPath axis: ancestor
ancestorAxis :: (ArrowList a, NavigatableTree t) => a (t b) (t b)

-- | XPath axis: ancestor or self
ancestorOrSelfAxis :: (ArrowList a, NavigatableTree t) => a (t b) (t b)

-- | XPath axis: child
childAxis :: (ArrowList a, NavigatableTree t) => a (t b) (t b)

-- | XPath axis: descendant
descendantAxis :: (ArrowList a, NavigatableTree t) => a (t b) (t b)

-- | XPath axis: descendant or self
descendantOrSelfAxis :: (ArrowList a, NavigatableTree t) => a (t b) (t b)

-- | not an XPath axis but useful: descendant or following
descendantOrFollowingAxis :: (ArrowList a, NavigatableTree t) => a (t b) (t b)

-- | not an official XPath axis but useful: reverse descendant or self,
--   used in preceding axis
revDescendantOrSelfAxis :: (ArrowList a, NavigatableTree t) => a (t b) (t b)

-- | XPath axis: following sibling
followingSiblingAxis :: (ArrowList a, NavigatableTree t) => a (t b) (t b)

-- | XPath axis: preceeding sibling
precedingSiblingAxis :: (ArrowList a, NavigatableTree t) => a (t b) (t b)

-- | XPath axis: self
selfAxis :: (ArrowList a, NavigatableTree t) => a (t b) (t b)

-- | XPath axis: following
followingAxis :: (ArrowList a, NavigatableTree t) => a (t b) (t b)

-- | XPath axis: preceding
precedingAxis :: (ArrowList a, NavigatableTree t) => a (t b) (t b)

-- | move to the root
moveToRoot :: (Arrow a, NavigatableTree t) => a (t b) (t b)
isAtRoot :: (ArrowList a, NavigatableTree t) => a (t b) (t b)

-- | Conversion from a tree into a navigatable tree
addNav :: (ArrowList a, NavigatableTreeToTree nt t) => a (t b) (nt b)

-- | Conversion from a navigatable tree into an ordinary tree
remNav :: (ArrowList a, NavigatableTreeToTree nt t) => a (nt b) (t b)

-- | apply an operation using navigation to an ordinary tree
--   
--   This root and all children may be visited in arbitrary order
withNav :: (ArrowList a, NavigatableTreeToTree nt t) => a (nt b) (nt c) -> a (t b) (t c)

-- | apply a simple operation without use of navigation to a navigatable
--   tree
--   
--   This enables to apply arbitrary tree operations to navigatable trees
withoutNav :: (ArrowList a, NavigatableTreeToTree nt t, NavigatableTreeModify nt t) => a (t b) (t b) -> a (nt b) (nt b)

-- | Filter an axis with an ordinary tree predicate
--   
--   Example: In a tree of Ints find all nodes in the subtrees (in
--   preorder) that have label 42
--   
--   <pre>
--   descendantAxis &gt;&gt;&gt; filterAxis (hasNode (== 42))
--   </pre>
--   
--   Example: In an XML Tree find the following nodes of a node with
--   attribute id and value 42
--   
--   <pre>
--   descendantAxis &gt;&gt;&gt; filterAxis (hasAttrValue "id" (=="42")) &gt;&gt;&gt; followingAxis
--   </pre>
filterAxis :: (ArrowIf a, NavigatableTreeToTree nt t) => a (t b) c -> a (nt b) (nt b)

-- | Move to the next tree on a given axis. Deterministic arrow
--   
--   Example: Move to the next node in a preorder visit: next child or else
--   next following
--   
--   <pre>
--   moveOn descendantOrFollowingAxis
--   </pre>
moveOn :: (ArrowList a, NavigatableTree t) => a (t b) (t b) -> a (t b) (t b)

-- | Change the current subtree of a navigatable tree.
--   
--   The arrow for computing the changes should be deterministic. If it
--   fails nothing is changed.
changeThisTree :: (ArrowList a, ArrowIf a, NavigatableTreeToTree nt t, NavigatableTreeModify nt t) => a (t b) (t b) -> a (nt b) (nt b)

-- | Substitute the current subtree of a navigatable tree by a given tree
substThisTree :: (ArrowList a, ArrowIf a, NavigatableTreeToTree nt t, NavigatableTreeModify nt t) => t b -> a (nt b) (nt b)

-- | apply an ordinary arrow to the current subtree of a navigatabe tree
--   and add the result trees in front of the current tree.
--   
--   If this arrow is applied to the root, it will fail, because we want a
--   tree as result, not a forest.
addToTheLeft :: (ArrowList a, NavigatableTreeToTree nt t, NavigatableTreeModify nt t) => a (t b) (t b) -> a (nt b) (nt b)

-- | apply an ordinary arrow to the current subtree of a navigatabe tree
--   and add the result trees behind the current tree.
--   
--   If this arrow is applied to the root, it will fail, because we want a
--   tree as result, not a forest.
addToTheRight :: (ArrowList a, NavigatableTreeToTree nt t, NavigatableTreeModify nt t) => a (t b) (t b) -> a (nt b) (nt b)

-- | addToOneSide does the real work for <a>addToTheLeft</a> and
--   <a>addToTheRight</a>
addToOneSide :: (ArrowList a, NavigatableTreeToTree nt t, NavigatableTreeModify nt t) => (Maybe (nt b) -> [t b] -> Maybe (nt b)) -> a (t b) (t b) -> a (nt b) (nt b)

-- | drop the direct left sibling tree of the given navigatable tree
--   
--   If this arrow is applied to the root or a leftmost tree, it will fail,
--   because there is nothing to remove
dropFromTheLeft :: (ArrowList a, NavigatableTreeModify nt t) => a (nt b) (nt b)

-- | drop the direct left sibling tree of the given navigatable tree
--   
--   If this arrow is applied to the root or a rightmost tree, it will
--   fail, because there is nothing to remove
dropFromTheRight :: (ArrowList a, NavigatableTreeModify nt t) => a (nt b) (nt b)


-- | List arrows for tree processing.
--   
--   Trees that implement the <a>Data.Tree.Class</a> interface, can be
--   processed with these arrows.
module Control.Arrow.ArrowTree

-- | The interface for tree arrows
--   
--   all functions have default implementations
class (ArrowPlus a, ArrowIf a) => ArrowTree a
mkLeaf :: (ArrowTree a, Tree t) => b -> a c (t b)
mkTree :: (ArrowTree a, Tree t) => b -> [t b] -> a c (t b)
getChildren :: (ArrowTree a, Tree t) => a (t b) (t b)
getNode :: (ArrowTree a, Tree t) => a (t b) b
hasNode :: (ArrowTree a, Tree t) => (b -> Bool) -> a (t b) (t b)
setChildren :: (ArrowTree a, Tree t) => [t b] -> a (t b) (t b)
setNode :: (ArrowTree a, Tree t) => b -> a (t b) (t b)
changeChildren :: (ArrowTree a, Tree t) => ([t b] -> [t b]) -> a (t b) (t b)
changeNode :: (ArrowTree a, Tree t) => (b -> b) -> a (t b) (t b)
processChildren :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b)
replaceChildren :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b)
(/>) :: (ArrowTree a, Tree t) => a b (t c) -> a (t c) d -> a b d
(//>) :: (ArrowTree a, Tree t) => a b (t c) -> a (t c) d -> a b d
(</) :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b) -> a (t b) (t b)
deep :: (ArrowTree a, Tree t) => a (t b) c -> a (t b) c
deepest :: (ArrowTree a, Tree t) => a (t b) c -> a (t b) c
multi :: (ArrowTree a, Tree t) => a (t b) c -> a (t b) c
processBottomUp :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b)
processTopDown :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b)
processBottomUpWhenNot :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b) -> a (t b) (t b)
processTopDownUntil :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b)
insertChildrenAt :: (ArrowTree a, Tree t) => Int -> a (t b) (t b) -> a (t b) (t b)
insertChildrenAfter :: (ArrowTree a, Tree t) => a (t b) (t b) -> a (t b) (t b) -> a (t b) (t b)
insertTreeTemplate :: (ArrowTree a, Tree t) => a (t b) (t b) -> [IfThen (a (t b) c) (a (t b) (t b))] -> a (t b) (t b)

-- | The interface for trees
class Tree t


-- | Implementation of pure list arrows
module Control.Arrow.ListArrow

-- | pure list arrow data type
newtype LA a b
LA :: (a -> [b]) -> LA a b
runLA :: LA a b -> a -> [b]

-- | conversion of pure list arrows into other possibly more complex list
--   arrows
fromLA :: ArrowList a => LA b c -> a b c
instance ArrowWNF LA
instance ArrowNF LA
instance ArrowNavigatableTree LA
instance ArrowTree LA
instance ArrowIf LA
instance ArrowList LA
instance ArrowApply LA
instance ArrowChoice LA
instance ArrowPlus LA
instance ArrowZero LA
instance Arrow LA
instance Category LA


-- | Implementation of list arrows with a state
module Control.Arrow.StateListArrow

-- | list arrow combined with a state
newtype SLA s a b
SLA :: (s -> a -> (s, [b])) -> SLA s a b
runSLA :: SLA s a b -> s -> a -> (s, [b])

-- | conversion of state list arrows into arbitray other list arrows.
--   
--   allows running a state list arrow within another arrow:
--   
--   example:
--   
--   <pre>
--   ... &gt;&gt;&gt; fromSLA 0 (... setState ... getState ... ) &gt;&gt;&gt; ...
--   </pre>
--   
--   runs a state arrow with initial state 0 (e..g. an Int) within another
--   arrow sequence
fromSLA :: ArrowList a => s -> SLA s b c -> a b c
instance ArrowWNF (SLA s)
instance ArrowNF (SLA s)
instance ArrowNavigatableTree (SLA s)
instance ArrowTree (SLA s)
instance ArrowState s (SLA s)
instance ArrowIf (SLA s)
instance ArrowList (SLA s)
instance ArrowApply (SLA s)
instance ArrowChoice (SLA s)
instance ArrowPlus (SLA s)
instance ArrowZero (SLA s)
instance Arrow (SLA s)
instance Category (SLA s)


-- | arrows for efficient editing of rose trees
module Control.Arrow.NTreeEdit

-- | Edit parts of a rose tree
--   
--   The subtrees to be modified are selected by the first part of the
--   IfThen pairs The modification by the second part
editNTreeA :: [IfThen (LA (NTree b) c) (LA (NTree b) (NTree b))] -> LA (NTree b) (NTree b)
fmapNTreeA :: (b -> Maybe b) -> LA (NTree b) (NTree b)


-- | Lifting of IO actions to arrows
module Control.Arrow.ArrowIO

-- | the interface for converting an IO action into an arrow
class Arrow a => ArrowIO a
arrIO :: ArrowIO a => (b -> IO c) -> a b c
arrIO0 :: ArrowIO a => IO c -> a b c
arrIO2 :: ArrowIO a => (b1 -> b2 -> IO c) -> a (b1, b2) c
arrIO3 :: ArrowIO a => (b1 -> b2 -> b3 -> IO c) -> a (b1, (b2, b3)) c
arrIO4 :: ArrowIO a => (b1 -> b2 -> b3 -> b4 -> IO c) -> a (b1, (b2, (b3, b4))) c

-- | the interface for converting an IO predicate into a list arrow
class (Arrow a, ArrowIO a) => ArrowIOIf a
isIOA :: ArrowIOIf a => (b -> IO Bool) -> a b b


-- | The exception arrow class
module Control.Arrow.ArrowExc
class (Arrow a, ArrowChoice a, ArrowZero a, ArrowIO a) => ArrowExc a
tryA :: ArrowExc a => a b c -> a b (Either SomeException c)
catchA :: ArrowExc a => a b c -> a SomeException c -> a b c


-- | Implementation of pure list arrows with IO
module Control.Arrow.IOListArrow

-- | list arrow combined with IO monad
newtype IOLA a b
IOLA :: (a -> IO [b]) -> IOLA a b
runIOLA :: IOLA a b -> a -> IO [b]
instance ArrowWNF IOLA
instance ArrowNF IOLA
instance ArrowNavigatableTree IOLA
instance ArrowTree IOLA
instance ArrowIOIf IOLA
instance ArrowExc IOLA
instance ArrowIO IOLA
instance ArrowIf IOLA
instance ArrowList IOLA
instance ArrowApply IOLA
instance ArrowChoice IOLA
instance ArrowPlus IOLA
instance ArrowZero IOLA
instance Arrow IOLA
instance Category IOLA


-- | Implementation of arrows with IO and a state
module Control.Arrow.IOStateListArrow

-- | list arrow combined with a state and the IO monad
newtype IOSLA s a b
IOSLA :: (s -> a -> IO (s, [b])) -> IOSLA s a b
runIOSLA :: IOSLA s a b -> s -> a -> IO (s, [b])

-- | lift the state of an IOSLA arrow to a state with an additional
--   component.
--   
--   This is uesful, when running predefined IO arrows, e.g. for document
--   input, in a context with a more complex state component.
liftSt :: IOSLA s1 b c -> IOSLA (s1, s2) b c

-- | run an arrow with augmented state in the context of a simple state
--   arrow. An initial value for the new state component is needed.
--   
--   This is useful, when running an arrow with an extra environment
--   component, e.g. for namespace handling in XML.
runSt :: s2 -> IOSLA (s1, s2) b c -> IOSLA s1 b c
instance ArrowWNF (IOSLA s)
instance ArrowNF (IOSLA s)
instance ArrowNavigatableTree (IOSLA s)
instance ArrowTree (IOSLA s)
instance ArrowState s (IOSLA s)
instance ArrowIOIf (IOSLA s)
instance ArrowExc (IOSLA s)
instance ArrowIO (IOSLA s)
instance ArrowIf (IOSLA s)
instance ArrowList (IOSLA s)
instance ArrowApply (IOSLA s)
instance ArrowChoice (IOSLA s)
instance ArrowPlus (IOSLA s)
instance ArrowZero (IOSLA s)
instance Arrow (IOSLA s)
instance Category (IOSLA s)


-- | the basic state arrows for XML processing
--   
--   A state is needed for global processing options, like encoding
--   options, document base URI, trace levels and error message handling
--   
--   The state is separated into a user defined state and a system state.
--   The system state contains variables for error message handling, for
--   tracing, for the document base for accessing XML documents with
--   relative references, e.g. DTDs, and a global key value store. This
--   assoc list has strings as keys and lists of XmlTrees as values. It is
--   used to store arbitrary XML and text values, e.g. user defined global
--   options.
--   
--   The user defined part of the store is in the default case empty,
--   defined as (). It can be extended with an arbitray data type
module Text.XML.HXT.Arrow.XmlState.TypeDefs

-- | state datatype consists of a system state and a user state the user
--   state is not fixed
data XIOState us
XIOState :: !XIOSysState -> !us -> XIOState us
xioSysState :: XIOState us -> !XIOSysState
xioUserState :: XIOState us -> !us

-- | The arrow type for stateful arrows
type IOStateArrow s b c = IOSLA (XIOState s) b c

-- | The arrow for stateful arrows with no user defined state
type IOSArrow b c = IOStateArrow () b c

-- | read the user defined part of the state
getUserState :: IOStateArrow s b s

-- | change the user defined part of the state
changeUserState :: (b -> s -> s) -> IOStateArrow s b b

-- | set the user defined part of the state
setUserState :: IOStateArrow s s s

-- | extend user state
--   
--   Run an arrow with an extended user state component, The old component
--   is stored together with a new one in a pair, the arrow is executed
--   with this extended state, and the augmented state component is removed
--   form the state when the arrow has finished its execution
withExtendedUserState :: s1 -> IOStateArrow (s1, s0) b c -> IOStateArrow s0 b c

-- | change the type of user state
--   
--   This conversion is useful, when running a state arrow with another
--   structure of the user state, e.g. with () when executing some IO
--   arrows
withOtherUserState :: s1 -> IOStateArrow s1 b c -> IOStateArrow s0 b c
withoutUserState :: IOSArrow b c -> IOStateArrow s0 b c

-- | predefined system state data type with all components for the system
--   functions, like trace, error handling, ...
data XIOSysState
XIOSys :: !XIOSysWriter -> !XIOSysEnv -> XIOSysState
xioSysWriter :: XIOSysState -> !XIOSysWriter
xioSysEnv :: XIOSysState -> !XIOSysEnv
data XIOSysWriter
XIOwrt :: !Int -> !XmlTrees -> IOSArrow XmlTree XmlTree -> !Int -> !Int -> AssocList String XmlTrees -> XIOSysWriter
xioErrorStatus :: XIOSysWriter -> !Int
xioErrorMsgList :: XIOSysWriter -> !XmlTrees
xioExpatErrors :: XIOSysWriter -> IOSArrow XmlTree XmlTree
xioRelaxNoOfErrors :: XIOSysWriter -> !Int
xioRelaxDefineId :: XIOSysWriter -> !Int
xioRelaxAttrList :: XIOSysWriter -> AssocList String XmlTrees
data XIOSysEnv
XIOEnv :: !Int -> (Int -> String -> IO ()) -> (String -> IO ()) -> !Bool -> !String -> !String -> !Attributes -> !XIOInputConfig -> !XIOParseConfig -> !XIOOutputConfig -> !XIORelaxConfig -> !XIOCacheConfig -> XIOSysEnv
xioTraceLevel :: XIOSysEnv -> !Int
xioTraceCmd :: XIOSysEnv -> Int -> String -> IO ()
xioErrorMsgHandler :: XIOSysEnv -> String -> IO ()
xioErrorMsgCollect :: XIOSysEnv -> !Bool
xioBaseURI :: XIOSysEnv -> !String
xioDefaultBaseURI :: XIOSysEnv -> !String
xioAttrList :: XIOSysEnv -> !Attributes
xioInputConfig :: XIOSysEnv -> !XIOInputConfig
xioParseConfig :: XIOSysEnv -> !XIOParseConfig
xioOutputConfig :: XIOSysEnv -> !XIOOutputConfig
xioRelaxConfig :: XIOSysEnv -> !XIORelaxConfig
xioCacheConfig :: XIOSysEnv -> !XIOCacheConfig
data XIOInputConfig
XIOIcgf :: !Bool -> !Bool -> String -> IOSArrow XmlTree XmlTree -> !Attributes -> !Bool -> String -> XIOInputConfig
xioStrictInput :: XIOInputConfig -> !Bool
xioEncodingErrors :: XIOInputConfig -> !Bool
xioInputEncoding :: XIOInputConfig -> String
xioHttpHandler :: XIOInputConfig -> IOSArrow XmlTree XmlTree
xioInputOptions :: XIOInputConfig -> !Attributes
xioRedirect :: XIOInputConfig -> !Bool
xioProxy :: XIOInputConfig -> String
data XIOParseConfig
XIOPcfg :: MimeTypeTable -> String -> [String] -> String -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> IOSArrow XmlTree XmlTree -> !Bool -> IOSArrow XmlTree XmlTree -> XIOParseConfig
xioMimeTypes :: XIOParseConfig -> MimeTypeTable
xioMimeTypeFile :: XIOParseConfig -> String
xioAcceptedMimeTypes :: XIOParseConfig -> [String]
xioFileMimeType :: XIOParseConfig -> String
xioWarnings :: XIOParseConfig -> !Bool
xioRemoveWS :: XIOParseConfig -> !Bool
xioParseByMimeType :: XIOParseConfig -> !Bool
xioParseHTML :: XIOParseConfig -> !Bool
xioLowerCaseNames :: XIOParseConfig -> !Bool
xioPreserveComment :: XIOParseConfig -> !Bool
xioValidate :: XIOParseConfig -> !Bool
xioSubstDTDEntities :: XIOParseConfig -> !Bool
xioSubstHTMLEntities :: XIOParseConfig -> !Bool
xioCheckNamespaces :: XIOParseConfig -> !Bool
xioCanonicalize :: XIOParseConfig -> !Bool
xioIgnoreNoneXmlContents :: XIOParseConfig -> !Bool
xioTagSoup :: XIOParseConfig -> !Bool
xioTagSoupParser :: XIOParseConfig -> IOSArrow XmlTree XmlTree
xioExpat :: XIOParseConfig -> !Bool
xioExpatParser :: XIOParseConfig -> IOSArrow XmlTree XmlTree
data XIOOutputConfig
XIOOcfg :: !Bool -> !String -> !XIOXoutConfig -> !Bool -> ![String] -> !Bool -> !Bool -> !Bool -> !Bool -> XIOOutputConfig
xioIndent :: XIOOutputConfig -> !Bool
xioOutputEncoding :: XIOOutputConfig -> !String
xioOutputFmt :: XIOOutputConfig -> !XIOXoutConfig
xioXmlPi :: XIOOutputConfig -> !Bool
xioNoEmptyElemFor :: XIOOutputConfig -> ![String]
xioAddDefaultDTD :: XIOOutputConfig -> !Bool
xioTextMode :: XIOOutputConfig -> !Bool
xioShowTree :: XIOOutputConfig -> !Bool
xioShowHaskell :: XIOOutputConfig -> !Bool
data XIOXoutConfig
XMLoutput :: XIOXoutConfig
XHTMLoutput :: XIOXoutConfig
HTMLoutput :: XIOXoutConfig
PLAINoutput :: XIOXoutConfig
data XIORelaxConfig
XIORxc :: !Bool -> String -> !Bool -> !Bool -> !Bool -> !Bool -> IOSArrow XmlTree XmlTree -> XIORelaxConfig
xioRelaxValidate :: XIORelaxConfig -> !Bool
xioRelaxSchema :: XIORelaxConfig -> String
xioRelaxCheckRestr :: XIORelaxConfig -> !Bool
xioRelaxValidateExtRef :: XIORelaxConfig -> !Bool
xioRelaxValidateInclude :: XIORelaxConfig -> !Bool
xioRelaxCollectErrors :: XIORelaxConfig -> !Bool
xioRelaxValidator :: XIORelaxConfig -> IOSArrow XmlTree XmlTree
data XIOCacheConfig
XIOCch :: CompressionFct -> DeCompressionFct -> !Bool -> !String -> !Int -> !Bool -> (String -> IOSArrow XmlTree XmlTree) -> !Bool -> XIOCacheConfig
xioBinaryCompression :: XIOCacheConfig -> CompressionFct
xioBinaryDeCompression :: XIOCacheConfig -> DeCompressionFct
xioWithCache :: XIOCacheConfig -> !Bool
xioCacheDir :: XIOCacheConfig -> !String
xioDocumentAge :: XIOCacheConfig -> !Int
xioCache404Err :: XIOCacheConfig -> !Bool
xioCacheRead :: XIOCacheConfig -> String -> IOSArrow XmlTree XmlTree
xioStrictDeserialize :: XIOCacheConfig -> !Bool
type CompressionFct = ByteString -> ByteString
type DeCompressionFct = ByteString -> ByteString
type SysConfig = XIOSysState -> XIOSysState
type SysConfigList = [SysConfig]
theSysState :: Selector (XIOState us) XIOSysState
theUserState :: Selector (XIOState us) us
theSysWriter :: Selector XIOSysState XIOSysWriter
theErrorStatus :: Selector XIOSysState Int
theErrorMsgList :: Selector XIOSysState XmlTrees
theRelaxNoOfErrors :: Selector XIOSysState Int
theRelaxDefineId :: Selector XIOSysState Int
theRelaxAttrList :: Selector XIOSysState (AssocList String XmlTrees)
theSysEnv :: Selector XIOSysState XIOSysEnv
theInputConfig :: Selector XIOSysState XIOInputConfig
theStrictInput :: Selector XIOSysState Bool
theEncodingErrors :: Selector XIOSysState Bool
theInputEncoding :: Selector XIOSysState String
theHttpHandler :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theInputOptions :: Selector XIOSysState Attributes
theRedirect :: Selector XIOSysState Bool
theProxy :: Selector XIOSysState String
theOutputConfig :: Selector XIOSysState XIOOutputConfig
theIndent :: Selector XIOSysState Bool
theOutputEncoding :: Selector XIOSysState String
theOutputFmt :: Selector XIOSysState XIOXoutConfig
theXmlPi :: Selector XIOSysState Bool
theNoEmptyElemFor :: Selector XIOSysState [String]
theAddDefaultDTD :: Selector XIOSysState Bool
theTextMode :: Selector XIOSysState Bool
theShowTree :: Selector XIOSysState Bool
theShowHaskell :: Selector XIOSysState Bool
theRelaxConfig :: Selector XIOSysState XIORelaxConfig
theRelaxValidate :: Selector XIOSysState Bool
theRelaxSchema :: Selector XIOSysState String
theRelaxCheckRestr :: Selector XIOSysState Bool
theRelaxValidateExtRef :: Selector XIOSysState Bool
theRelaxValidateInclude :: Selector XIOSysState Bool
theRelaxCollectErrors :: Selector XIOSysState Bool
theRelaxValidator :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theParseConfig :: Selector XIOSysState XIOParseConfig
theErrorMsgHandler :: Selector XIOSysState (String -> IO ())
theErrorMsgCollect :: Selector XIOSysState Bool
theBaseURI :: Selector XIOSysState String
theDefaultBaseURI :: Selector XIOSysState String
theTraceLevel :: Selector XIOSysState Int
theTraceCmd :: Selector XIOSysState (Int -> String -> IO ())
theTrace :: Selector XIOSysState (Int, Int -> String -> IO ())
theAttrList :: Selector XIOSysState Attributes
theMimeTypes :: Selector XIOSysState MimeTypeTable
theMimeTypeFile :: Selector XIOSysState String
theAcceptedMimeTypes :: Selector XIOSysState [String]
theFileMimeType :: Selector XIOSysState String
theWarnings :: Selector XIOSysState Bool
theRemoveWS :: Selector XIOSysState Bool
thePreserveComment :: Selector XIOSysState Bool
theParseByMimeType :: Selector XIOSysState Bool
theParseHTML :: Selector XIOSysState Bool
theLowerCaseNames :: Selector XIOSysState Bool
theValidate :: Selector XIOSysState Bool
theSubstDTDEntities :: Selector XIOSysState Bool
theSubstHTMLEntities :: Selector XIOSysState Bool
theCheckNamespaces :: Selector XIOSysState Bool
theCanonicalize :: Selector XIOSysState Bool
theIgnoreNoneXmlContents :: Selector XIOSysState Bool
theTagSoup :: Selector XIOSysState Bool
theTagSoupParser :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theExpat :: Selector XIOSysState Bool
theExpatParser :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theExpatErrors :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theCacheConfig :: Selector XIOSysState XIOCacheConfig
theBinaryCompression :: Selector XIOSysState (ByteString -> ByteString)
theBinaryDeCompression :: Selector XIOSysState (ByteString -> ByteString)
theWithCache :: Selector XIOSysState Bool
theCacheDir :: Selector XIOSysState String
theDocumentAge :: Selector XIOSysState Int
theCache404Err :: Selector XIOSysState Bool
theCacheRead :: Selector XIOSysState (String -> IOSArrow XmlTree XmlTree)
theStrictDeserialize :: Selector XIOSysState Bool
getSysVar :: Selector XIOSysState c -> IOStateArrow s b c
setSysVar :: Selector XIOSysState c -> IOStateArrow s c c
chgSysVar :: Selector XIOSysState c -> (b -> c -> c) -> IOStateArrow s b b
configSysVar :: SysConfig -> IOStateArrow s c c
configSysVars :: SysConfigList -> IOStateArrow s c c
localSysVar :: Selector XIOSysState c -> IOStateArrow s a b -> IOStateArrow s a b
localSysEnv :: IOStateArrow s a b -> IOStateArrow s a b
incrSysVar :: Selector XIOSysState Int -> IOStateArrow s a Int

-- | store a string in global state under a given attribute name
setSysAttr :: String -> IOStateArrow s String String

-- | remove an entry in global state, arrow input remains unchanged
unsetSysAttr :: String -> IOStateArrow s b b

-- | read an attribute value from global state
getSysAttr :: String -> IOStateArrow s b String

-- | read all attributes from global state
getAllSysAttrs :: IOStateArrow s b Attributes
setSysAttrString :: String -> String -> IOStateArrow s b b

-- | store an int value in global state
setSysAttrInt :: String -> Int -> IOStateArrow s b b

-- | read an int value from global state
--   
--   <pre>
--   getSysAttrInt 0 myIntAttr
--   </pre>
getSysAttrInt :: Int -> String -> IOStateArrow s b Int
toInt :: Int -> String -> Int

-- | A Selector is a pair of an access function and a modifying function
--   for reading and updating parts of a composite type
data Selector s a
S :: (s -> a) -> (a -> s -> s) -> Selector s a
getS :: Selector s a -> s -> a
setS :: Selector s a -> a -> s -> s
chgS :: Selector s a -> (a -> a) -> (s -> s)
idS :: Selector s s
(.&&&.) :: Selector s a -> Selector s b -> Selector s (a, b)
instance Eq XIOXoutConfig
instance NFData XIOSysState
instance NFData us => NFData (XIOState us)


-- | the mime type configuration functions
module Text.XML.HXT.Arrow.XmlState.MimeTypeTable

-- | set the table mapping of file extensions to mime types in the system
--   state
--   
--   Default table is defined in
--   <tt>Text.XML.HXT.DOM.MimeTypeDefaults</tt>. This table is used when
--   reading loacl files, (file: protocol) to determine the mime type
setMimeTypeTable :: MimeTypeTable -> IOStateArrow s b b

-- | set the table mapping of file extensions to mime types by an external
--   config file
--   
--   The config file must follow the conventions of <i>etc</i>mime.types on
--   a debian linux system, that means all empty lines and all lines
--   starting with a # are ignored. The other lines must consist of a mime
--   type followed by a possible empty list of extensions. The list of
--   extenstions and mime types overwrites the default list in the system
--   state of the IOStateArrow
setMimeTypeTableFromFile :: FilePath -> IOStateArrow s b b

-- | read the system mimetype table
getMimeTypeTable :: IOStateArrow s b MimeTypeTable


-- | Basic arrows for processing XML documents
--   
--   All arrows use IO and a global state for options, errorhandling, ...
module Text.XML.HXT.Arrow.XmlArrow

-- | Arrows for processing <tt>Text.XML.HXT.DOM.TypeDefs.XmlTree</tt>s
--   
--   These arrows can be grouped into predicates, selectors, constructors,
--   and transformers.
--   
--   All predicates (tests) act like <tt>Control.Arrow.ArrowIf.none</tt>
--   for failure and <tt>Control.Arrow.ArrowIf.this</tt> for success. A
--   logical and can be formed by <tt> a1 &gt;&gt;&gt; a2 </tt>, a locical
--   or by <tt> a1 &lt;+&gt; a2 </tt>.
--   
--   Selector arrows will fail, when applied to wrong input, e.g. selecting
--   the text of a node with <a>getText</a> will fail when applied to a
--   none text node.
--   
--   Edit arrows will remain the input unchanged, when applied to wrong
--   argument, e.g. editing the content of a text node with
--   <a>changeText</a> applied to an element node will return the unchanged
--   element node.
class (Arrow a, ArrowList a, ArrowTree a) => ArrowXml a
isText :: ArrowXml a => a XmlTree XmlTree
isBlob :: ArrowXml a => a XmlTree XmlTree
isCharRef :: ArrowXml a => a XmlTree XmlTree
isEntityRef :: ArrowXml a => a XmlTree XmlTree
isCmt :: ArrowXml a => a XmlTree XmlTree
isCdata :: ArrowXml a => a XmlTree XmlTree
isPi :: ArrowXml a => a XmlTree XmlTree
isXmlPi :: ArrowXml a => a XmlTree XmlTree
isElem :: ArrowXml a => a XmlTree XmlTree
isDTD :: ArrowXml a => a XmlTree XmlTree
isAttr :: ArrowXml a => a XmlTree XmlTree
isError :: ArrowXml a => a XmlTree XmlTree
isRoot :: ArrowXml a => a XmlTree XmlTree
hasText :: ArrowXml a => (String -> Bool) -> a XmlTree XmlTree
isWhiteSpace :: ArrowXml a => a XmlTree XmlTree
hasNameWith :: ArrowXml a => (QName -> Bool) -> a XmlTree XmlTree
hasQName :: ArrowXml a => QName -> a XmlTree XmlTree
hasName :: ArrowXml a => String -> a XmlTree XmlTree
hasLocalPart :: ArrowXml a => String -> a XmlTree XmlTree
hasNamePrefix :: ArrowXml a => String -> a XmlTree XmlTree
hasNamespaceUri :: ArrowXml a => String -> a XmlTree XmlTree
hasAttr :: ArrowXml a => String -> a XmlTree XmlTree
hasQAttr :: ArrowXml a => QName -> a XmlTree XmlTree
hasAttrValue :: ArrowXml a => String -> (String -> Bool) -> a XmlTree XmlTree
hasQAttrValue :: ArrowXml a => QName -> (String -> Bool) -> a XmlTree XmlTree
mkText :: ArrowXml a => a String XmlTree
mkBlob :: ArrowXml a => a Blob XmlTree
mkCharRef :: ArrowXml a => a Int XmlTree
mkEntityRef :: ArrowXml a => a String XmlTree
mkCmt :: ArrowXml a => a String XmlTree
mkCdata :: ArrowXml a => a String XmlTree
mkError :: ArrowXml a => Int -> a String XmlTree
mkElement :: ArrowXml a => QName -> a n XmlTree -> a n XmlTree -> a n XmlTree
mkAttr :: ArrowXml a => QName -> a n XmlTree -> a n XmlTree
mkPi :: ArrowXml a => QName -> a n XmlTree -> a n XmlTree
mkqelem :: ArrowXml a => QName -> [a n XmlTree] -> [a n XmlTree] -> a n XmlTree
mkelem :: ArrowXml a => String -> [a n XmlTree] -> [a n XmlTree] -> a n XmlTree
aelem :: ArrowXml a => String -> [a n XmlTree] -> a n XmlTree
selem :: ArrowXml a => String -> [a n XmlTree] -> a n XmlTree
eelem :: ArrowXml a => String -> a n XmlTree
root :: ArrowXml a => [a n XmlTree] -> [a n XmlTree] -> a n XmlTree
qattr :: ArrowXml a => QName -> a n XmlTree -> a n XmlTree
attr :: ArrowXml a => String -> a n XmlTree -> a n XmlTree
txt :: ArrowXml a => String -> a n XmlTree
blb :: ArrowXml a => Blob -> a n XmlTree
charRef :: ArrowXml a => Int -> a n XmlTree
entityRef :: ArrowXml a => String -> a n XmlTree
cmt :: ArrowXml a => String -> a n XmlTree
warn :: ArrowXml a => String -> a n XmlTree
err :: ArrowXml a => String -> a n XmlTree
fatal :: ArrowXml a => String -> a n XmlTree
spi :: ArrowXml a => String -> String -> a n XmlTree
sqattr :: ArrowXml a => QName -> String -> a n XmlTree
sattr :: ArrowXml a => String -> String -> a n XmlTree
getText :: ArrowXml a => a XmlTree String
getCharRef :: ArrowXml a => a XmlTree Int
getEntityRef :: ArrowXml a => a XmlTree String
getCmt :: ArrowXml a => a XmlTree String
getCdata :: ArrowXml a => a XmlTree String
getPiName :: ArrowXml a => a XmlTree QName
getPiContent :: ArrowXml a => a XmlTree XmlTree
getElemName :: ArrowXml a => a XmlTree QName
getAttrl :: ArrowXml a => a XmlTree XmlTree
getDTDPart :: ArrowXml a => a XmlTree DTDElem
getDTDAttrl :: ArrowXml a => a XmlTree Attributes
getAttrName :: ArrowXml a => a XmlTree QName
getErrorLevel :: ArrowXml a => a XmlTree Int
getErrorMsg :: ArrowXml a => a XmlTree String
getQName :: ArrowXml a => a XmlTree QName
getName :: ArrowXml a => a XmlTree String
getUniversalName :: ArrowXml a => a XmlTree String
getUniversalUri :: ArrowXml a => a XmlTree String
getLocalPart :: ArrowXml a => a XmlTree String
getNamePrefix :: ArrowXml a => a XmlTree String
getNamespaceUri :: ArrowXml a => a XmlTree String
getAttrValue :: ArrowXml a => String -> a XmlTree String
getAttrValue0 :: ArrowXml a => String -> a XmlTree String
getQAttrValue :: ArrowXml a => QName -> a XmlTree String
getQAttrValue0 :: ArrowXml a => QName -> a XmlTree String
changeText :: ArrowXml a => (String -> String) -> a XmlTree XmlTree
changeBlob :: ArrowXml a => (Blob -> Blob) -> a XmlTree XmlTree
changeCmt :: ArrowXml a => (String -> String) -> a XmlTree XmlTree
changeQName :: ArrowXml a => (QName -> QName) -> a XmlTree XmlTree
changeElemName :: ArrowXml a => (QName -> QName) -> a XmlTree XmlTree
changeAttrName :: ArrowXml a => (QName -> QName) -> a XmlTree XmlTree
changePiName :: ArrowXml a => (QName -> QName) -> a XmlTree XmlTree
changeAttrValue :: ArrowXml a => (String -> String) -> a XmlTree XmlTree
changeAttrl :: ArrowXml a => (XmlTrees -> XmlTrees -> XmlTrees) -> a XmlTree XmlTree -> a XmlTree XmlTree
setQName :: ArrowXml a => QName -> a XmlTree XmlTree
setElemName :: ArrowXml a => QName -> a XmlTree XmlTree
setAttrName :: ArrowXml a => QName -> a XmlTree XmlTree
setPiName :: ArrowXml a => QName -> a XmlTree XmlTree
setAttrl :: ArrowXml a => a XmlTree XmlTree -> a XmlTree XmlTree
addAttrl :: ArrowXml a => a XmlTree XmlTree -> a XmlTree XmlTree
addAttr :: ArrowXml a => String -> String -> a XmlTree XmlTree
removeAttr :: ArrowXml a => String -> a XmlTree XmlTree
removeQAttr :: ArrowXml a => QName -> a XmlTree XmlTree
processAttrl :: ArrowXml a => a XmlTree XmlTree -> a XmlTree XmlTree
processTopDownWithAttrl :: ArrowXml a => a XmlTree XmlTree -> a XmlTree XmlTree
(+=) :: ArrowXml a => a b XmlTree -> a b XmlTree -> a b XmlTree
xshow :: ArrowXml a => a n XmlTree -> a n String
xshowBlob :: ArrowXml a => a n XmlTree -> a n Blob

-- | Document Type Definition arrows
--   
--   These are separated, because they are not needed for document
--   processing, only when processing the DTD, e.g. for generating access
--   funtions for the toolbox from a DTD (se example DTDtoHaskell in the
--   examples directory)
class ArrowXml a => ArrowDTD a
isDTDDoctype :: ArrowDTD a => a XmlTree XmlTree
isDTDElement :: ArrowDTD a => a XmlTree XmlTree
isDTDContent :: ArrowDTD a => a XmlTree XmlTree
isDTDAttlist :: ArrowDTD a => a XmlTree XmlTree
isDTDEntity :: ArrowDTD a => a XmlTree XmlTree
isDTDPEntity :: ArrowDTD a => a XmlTree XmlTree
isDTDNotation :: ArrowDTD a => a XmlTree XmlTree
isDTDCondSect :: ArrowDTD a => a XmlTree XmlTree
isDTDName :: ArrowDTD a => a XmlTree XmlTree
isDTDPERef :: ArrowDTD a => a XmlTree XmlTree
hasDTDAttr :: ArrowDTD a => String -> a XmlTree XmlTree
getDTDAttrValue :: ArrowDTD a => String -> a XmlTree String
setDTDAttrValue :: ArrowDTD a => String -> String -> a XmlTree XmlTree
mkDTDElem :: ArrowDTD a => DTDElem -> Attributes -> a n XmlTree -> a n XmlTree
mkDTDDoctype :: ArrowDTD a => Attributes -> a n XmlTree -> a n XmlTree
mkDTDElement :: ArrowDTD a => Attributes -> a n XmlTree
mkDTDEntity :: ArrowDTD a => Attributes -> a n XmlTree
mkDTDPEntity :: ArrowDTD a => Attributes -> a n XmlTree
instance ArrowDTD (IOSLA s)
instance ArrowDTD IOLA
instance ArrowDTD (SLA s)
instance ArrowDTD LA
instance ArrowXml (IOSLA s)
instance ArrowXml IOLA
instance ArrowXml (SLA s)
instance ArrowXml LA


-- | the basic state arrows for XML processing
--   
--   A state is needed for global processing options, like encoding
--   options, document base URI, trace levels and error message handling
--   
--   The state is separated into a user defined state and a system state.
--   The system state contains variables for error message handling, for
--   tracing, for the document base for accessing XML documents with
--   relative references, e.g. DTDs, and a global key value store. This
--   assoc list has strings as keys and lists of XmlTrees as values. It is
--   used to store arbitrary XML and text values, e.g. user defined global
--   options.
--   
--   The user defined part of the store is in the default case empty,
--   defined as (). It can be extended with an arbitray data type
module Text.XML.HXT.Arrow.XmlState.ErrorHandling
changeErrorStatus :: (Int -> Int -> Int) -> IOStateArrow s Int Int

-- | reset global error variable
clearErrStatus :: IOStateArrow s b b

-- | set global error variable
setErrStatus :: IOStateArrow s Int Int

-- | read current global error status
getErrStatus :: IOStateArrow s XmlTree Int

-- | raise the global error status level to that of the input tree
setErrMsgStatus :: IOStateArrow s XmlTree XmlTree

-- | set the error message handler and the flag for collecting the errors
setErrorMsgHandler :: Bool -> (String -> IO ()) -> IOStateArrow s b b

-- | error message handler for output to stderr
sysErrorMsg :: IOStateArrow s XmlTree XmlTree

-- | the default error message handler: error output to stderr
errorMsgStderr :: IOStateArrow s b b

-- | error message handler for collecting errors
errorMsgCollect :: IOStateArrow s b b

-- | error message handler for output to stderr and collecting
errorMsgStderrAndCollect :: IOStateArrow s b b

-- | error message handler for ignoring errors
errorMsgIgnore :: IOStateArrow s b b

-- | if error messages are collected by the error handler for processing
--   these messages by the calling application, this arrow reads the stored
--   messages and clears the error message store
getErrorMessages :: IOStateArrow s b XmlTree
addToErrorMsgList :: IOStateArrow s XmlTree XmlTree

-- | filter error messages from input trees and issue errors
filterErrorMsg :: IOStateArrow s XmlTree XmlTree

-- | generate a warnig message
issueWarn :: String -> IOStateArrow s b b

-- | generate an error message
issueErr :: String -> IOStateArrow s b b

-- | generate a fatal error message, e.g. document not found
issueFatal :: String -> IOStateArrow s b b

-- | Default exception handler: issue a fatal error message and fail.
--   
--   The parameter can be used to specify where the error occured
issueExc :: String -> IOStateArrow s SomeException b

-- | add the error level and the module where the error occured to the
--   attributes of a document root node and remove the children when level
--   is greater or equal to <a>c_err</a>. called by
--   <a>setDocumentStatusFromSystemState</a> when the system state
--   indicates an error
setDocumentStatus :: Int -> String -> IOStateArrow s XmlTree XmlTree

-- | check whether the error level attribute in the system state is set to
--   error, in this case the children of the document root are removed and
--   the module name where the error occured and the error level are added
--   as attributes with <a>setDocumentStatus</a> else nothing is changed
setDocumentStatusFromSystemState :: String -> IOStateArrow s XmlTree XmlTree

-- | check whether tree is a document root and the status attribute has a
--   value less than <a>c_err</a>
documentStatusOk :: ArrowXml a => a XmlTree XmlTree
errorOutputToStderr :: String -> IO ()


-- | system configuration and common options options
module Text.XML.HXT.Arrow.XmlState.SystemConfig

-- | <tt>withTace level</tt> : system option, set the trace level, (0..4)
withTrace :: Int -> SysConfig

-- | <tt>withSysAttr key value</tt> : store an arbitarty key value pair in
--   system state
withSysAttr :: String -> String -> SysConfig
withAcceptedMimeTypes :: [String] -> SysConfig

-- | <tt>withMimeTypeFile filename</tt> : input option, set the mime type
--   table for <tt>file:</tt> documents by given file. The format of this
--   config file must be in the syntax of a debian linux "mime.types"
--   config file
withMimeTypeFile :: String -> SysConfig

-- | Force a given mime type for all file contents.
--   
--   The mime type for file access will then not be computed by looking
--   into a mime.types file
withFileMimeType :: String -> SysConfig

-- | <tt>withWarnings yes/no</tt> : system option, issue warnings during
--   reading, HTML parsing and processing, default is <a>yes</a>
withWarnings :: Bool -> SysConfig

-- | <tt>withErrors yes/no</tt> : system option for suppressing error
--   messages, default is <a>no</a>
withErrors :: Bool -> SysConfig

-- | <tt>withRemoveWS yes/no</tt> : read and write option, remove all
--   whitespace, used for document indentation, default is <a>no</a>
withRemoveWS :: Bool -> SysConfig

-- | <tt>withPreserveComment yes/no</tt> : read option, preserve comments
--   during canonicalization, default is <a>no</a>
withPreserveComment :: Bool -> SysConfig

-- | <tt>withParseByMimeType yes/no</tt> : read option, select the parser
--   by the mime type of the document (pulled out of the HTTP header).
--   
--   When the mime type is set to "text/html" the configured HTML parser is
--   taken, when it's set to "text/xml" or "text/xhtml" the configured XML
--   parser is taken. If the mime type is something else, no further
--   processing is performed, the contents is given back to the application
--   in form of a single text node. If the default document encoding is set
--   to isoLatin1, this even enables processing of arbitray binary data.
withParseByMimeType :: Bool -> SysConfig

-- | <tt>withParseHTML yes/no</tt>: read option, use HTML parser, default
--   is <a>no</a> (use XML parser)
withParseHTML :: Bool -> SysConfig

-- | <tt>withValidate yes/no</tt>: read option, validate document against
--   DTD, default is <a>yes</a>
withValidate :: Bool -> SysConfig

-- | <tt>withSubstDTDEntities yes/no</tt>: read option, substitute general
--   entities defined in DTD, default is <a>yes</a>. switching this option
--   and the validate option off can lead to faster parsing, because then
--   there is no need to access the DTD
withSubstDTDEntities :: Bool -> SysConfig

-- | <tt>withSubstHTMLEntities yes/no</tt>: read option, substitute general
--   entities defined in HTML DTD, default is <a>no</a>. switching this
--   option on and the substDTDEntities and validate options off can lead
--   to faster parsing because there is no need to access a DTD, but still
--   the HTML general entities are substituted
withSubstHTMLEntities :: Bool -> SysConfig

-- | <tt>withCheckNamespaces yes/no</tt>: read option, check namespaces,
--   default is <a>no</a>
withCheckNamespaces :: Bool -> SysConfig

-- | <tt>withCanonicalize yes/no</tt> : read option, canonicalize document,
--   default is <a>yes</a>
withCanonicalize :: Bool -> SysConfig

-- | <tt>withIgnoreNoneXmlContents yes/no</tt> : input option, ignore
--   document contents of none XML/HTML documents.
--   
--   This option can be useful for implementing crawler like applications,
--   e.g. an URL checker. In those cases net traffic can be reduced.
withIgnoreNoneXmlContents :: Bool -> SysConfig

-- | <tt>withStrictInput yes/no</tt> : input option, input of file and HTTP
--   contents is read eagerly, default is <a>no</a>
withStrictInput :: Bool -> SysConfig

-- | <tt>withEncodingErrors yes/no</tt> : input option, ignore all encoding
--   errors, default is <a>no</a>
withEncodingErrors :: Bool -> SysConfig

-- | <tt>withInputEncoding encodingName</tt> : input option
--   
--   Set default document encoding (<a>utf8</a>, <a>isoLatin1</a>,
--   <a>usAscii</a>, <a>iso8859_2</a>, ... , <a>iso8859_16</a>, ...). Only
--   XML, HTML and text documents are decoded, default decoding for
--   XML/HTML is utf8, for text iso latin1 (no decoding).
withInputEncoding :: String -> SysConfig

-- | <tt>withDefaultBaseURI URI</tt> , input option, set the default base
--   URI
--   
--   This option can be useful when parsing documents from stdin or
--   contained in a string, and interpreting relative URIs within the
--   document
withDefaultBaseURI :: String -> SysConfig
withInputOption :: String -> String -> SysConfig
withInputOptions :: Attributes -> SysConfig

-- | <tt>withRedirect yes/no</tt> : input option, automatically follow
--   redirected URIs, default is <a>yes</a>
withRedirect :: Bool -> SysConfig

-- | <tt>withProxy "host:port"</tt> : input option, configure a proxy for
--   HTTP access, e.g. www-cache:3128
withProxy :: String -> SysConfig

-- | <tt>withIndent yes/no</tt> : output option, indent document before
--   output, default is <a>no</a>
withIndent :: Bool -> SysConfig

-- | <tt>withOutputEncoding encoding</tt> , output option, default is the
--   default input encoding or utf8, if input encoding is not set
withOutputEncoding :: String -> SysConfig

-- | <tt>withOutputXML</tt> : output option, default writing
--   
--   Default is writing XML: quote special XML chars &gt;,&lt;,",',&amp;
--   where neccessary, add XML processing instruction and encode document
--   with respect to <a>withOutputEncoding</a>
withOutputXML :: SysConfig

-- | Write XHTML: quote all special XML chars, use HTML entity refs or char
--   refs for none ASCII chars
withOutputHTML :: SysConfig

-- | Write XML: quote only special XML chars, don't substitute chars by
--   HTML entities, and don't generate empty elements for HTML elements,
--   which may contain any contents, e.g. <tt><a>script
--   src=...</a><a>/script</a></tt> instead of <tt><a>script src=...
--   /</a></tt>
withOutputXHTML :: SysConfig

-- | suppreses all char and entitiy substitution
withOutputPLAIN :: SysConfig
withXmlPi :: Bool -> SysConfig
withNoEmptyElemFor :: [String] -> SysConfig
withAddDefaultDTD :: Bool -> SysConfig
withTextMode :: Bool -> SysConfig
withShowTree :: Bool -> SysConfig
withShowHaskell :: Bool -> SysConfig

-- | Configure compression and decompression for binary
--   serialization/deserialization. First component is the compression
--   function applied after serialization, second the decompression applied
--   before deserialization.
withCompression :: (CompressionFct, DeCompressionFct) -> SysConfig

-- | Strict input for deserialization of binary data
withStrictDeserialize :: Bool -> SysConfig
yes :: Bool
no :: Bool


-- | system configuration and common options options
module Text.XML.HXT.Arrow.XmlOptions

-- | commonly useful options for XML input
--   
--   can be used for option definition with haskell getopt
--   
--   defines options: <a>a_trace</a>, <a>a_proxy</a>, <tt>a_use_curl</tt>,
--   <tt>a_do_not_use_curl</tt>, <tt>a_options_curl</tt>,
--   <a>a_encoding</a>, <a>a_issue_errors</a>,
--   <a>a_do_not_issue_errors</a>, <a>a_parse_html</a>,
--   <a>a_parse_by_mimetype</a>, <a>a_issue_warnings</a>,
--   <a>a_do_not_issue_warnings</a>, <a>a_parse_xml</a>, <a>a_validate</a>,
--   <a>a_do_not_validate</a>, <a>a_canonicalize</a>,
--   <a>a_do_not_canonicalize</a>,
inputOptions :: [OptDescr SysConfig]

-- | commonly useful options for XML output
--   
--   defines options: <a>a_indent</a>, <a>a_output_encoding</a>,
--   <a>a_output_html</a> and others
outputOptions :: [OptDescr SysConfig]

-- | commonly useful options
--   
--   defines options: <a>a_verbose</a>, <a>a_help</a>
generalOptions :: [OptDescr SysConfig]

-- | defines <a>a_version</a> option
versionOptions :: [OptDescr SysConfig]

-- | debug output options
showOptions :: [OptDescr SysConfig]
a_accept_mimetypes, a_verbose, a_validate, a_trace, a_text_mode, a_subst_html_entities, a_subst_dtd_entities, a_strict_input, a_show_tree, a_show_haskell, a_remove_whitespace, a_redirect, a_proxy, a_preserve_comment, a_parse_xml, a_parse_html, a_parse_by_mimetype, a_output_plain, a_output_xhtml, a_output_html, a_output_xml, a_output_file, a_no_xml_pi, a_no_redirect, a_no_empty_elem_for, a_no_empty_elements, a_mime_types, a_issue_warnings, a_issue_errors, a_indent, a_ignore_none_xml_contents, a_ignore_encoding_errors, a_if_unmodified_since, a_if_modified_since, a_help, a_error_log, a_error, a_do_not_validate, a_do_not_subst_html_entities, a_do_not_subst_dtd_entities, a_do_not_remove_whitespace, a_do_not_preserve_comment, a_do_not_issue_warnings, a_do_not_issue_errors, a_do_not_check_namespaces, a_do_not_canonicalize, a_default_baseuri, a_collect_errors, a_check_namespaces, a_canonicalize, a_add_default_dtd :: String

-- | select options from a predefined list of option desciptions
selectOptions :: [String] -> [OptDescr a] -> [OptDescr a]
removeOptions :: [String] -> [OptDescr a] -> [OptDescr a]


-- | interface to the HXT XML and DTD parsers
module Text.XML.HXT.Arrow.ParserInterface
parseXmlDoc :: ArrowXml a => a (String, String) XmlTree
parseXmlDTDPart :: ArrowXml a => a (String, XmlTree) XmlTree
parseXmlContent :: ArrowXml a => a String XmlTree
parseXmlEntityEncodingSpec, removeEncodingSpec, parseXmlDocEncodingSpec :: ArrowXml a => a XmlTree XmlTree
parseXmlDTDdeclPart :: ArrowXml a => a XmlTree XmlTree
parseXmlDTDdecl :: ArrowXml a => a XmlTree XmlTree
parseXmlDTDEntityValue :: ArrowXml a => a XmlTree XmlTree
parseXmlEntityValueAsContent :: ArrowXml a => String -> a XmlTree XmlTree
parseXmlEntityValueAsAttrValue :: ArrowXml a => String -> a XmlTree XmlTree
parseHtmlDoc :: ArrowList a => a (String, String) XmlTree
parseHtmlContent :: ArrowList a => a String XmlTree


-- | common edit arrows
module Text.XML.HXT.Arrow.Edit

-- | Applies some <a>Canonical XML</a> rules to a document tree.
--   
--   The rule differ slightly for canonical XML and XPath in handling of
--   comments
--   
--   Note: This is not the whole canonicalization as it is specified by the
--   W3C Recommendation. Adding attribute defaults or sorting attributes in
--   lexicographic order is done by the <tt>transform</tt> function of
--   module <tt>Text.XML.HXT.Validator.Validation</tt>. Replacing entities
--   or line feed normalization is done by the parser.
--   
--   Rules: remove DTD parts, processing instructions, comments and
--   substitute char refs in attribute values and text
--   
--   Not implemented yet:
--   
--   <ul>
--   <li>Whitespace within start and end tags is normalized</li>
--   <li>Special characters in attribute values and character content are
--   replaced by character references</li>
--   </ul>
canonicalizeAllNodes :: ArrowList a => a XmlTree XmlTree

-- | Canonicalize a tree for XPath Like <a>canonicalizeAllNodes</a> but
--   comment nodes are not removed
--   
--   see <a>canonicalizeAllNodes</a>
canonicalizeForXPath :: ArrowList a => a XmlTree XmlTree

-- | Canonicalize the contents of a document
--   
--   substitutes all char refs in text and attribute values, removes CDATA
--   section and combines all sequences of resulting text nodes into a
--   single text node
--   
--   see <a>canonicalizeAllNodes</a>
canonicalizeContents :: ArrowList a => a XmlTree XmlTree

-- | Applies collapseXText recursively.
--   
--   see also : <a>collapseXText</a>
collapseAllXText :: ArrowList a => a XmlTree XmlTree

-- | Collects sequences of text nodes in the list of children of a node
--   into one single text node. This is useful, e.g. after char and entity
--   reference substitution
collapseXText :: ArrowList a => a XmlTree XmlTree

-- | apply an arrow to the input and convert the resulting XML trees into
--   an XML escaped string
--   
--   This is a save variant for converting a tree into an XML string
--   representation that is parsable with
--   <tt>Text.XML.HXT.Arrow.ReadDocument</tt>. It is implemented with
--   <a>xshow</a>, but xshow does no XML escaping. The XML escaping is done
--   with <tt>Text.XML.HXT.Arrow.Edit.escapeXmlDoc</tt> before xshow is
--   applied.
--   
--   So the following law holds
--   
--   <pre>
--   xshowEscapeXml f &gt;&gt;&gt; xread == f
--   </pre>
xshowEscapeXml :: ArrowXml a => a n XmlTree -> a n String
escapeXmlRefs :: (Char -> String -> String, Char -> String -> String)
escapeHtmlRefs :: (Char -> String -> String, Char -> String -> String)

-- | convert a document into a Haskell representation (with show).
--   
--   Useful for debugging and trace output. see also :
--   <a>treeRepOfXmlDoc</a>, <a>numberLinesInXmlDoc</a>
haskellRepOfXmlDoc :: ArrowList a => a XmlTree XmlTree

-- | convert a document into a text representation in tree form.
--   
--   Useful for debugging and trace output. see also :
--   <a>haskellRepOfXmlDoc</a>, <a>numberLinesInXmlDoc</a>
treeRepOfXmlDoc :: ArrowList a => a XmlTree XmlTree
addHeadlineToXmlDoc :: ArrowXml a => a XmlTree XmlTree

-- | filter for indenting a document tree for pretty printing.
--   
--   the tree is traversed for inserting whitespace for tag indentation.
--   
--   whitespace is only inserted or changed at places, where it isn't
--   significant, is's not inserted between tags and text containing non
--   whitespace chars.
--   
--   whitespace is only inserted or changed at places, where it's not
--   significant. preserving whitespace may be controlled in a document
--   tree by a tag attribute <tt>xml:space</tt>
--   
--   allowed values for this attribute are <tt>default | preserve</tt>.
--   
--   input is a complete document tree or a document fragment result is the
--   semantically equivalent formatted tree.
--   
--   see also : <a>removeDocWhiteSpace</a>
indentDoc :: ArrowXml a => a XmlTree XmlTree

-- | convert a document into a text and add line numbers to the text
--   representation.
--   
--   Result is a root node with a single text node as child. Useful for
--   debugging and trace output. see also : <a>haskellRepOfXmlDoc</a>,
--   <a>treeRepOfXmlDoc</a>
numberLinesInXmlDoc :: ArrowList a => a XmlTree XmlTree
preventEmptyElements :: ArrowList a => [String] -> Bool -> a XmlTree XmlTree

-- | remove a Comment node
removeComment :: ArrowXml a => a XmlTree XmlTree

-- | remove all comments in a tree recursively
removeAllComment :: ArrowXml a => a XmlTree XmlTree

-- | simple filter for removing whitespace.
--   
--   no check on sigificant whitespace, e.g. in HTML &lt;pre&gt;-elements,
--   is done.
--   
--   see also : <a>removeAllWhiteSpace</a>, <a>removeDocWhiteSpace</a>
removeWhiteSpace :: ArrowXml a => a XmlTree XmlTree

-- | simple recursive filter for removing all whitespace.
--   
--   removes all text nodes in a tree that consist only of whitespace.
--   
--   see also : <a>removeWhiteSpace</a>, <a>removeDocWhiteSpace</a>
removeAllWhiteSpace :: ArrowXml a => a XmlTree XmlTree

-- | filter for removing all not significant whitespace.
--   
--   the tree traversed for removing whitespace between elements, that was
--   inserted for indentation and readability. whitespace is only removed
--   at places, where it's not significat preserving whitespace may be
--   controlled in a document tree by a tag attribute <tt>xml:space</tt>
--   
--   allowed values for this attribute are <tt>default | preserve</tt>
--   
--   input is root node of the document to be cleaned up, output the
--   semantically equivalent simplified tree
--   
--   see also : <a>indentDoc</a>, <a>removeAllWhiteSpace</a>
removeDocWhiteSpace :: ArrowXml a => a XmlTree XmlTree

-- | converts a CDATA section into normal text nodes
transfCdata :: ArrowXml a => a XmlTree XmlTree

-- | converts CDATA sections in whole document tree into normal text nodes
transfAllCdata :: ArrowXml a => a XmlTree XmlTree

-- | converts a character reference to normal text
transfCharRef :: ArrowXml a => a XmlTree XmlTree

-- | recursively converts all character references to normal text
transfAllCharRef :: ArrowXml a => a XmlTree XmlTree
substAllXHTMLEntityRefs :: ArrowXml a => a XmlTree XmlTree
substXHTMLEntityRef :: LA XmlTree XmlTree
rememberDTDAttrl :: ArrowList a => a XmlTree XmlTree
addDefaultDTDecl :: ArrowList a => a XmlTree XmlTree
hasXmlPi :: ArrowXml a => a XmlTree XmlTree

-- | add an &lt;?xml version="1.0"?&gt; processing instruction if it's not
--   already there
addXmlPi :: ArrowXml a => a XmlTree XmlTree

-- | add an encoding spec to the &lt;?xml version="1.0"?&gt; processing
--   instruction
addXmlPiEncoding :: ArrowXml a => String -> a XmlTree XmlTree

-- | add an XHTML strict doctype declaration to a document
--   
--   add an XHTML transitional doctype declaration to a document
--   
--   add an XHTML frameset doctype declaration to a document
--   
--   add a doctype declaration to a document
--   
--   The arguments are the root element name, the PUBLIC id and the SYSTEM
--   id
addDoctypeDecl :: ArrowXml a => String -> String -> String -> a XmlTree XmlTree

-- | add an XHTML strict doctype declaration to a document
addXHtmlDoctypeStrict, addXHtmlDoctypeFrameset, addXHtmlDoctypeTransitional :: ArrowXml a => a XmlTree XmlTree


-- | namespace specific arrows
module Text.XML.HXT.Arrow.Namespace

-- | attach all valid namespace declarations to the attribute list of
--   element nodes.
--   
--   This arrow is useful for document processing, that requires access to
--   all namespace declarations at any element node, but which cannot be
--   done with a simple <a>processWithNsEnv</a>.
attachNsEnv :: ArrowXml a => NsEnv -> a XmlTree XmlTree

-- | does the real work for namespace cleanup.
--   
--   The parameter is used for collecting namespace uris and prefixes from
--   the input tree
cleanupNamespaces :: LA XmlTree (String, String) -> LA XmlTree XmlTree

-- | collect all namespace declarations contained in a document
--   
--   apply <a>getNamespaceDecl</a> to a whole XmlTree
collectNamespaceDecl :: LA XmlTree (String, String)

-- | collect all (namePrefix, namespaceUri) pairs from a tree
--   
--   all qualified names are inspected, whether a namespace uri is defined,
--   for these uris the prefix and uri is returned. This arrow is useful
--   for namespace cleanup, e.g. for documents generated with XSLT. It can
--   be used together with <a>collectNamespaceDecl</a> to
--   <a>cleanupNamespaces</a>
collectPrefixUriPairs :: LA XmlTree (String, String)

-- | test whether an attribute node contains an XML Namespace declaration
isNamespaceDeclAttr :: ArrowXml a => a XmlTree XmlTree

-- | get the namespace prefix and the namespace URI out of an attribute
--   tree with a namespace declaration (see <a>isNamespaceDeclAttr</a>) for
--   all other nodes this arrow fails
getNamespaceDecl :: ArrowXml a => a XmlTree (String, String)

-- | process a document tree with an arrow, containing always the valid
--   namespace environment as extra parameter.
--   
--   The namespace environment is implemented as a
--   <tt>Data.AssocList.AssocList</tt>
processWithNsEnv :: ArrowXml a => (NsEnv -> a XmlTree XmlTree) -> NsEnv -> a XmlTree XmlTree

-- | process all element nodes of a document tree with an arrow, containing
--   always the valid namespace environment as extra parameter. Attribute
--   lists are not processed.
--   
--   See also: <a>processWithNsEnv</a>
processWithNsEnvWithoutAttrl :: ArrowXml a => (NsEnv -> a XmlTree XmlTree) -> NsEnv -> a XmlTree XmlTree

-- | propagate all namespace declarations "xmlns:ns=..." to all element and
--   attribute nodes of a document.
--   
--   This arrow does not check for illegal use of namespaces. The real work
--   is done by <a>propagateNamespaceEnv</a>.
--   
--   The arrow may be applied repeatedly if neccessary.
propagateNamespaces :: ArrowXml a => a XmlTree XmlTree

-- | generate unique namespaces and add all namespace declarations to all
--   top nodes containing a namespace declaration Usually the top node
--   containing namespace declarations is the root node, but this isn't
--   mandatory.
--   
--   Calls <a>cleanupNamespaces</a> with <a>collectNamespaceDecl</a>
uniqueNamespaces :: ArrowXml a => a XmlTree XmlTree

-- | generate unique namespaces and add all namespace declarations for all
--   prefix-uri pairs in all qualified names
--   
--   useful for cleanup of namespaces in generated documents. Calls
--   <a>cleanupNamespaces</a> with <tt> collectNamespaceDecl &lt;+&gt;
--   collectPrefixUriPairs </tt>
uniqueNamespacesFromDeclAndQNames :: ArrowXml a => a XmlTree XmlTree

-- | validate the namespace constraints in a whole tree.
--   
--   Result is the list of errors concerning namespaces. Predicates
--   <a>isWellformedQName</a>, <a>isWellformedQualifiedName</a>,
--   <a>isDeclaredNamespace</a> and <a>isWellformedNSDecl</a> are applied
--   to the appropriate elements and attributes.
validateNamespaces :: ArrowXml a => a XmlTree XmlTree


-- | the trace arrows
module Text.XML.HXT.Arrow.XmlState.TraceHandling

-- | set the global trace level
setTraceLevel :: Int -> IOStateArrow s b b

-- | read the global trace level
getTraceLevel :: IOStateArrow s b Int

-- | set the global trace command. This command does the trace output
setTraceCmd :: (Int -> String -> IO ()) -> IOStateArrow s b b

-- | acces the command for trace output
getTraceCmd :: IOStateArrow a b (Int -> String -> IO ())

-- | run an arrow with a given trace level, the old trace level is restored
--   after the arrow execution
withTraceLevel :: Int -> IOStateArrow s b c -> IOStateArrow s b c

-- | apply a trace arrow and issue message to stderr
trace :: Int -> IOStateArrow s b String -> IOStateArrow s b b

-- | trace the current value transfered in a sequence of arrows.
--   
--   The value is formated by a string conversion function. This is a
--   substitute for the old and less general traceString function
traceValue :: Int -> (b -> String) -> IOStateArrow s b b

-- | an old alias for <a>traceValue</a>
traceString :: Int -> (b -> String) -> IOStateArrow s b b

-- | issue a string message as trace
traceMsg :: Int -> String -> IOStateArrow s b b

-- | issue the source representation of a document if trace level &gt;= 3
--   
--   for better readability the source is formated with indentDoc
traceSource :: IOStateArrow s XmlTree XmlTree

-- | issue the tree representation of a document if trace level &gt;= 4
traceTree :: IOStateArrow s XmlTree XmlTree

-- | trace a main computation step issue a message when trace level &gt;=
--   1, issue document source if level &gt;= 3, issue tree when level is
--   &gt;= 4
traceDoc :: String -> IOStateArrow s XmlTree XmlTree
traceOutputToStderr :: Int -> String -> IO ()


-- | the basic state arrows for URI handling
module Text.XML.HXT.Arrow.XmlState.URIHandling

-- | set the base URI of a document, used e.g. for reading includes, e.g.
--   external entities, the input must be an absolute URI
setBaseURI :: IOStateArrow s String String

-- | read the base URI from the globale state
getBaseURI :: IOStateArrow s b String

-- | change the base URI with a possibly relative URI, can be used for
--   evaluating the xml:base attribute. Returns the new absolute base URI.
--   Fails, if input is not parsable with parseURIReference
--   
--   see also: <a>setBaseURI</a>, <a>mkAbsURI</a>
changeBaseURI :: IOStateArrow s String String

-- | set the default base URI, if parameter is null, the system base (<tt>
--   file:///&lt;cwd&gt;/ </tt>) is used, else the parameter, must be
--   called before any document is read
setDefaultBaseURI :: String -> IOStateArrow s b String

-- | get the default base URI
getDefaultBaseURI :: IOStateArrow s b String

-- | remember base uri, run an arrow and restore the base URI, used with
--   external entity substitution
runInLocalURIContext :: IOStateArrow s b c -> IOStateArrow s b c

-- | parse a URI reference, in case of a failure, try to escape unescaped
--   chars, convert backslashes to slashes for windows paths, and try
--   parsing again
parseURIReference' :: String -> Maybe URI

-- | compute the absolut URI for a given URI and a base URI
expandURIString :: String -> String -> Maybe String

-- | arrow variant of <a>expandURIString</a>, fails if
--   <a>expandURIString</a> returns Nothing
expandURI :: ArrowXml a => a (String, String) String

-- | arrow for expanding an input URI into an absolute URI using global
--   base URI, fails if input is not a legal URI
mkAbsURI :: IOStateArrow s String String

-- | arrow for selecting the scheme (protocol) of the URI, fails if input
--   is not a legal URI.
--   
--   See Network.URI for URI components
getSchemeFromURI :: ArrowList a => a String String

-- | arrow for selecting the registered name (host) of the URI, fails if
--   input is not a legal URI
getRegNameFromURI :: ArrowList a => a String String

-- | arrow for selecting the port number of the URI without leading ':',
--   fails if input is not a legal URI
getPortFromURI :: ArrowList a => a String String

-- | arrow for selecting the user info of the URI without trailing '@',
--   fails if input is not a legal URI
getUserInfoFromURI :: ArrowList a => a String String

-- | arrow for computing the path component of an URI, fails if input is
--   not a legal URI
getPathFromURI :: ArrowList a => a String String

-- | arrow for computing the query component of an URI, fails if input is
--   not a legal URI
getQueryFromURI :: ArrowList a => a String String

-- | arrow for computing the fragment component of an URI, fails if input
--   is not a legal URI
getFragmentFromURI :: ArrowList a => a String String

-- | arrow for computing the path component of an URI, fails if input is
--   not a legal URI
getPartFromURI :: ArrowList a => (URI -> String) -> a String String


-- | This module provides all datatypes for DTD validation
module Text.XML.HXT.DTDValidation.TypeDefs
type XmlArrow = LA XmlTree XmlTree
type XmlArrowS = LA XmlTree XmlTrees
dtd_name, dtd_default, dtd_modifier, dtd_kind, dtd_type, dtd_value :: Attributes -> String
isUnparsedEntity :: ArrowDTD a => a XmlTree XmlTree
hasDTDAttrValue :: ArrowDTD a => String -> (String -> Bool) -> a XmlTree XmlTree
isRequiredAttrKind :: ArrowDTD a => a XmlTree XmlTree
isDefaultAttrKind :: ArrowDTD a => a XmlTree XmlTree
isFixedAttrKind :: ArrowDTD a => a XmlTree XmlTree
isMixedContentElement :: ArrowDTD a => a XmlTree XmlTree
isEmptyElement :: ArrowDTD a => a XmlTree XmlTree
isEnumAttrType :: ArrowDTD a => a XmlTree XmlTree
isIdAttrType :: ArrowDTD a => a XmlTree XmlTree
isIdRefAttrType :: ArrowDTD a => a XmlTree XmlTree
isNotationAttrType :: ArrowDTD a => a XmlTree XmlTree
isAttlistOfElement :: ArrowDTD a => String -> a XmlTree XmlTree
valueOfDTD :: String -> XmlTree -> String
valueOf :: String -> XmlTree -> String
getDTDAttributes :: XmlTree -> Attributes
isDTDDoctypeNode :: XmlTree -> Bool
isDTDElementNode :: XmlTree -> Bool
isDTDAttlistNode :: XmlTree -> Bool
isDTDContentNode :: XmlTree -> Bool
isDTDNameNode :: XmlTree -> Bool
isElemNode :: XmlTree -> Bool
nameOfAttr :: XmlTree -> String
nameOfElem :: XmlTree -> String

-- | infix operator for applying an arrow to a list of trees
--   
--   <ul>
--   <li>1.parameter f : the arrow</li>
--   <li>2.parameter ts : the list of trees</li>
--   <li>returns : list of results</li>
--   </ul>
($$) :: XmlArrow -> XmlTrees -> XmlTrees

-- | create an error message
msgToErr :: (String -> String) -> LA String XmlTree


-- | This module provides functions for validating attributes.
--   
--   The main functions are:
--   
--   <ul>
--   <li>Check if the attribute value meets the lexical constraints of its
--   type</li>
--   <li>Normalization of an attribute value</li>
--   </ul>
module Text.XML.HXT.DTDValidation.AttributeValueValidation

-- | Checks if the attribute value meets the lexical constraints of its
--   type.
--   
--   <ul>
--   <li>1.parameter dtdPart : the children of the <tt>DOCTYPE</tt>
--   node</li>
--   <li>2.parameter attrDecl : the declaration of the attribute from the
--   DTD</li>
--   <li>returns : a function which takes an element (XTag or XDTD
--   ATTLIST), checks if the attribute value meets the lexical constraints
--   of its type and returns a list of errors</li>
--   </ul>
checkAttributeValue :: XmlTrees -> XmlTree -> XmlArrow

-- | Normalizes an attribute value with respect to its type. (3.3.3 / p.29
--   in Spec)
--   
--   <ul>
--   <li>1.parameter attrDecl : the declaration of the attribute from the
--   DTD. Expected is a list. If the list is empty, no declaration
--   exists.</li>
--   <li>2.parameter value : the attribute value to be normalized</li>
--   <li>returns : the normalized value</li>
--   </ul>
normalizeAttributeValue :: Maybe XmlTree -> String -> String


-- | This module provides functions for validating the DTD of XML documents
--   represented as XmlTree.
--   
--   Unlike other popular XML validation tools the validation process
--   returns a list of errors instead of aborting after the first error was
--   found.
--   
--   Unlike validation of the document, the DTD branch is traversed four
--   times:
--   
--   <ul>
--   <li>Validation of Notations</li>
--   <li>Validation of Unparsed Entities</li>
--   <li>Validation of Element declarations</li>
--   <li>Validation of Attribute declarations</li>
--   </ul>
module Text.XML.HXT.DTDValidation.DTDValidation

-- | Removes doublicate declarations from the DTD, which first declaration
--   is binding. This is the case for ATTLIST and ENTITY declarations.
--   
--   <ul>
--   <li>returns : A function that replaces the children of DOCTYPE nodes
--   by a list where all multiple declarations are removed.</li>
--   </ul>
removeDoublicateDefs :: XmlArrow

-- | Validate a DTD.
--   
--   <ul>
--   <li>returns : a functions which takes the DTD subset of the XmlTree,
--   checks if the DTD is valid and returns a list of errors</li>
--   </ul>
validateDTD :: XmlArrow


-- | This module provides functions for transforming XML documents
--   represented as XmlTree with respect to its DTD.
--   
--   Transforming an XML document with respect to its DTD means:
--   
--   <ul>
--   <li>add all attributes with default values</li>
--   <li>normalize all attribute values</li>
--   <li>sort all attributes in lexical order</li>
--   </ul>
--   
--   Note: Transformation should be started after validation.
--   
--   Before the document is validated, a lookup-table is build on the basis
--   of the DTD which maps element names to their transformation functions.
--   After this initialization phase the whole document is traversed in
--   preorder and every element is transformed by the XmlFilter from the
--   lookup-table.
module Text.XML.HXT.DTDValidation.DocTransformation

-- | filter for transforming the document.
--   
--   <ul>
--   <li>1.parameter dtdPart : the DTD subset (Node <tt>DOCTYPE</tt>) of
--   the XmlTree</li>
--   <li>2.parameter doc : the document subset of the XmlTree</li>
--   <li>returns : a list of errors</li>
--   </ul>
transform :: XmlTree -> XmlArrow


-- | A module for regular expression matching, adapted for XML DTDs.
--   
--   This module is based on the module RE.
module Text.XML.HXT.DTDValidation.XmlRE

-- | Data type for regular expressions.
data RE a

-- | Checks if an input matched a regular expression. The function should
--   be called after matches.
--   
--   Was the sentence used in <tt>matches</tt> in the language of the
--   regular expression? -&gt; matches e s == s `in` L(e)?
--   
--   <ul>
--   <li>1.parameter re : the derived regular expression</li>
--   <li>returns : empty String if input matched the regular expression,
--   otherwise an error message is returned</li>
--   </ul>
checkRE :: Show a => RE a -> String

-- | Derives a regular expression with respect to a list of elements.
--   
--   <ul>
--   <li>1.parameter re : regular expression</li>
--   <li>2.parameter list : list of elements to which the regular
--   expression is applied</li>
--   <li>returns : the derived regular expression</li>
--   </ul>
matches :: RE String -> XmlTrees -> RE String

-- | Constructs a string representation of a regular expression.
--   
--   <ul>
--   <li>1.parameter re : a regular expression</li>
--   <li>returns : the string representation of the regular expression</li>
--   </ul>
printRE :: Show a => RE a -> String

-- | Constructs a regular expression for an empty sequence.
--   
--   <ul>
--   <li>returns : regular expression for an empty sequence</li>
--   </ul>
re_unit :: RE a

-- | Constructs a regular expression for an empty set.
--   
--   <ul>
--   <li>1.parameter errMsg : error message</li>
--   <li>returns : regular expression for an empty set</li>
--   </ul>
re_zero :: String -> RE a

-- | Constructs a regular expression for accepting a symbol
--   
--   <ul>
--   <li>1.parameter sym : the symbol to be accepted</li>
--   <li>returns : regular expression for accepting a symbol</li>
--   </ul>
re_sym :: a -> RE a

-- | Constructs an optional repetition (*) of a regular expression
--   
--   <ul>
--   <li>1.parameter re_a : regular expression to be repeted</li>
--   <li>returns : new regular expression</li>
--   </ul>
re_rep :: RE a -> RE a

-- | Constructs a repetition (+) of a regular expression
--   
--   <ul>
--   <li>1.parameter re_a : regular expression to be repeted</li>
--   <li>returns : new regular expression</li>
--   </ul>
re_plus :: RE a -> RE a

-- | Constructs an option (?) of a regular expression
--   
--   <ul>
--   <li>1.parameter re_a : regular expression to be optional</li>
--   <li>returns : new regular expression</li>
--   </ul>
re_opt :: RE a -> RE a

-- | Constructs a sequence (,) of two regular expressions
--   
--   <ul>
--   <li>1.parameter re_a : first regular expression in sequence</li>
--   <li>2.parameter re_b : second regular expression in sequence</li>
--   <li>returns : new regular expression</li>
--   </ul>
re_seq :: RE a -> RE a -> RE a

-- | Constructs an alternative (|) of two regular expressions
--   
--   <ul>
--   <li>1.parameter re_a : first regular expression of alternative</li>
--   <li>2.parameter re_b : second regular expression of alternative</li>
--   <li>returns : new regular expression</li>
--   </ul>
re_alt :: RE a -> RE a -> RE a

-- | Constructs a regular expression for accepting any singel symbol
--   
--   <ul>
--   <li>returns : regular expression for accepting any singel symbol</li>
--   </ul>
re_dot :: RE a


-- | This module provides functions for validating XML Documents
--   represented as XmlTree.
--   
--   Unlike other popular XML validation tools the validation process
--   returns a list of errors instead of aborting after the first error was
--   found.
--   
--   Before the document is validated, a lookup-table is build on the basis
--   of the DTD which maps element names to their validation functions.
--   After this initialization phase the whole document is traversed in
--   preorder and every element is validated by the XmlFilter from the
--   lookup-table.
module Text.XML.HXT.DTDValidation.DocValidation

-- | Validate a document.
--   
--   <ul>
--   <li>1.parameter dtdPart : the DTD subset (Node <tt>DOCTYPE</tt>) of
--   the XmlTree</li>
--   <li>2.parameter doc : the document subset of the XmlTree</li>
--   <li>returns : a list of errors</li>
--   </ul>
validateDoc :: XmlTree -> XmlArrow


-- | This module provides functions for checking special
--   ID<i>IDREF</i>IDREFS constraints.
--   
--   Checking special ID/IDREF/IDREFS constraints means:
--   
--   <ul>
--   <li>checking that all ID values are unique.</li>
--   <li>checking that all IDREF/IDREFS values match the value of some ID
--   attribute</li>
--   </ul>
--   
--   ID-Validation should be started before or after validating the
--   document.
--   
--   First all nodes with ID attributes are collected from the document,
--   then it is validated that values of ID attributes do not occure more
--   than once. During a second iteration over the document it is validated
--   that there exists an ID attribute value for IDREF/IDREFS attribute
--   values.
module Text.XML.HXT.DTDValidation.IdValidation

-- | Perform the validation of the ID<i>IDREF</i>IDREFS constraints.
--   
--   <ul>
--   <li>1.parameter dtdPart : the DTD subset (Node <tt>DOCTYPE</tt>) of
--   the XmlTree</li>
--   <li>2.parameter doc : the document subset of the XmlTree</li>
--   <li>returns : a list of errors</li>
--   </ul>
validateIds :: XmlTree -> XmlArrow


-- | This module provides functions for validating XML documents
--   represented as XmlTree.
--   
--   Unlike other popular XML validation tools the validation functions
--   return a list of errors instead of aborting after the first error was
--   found.
--   
--   Note: The validation process has been split into validation and
--   transformation! If <tt>validate</tt> did not report any errors,
--   <tt>transform</tt> should be called, to change the document the way a
--   validating parser is expected to do.
module Text.XML.HXT.DTDValidation.Validation
getDTDSubset :: XmlArrow
generalEntitiesDefined :: XmlArrow

-- | Main validation filter. Check if the DTD and the document are valid.
--   
--   <ul>
--   <li>returns : a function which expects a complete document as XmlTree
--   input and returns a list of all errors found.</li>
--   </ul>
validate :: XmlArrow

-- | Check if the DTD is valid.
--   
--   <ul>
--   <li>returns : a function which expects an XmlTree from the parser as
--   input and returns a list of all errors found in the DTD.</li>
--   </ul>
validateDTD :: XmlArrow

-- | Check if the document corresponds to the given DTD.
--   
--   <ul>
--   <li>returns : a function which expects a complete document as XmlTree
--   input and returns a list of all errors found in the content part.</li>
--   </ul>
validateDoc :: XmlArrow

-- | Removes doublicate declarations from the DTD which first declaration
--   is binding. This is the case for ATTLIST and ENTITY declarations.
--   
--   <ul>
--   <li>returns : A function that replaces the children of DOCTYPE nodes
--   by a list where all multiple declarations are removed.</li>
--   </ul>
removeDoublicateDefs :: XmlArrow

-- | filter for transforming a document with respect to the given DTD.
--   
--   Validating parsers are expected to normalize attribute values and add
--   default values. This function should be called after a successful
--   validation.
--   
--   <ul>
--   <li>returns : a function which expects a complete XML document tree
--   and returns the transformed XmlTree</li>
--   </ul>
transform :: XmlArrow


-- | run an io state arrow
module Text.XML.HXT.Arrow.XmlState.RunIOStateArrow

-- | apply an <a>IOSArrow</a> to an empty root node with
--   <a>initialState</a> () as initial state
--   
--   the main entry point for running a state arrow with IO
--   
--   when running <tt> runX f</tt> an empty XML root node is applied to
--   <tt>f</tt>. usually <tt>f</tt> will start with a constant arrow
--   (ignoring the input), e.g. a
--   <tt>Text.XML.HXT.Arrow.ReadDocument.readDocument</tt> arrow.
--   
--   for usage see examples with
--   <tt>Text.XML.HXT.Arrow.WriteDocument.writeDocument</tt>
--   
--   if input has to be feed into the arrow use <a>runIOSLA</a> like in
--   <tt> runIOSLA f emptyX inputDoc </tt>
runX :: IOSArrow XmlTree c -> IO [c]
runXIOState :: XIOState s -> IOStateArrow s XmlTree c -> IO [c]

-- | the default global state, used as initial state when running an
--   <a>IOSArrow</a> with <a>runIOSLA</a> or <a>runX</a>
initialState :: us -> XIOState us
initialSysState :: XIOSysState
initialSysWriter :: XIOSysWriter
initialSysEnv :: XIOSysEnv
initialInputConfig :: XIOInputConfig
initialParseConfig :: XIOParseConfig
initialOutputConfig :: XIOOutputConfig
initialRelaxConfig :: XIORelaxConfig
initialCacheConfig :: XIOCacheConfig
dummyHTTPHandler :: IOSArrow XmlTree XmlTree
dummyTagSoupParser :: IOSArrow b b
dummyExpatParser :: IOSArrow b b
dummyRelaxValidator :: IOSArrow b b
dummyCacheRead :: String -> IOSArrow b b
getConfigAttr :: String -> SysConfigList -> String
theSysConfigComp :: Selector XIOSysState a -> Selector SysConfig a


-- | the interface for the basic state maipulation functions
module Text.XML.HXT.Arrow.XmlState

-- | state datatype consists of a system state and a user state the user
--   state is not fixed
data XIOState us

-- | predefined system state data type with all components for the system
--   functions, like trace, error handling, ...
data XIOSysState

-- | The arrow type for stateful arrows
type IOStateArrow s b c = IOSLA (XIOState s) b c

-- | The arrow for stateful arrows with no user defined state
type IOSArrow b c = IOStateArrow () b c
type SysConfig = XIOSysState -> XIOSysState
type SysConfigList = [SysConfig]

-- | read the user defined part of the state
getUserState :: IOStateArrow s b s

-- | set the user defined part of the state
setUserState :: IOStateArrow s s s

-- | change the user defined part of the state
changeUserState :: (b -> s -> s) -> IOStateArrow s b b

-- | extend user state
--   
--   Run an arrow with an extended user state component, The old component
--   is stored together with a new one in a pair, the arrow is executed
--   with this extended state, and the augmented state component is removed
--   form the state when the arrow has finished its execution
withExtendedUserState :: s1 -> IOStateArrow (s1, s0) b c -> IOStateArrow s0 b c

-- | change the type of user state
--   
--   This conversion is useful, when running a state arrow with another
--   structure of the user state, e.g. with () when executing some IO
--   arrows
withOtherUserState :: s1 -> IOStateArrow s1 b c -> IOStateArrow s0 b c
withoutUserState :: IOSArrow b c -> IOStateArrow s0 b c

-- | apply an <a>IOSArrow</a> to an empty root node with
--   <a>initialState</a> () as initial state
--   
--   the main entry point for running a state arrow with IO
--   
--   when running <tt> runX f</tt> an empty XML root node is applied to
--   <tt>f</tt>. usually <tt>f</tt> will start with a constant arrow
--   (ignoring the input), e.g. a
--   <tt>Text.XML.HXT.Arrow.ReadDocument.readDocument</tt> arrow.
--   
--   for usage see examples with
--   <tt>Text.XML.HXT.Arrow.WriteDocument.writeDocument</tt>
--   
--   if input has to be feed into the arrow use <a>runIOSLA</a> like in
--   <tt> runIOSLA f emptyX inputDoc </tt>
runX :: IOSArrow XmlTree c -> IO [c]
configSysVars :: SysConfigList -> IOStateArrow s c c

-- | store a string in global state under a given attribute name
setSysAttr :: String -> IOStateArrow s String String

-- | remove an entry in global state, arrow input remains unchanged
unsetSysAttr :: String -> IOStateArrow s b b

-- | read an attribute value from global state
getSysAttr :: String -> IOStateArrow s b String

-- | read all attributes from global state
getAllSysAttrs :: IOStateArrow s b Attributes
setSysAttrString :: String -> String -> IOStateArrow s b b

-- | store an int value in global state
setSysAttrInt :: String -> Int -> IOStateArrow s b b

-- | read an int value from global state
--   
--   <pre>
--   getSysAttrInt 0 myIntAttr
--   </pre>
getSysAttrInt :: Int -> String -> IOStateArrow s b Int
getConfigAttr :: String -> SysConfigList -> String

-- | reset global error variable
clearErrStatus :: IOStateArrow s b b

-- | set global error variable
setErrStatus :: IOStateArrow s Int Int

-- | read current global error status
getErrStatus :: IOStateArrow s XmlTree Int

-- | raise the global error status level to that of the input tree
setErrMsgStatus :: IOStateArrow s XmlTree XmlTree

-- | set the error message handler and the flag for collecting the errors
setErrorMsgHandler :: Bool -> (String -> IO ()) -> IOStateArrow s b b

-- | the default error message handler: error output to stderr
errorMsgStderr :: IOStateArrow s b b

-- | error message handler for collecting errors
errorMsgCollect :: IOStateArrow s b b

-- | error message handler for output to stderr and collecting
errorMsgStderrAndCollect :: IOStateArrow s b b

-- | error message handler for ignoring errors
errorMsgIgnore :: IOStateArrow s b b

-- | if error messages are collected by the error handler for processing
--   these messages by the calling application, this arrow reads the stored
--   messages and clears the error message store
getErrorMessages :: IOStateArrow s b XmlTree

-- | filter error messages from input trees and issue errors
filterErrorMsg :: IOStateArrow s XmlTree XmlTree

-- | generate a warnig message
issueWarn :: String -> IOStateArrow s b b

-- | generate an error message
issueErr :: String -> IOStateArrow s b b

-- | generate a fatal error message, e.g. document not found
issueFatal :: String -> IOStateArrow s b b

-- | Default exception handler: issue a fatal error message and fail.
--   
--   The parameter can be used to specify where the error occured
issueExc :: String -> IOStateArrow s SomeException b

-- | add the error level and the module where the error occured to the
--   attributes of a document root node and remove the children when level
--   is greater or equal to <a>c_err</a>. called by
--   <a>setDocumentStatusFromSystemState</a> when the system state
--   indicates an error
setDocumentStatus :: Int -> String -> IOStateArrow s XmlTree XmlTree

-- | check whether the error level attribute in the system state is set to
--   error, in this case the children of the document root are removed and
--   the module name where the error occured and the error level are added
--   as attributes with <a>setDocumentStatus</a> else nothing is changed
setDocumentStatusFromSystemState :: String -> IOStateArrow s XmlTree XmlTree

-- | check whether tree is a document root and the status attribute has a
--   value less than <a>c_err</a>
documentStatusOk :: ArrowXml a => a XmlTree XmlTree

-- | set the global trace level
setTraceLevel :: Int -> IOStateArrow s b b

-- | read the global trace level
getTraceLevel :: IOStateArrow s b Int

-- | run an arrow with a given trace level, the old trace level is restored
--   after the arrow execution
withTraceLevel :: Int -> IOStateArrow s b c -> IOStateArrow s b c

-- | set the global trace command. This command does the trace output
setTraceCmd :: (Int -> String -> IO ()) -> IOStateArrow s b b

-- | acces the command for trace output
getTraceCmd :: IOStateArrow a b (Int -> String -> IO ())

-- | apply a trace arrow and issue message to stderr
trace :: Int -> IOStateArrow s b String -> IOStateArrow s b b

-- | issue a string message as trace
traceMsg :: Int -> String -> IOStateArrow s b b

-- | trace the current value transfered in a sequence of arrows.
--   
--   The value is formated by a string conversion function. This is a
--   substitute for the old and less general traceString function
traceValue :: Int -> (b -> String) -> IOStateArrow s b b

-- | an old alias for <a>traceValue</a>
traceString :: Int -> (b -> String) -> IOStateArrow s b b

-- | issue the source representation of a document if trace level &gt;= 3
--   
--   for better readability the source is formated with indentDoc
traceSource :: IOStateArrow s XmlTree XmlTree

-- | issue the tree representation of a document if trace level &gt;= 4
traceTree :: IOStateArrow s XmlTree XmlTree

-- | trace a main computation step issue a message when trace level &gt;=
--   1, issue document source if level &gt;= 3, issue tree when level is
--   &gt;= 4
traceDoc :: String -> IOStateArrow s XmlTree XmlTree

-- | set the base URI of a document, used e.g. for reading includes, e.g.
--   external entities, the input must be an absolute URI
setBaseURI :: IOStateArrow s String String

-- | read the base URI from the globale state
getBaseURI :: IOStateArrow s b String

-- | change the base URI with a possibly relative URI, can be used for
--   evaluating the xml:base attribute. Returns the new absolute base URI.
--   Fails, if input is not parsable with parseURIReference
--   
--   see also: <a>setBaseURI</a>, <a>mkAbsURI</a>
changeBaseURI :: IOStateArrow s String String

-- | set the default base URI, if parameter is null, the system base (<tt>
--   file:///&lt;cwd&gt;/ </tt>) is used, else the parameter, must be
--   called before any document is read
setDefaultBaseURI :: String -> IOStateArrow s b String

-- | get the default base URI
getDefaultBaseURI :: IOStateArrow s b String

-- | remember base uri, run an arrow and restore the base URI, used with
--   external entity substitution
runInLocalURIContext :: IOStateArrow s b c -> IOStateArrow s b c

-- | compute the absolut URI for a given URI and a base URI
expandURIString :: String -> String -> Maybe String

-- | arrow variant of <a>expandURIString</a>, fails if
--   <a>expandURIString</a> returns Nothing
expandURI :: ArrowXml a => a (String, String) String

-- | arrow for expanding an input URI into an absolute URI using global
--   base URI, fails if input is not a legal URI
mkAbsURI :: IOStateArrow s String String

-- | arrow for computing the fragment component of an URI, fails if input
--   is not a legal URI
getFragmentFromURI :: ArrowList a => a String String

-- | arrow for computing the path component of an URI, fails if input is
--   not a legal URI
getPathFromURI :: ArrowList a => a String String

-- | arrow for selecting the port number of the URI without leading ':',
--   fails if input is not a legal URI
getPortFromURI :: ArrowList a => a String String

-- | arrow for computing the query component of an URI, fails if input is
--   not a legal URI
getQueryFromURI :: ArrowList a => a String String

-- | arrow for selecting the registered name (host) of the URI, fails if
--   input is not a legal URI
getRegNameFromURI :: ArrowList a => a String String

-- | arrow for selecting the scheme (protocol) of the URI, fails if input
--   is not a legal URI.
--   
--   See Network.URI for URI components
getSchemeFromURI :: ArrowList a => a String String

-- | arrow for selecting the user info of the URI without trailing '@',
--   fails if input is not a legal URI
getUserInfoFromURI :: ArrowList a => a String String

-- | read the system mimetype table
getMimeTypeTable :: IOStateArrow s b MimeTypeTable

-- | set the table mapping of file extensions to mime types in the system
--   state
--   
--   Default table is defined in
--   <tt>Text.XML.HXT.DOM.MimeTypeDefaults</tt>. This table is used when
--   reading loacl files, (file: protocol) to determine the mime type
setMimeTypeTable :: MimeTypeTable -> IOStateArrow s b b

-- | set the table mapping of file extensions to mime types by an external
--   config file
--   
--   The config file must follow the conventions of <i>etc</i>mime.types on
--   a debian linux system, that means all empty lines and all lines
--   starting with a # are ignored. The other lines must consist of a mime
--   type followed by a possible empty list of extensions. The list of
--   extenstions and mime types overwrites the default list in the system
--   state of the IOStateArrow
setMimeTypeTableFromFile :: FilePath -> IOStateArrow s b b
yes :: Bool
no :: Bool
withAcceptedMimeTypes :: [String] -> SysConfig
withAddDefaultDTD :: Bool -> SysConfig

-- | <tt>withSysAttr key value</tt> : store an arbitarty key value pair in
--   system state
withSysAttr :: String -> String -> SysConfig

-- | <tt>withCanonicalize yes/no</tt> : read option, canonicalize document,
--   default is <a>yes</a>
withCanonicalize :: Bool -> SysConfig

-- | Configure compression and decompression for binary
--   serialization/deserialization. First component is the compression
--   function applied after serialization, second the decompression applied
--   before deserialization.
withCompression :: (CompressionFct, DeCompressionFct) -> SysConfig

-- | <tt>withCheckNamespaces yes/no</tt>: read option, check namespaces,
--   default is <a>no</a>
withCheckNamespaces :: Bool -> SysConfig

-- | <tt>withDefaultBaseURI URI</tt> , input option, set the default base
--   URI
--   
--   This option can be useful when parsing documents from stdin or
--   contained in a string, and interpreting relative URIs within the
--   document
withDefaultBaseURI :: String -> SysConfig

-- | Strict input for deserialization of binary data
withStrictDeserialize :: Bool -> SysConfig

-- | <tt>withEncodingErrors yes/no</tt> : input option, ignore all encoding
--   errors, default is <a>no</a>
withEncodingErrors :: Bool -> SysConfig

-- | <tt>withErrors yes/no</tt> : system option for suppressing error
--   messages, default is <a>no</a>
withErrors :: Bool -> SysConfig

-- | Force a given mime type for all file contents.
--   
--   The mime type for file access will then not be computed by looking
--   into a mime.types file
withFileMimeType :: String -> SysConfig

-- | <tt>withIgnoreNoneXmlContents yes/no</tt> : input option, ignore
--   document contents of none XML/HTML documents.
--   
--   This option can be useful for implementing crawler like applications,
--   e.g. an URL checker. In those cases net traffic can be reduced.
withIgnoreNoneXmlContents :: Bool -> SysConfig

-- | <tt>withIndent yes/no</tt> : output option, indent document before
--   output, default is <a>no</a>
withIndent :: Bool -> SysConfig

-- | <tt>withInputEncoding encodingName</tt> : input option
--   
--   Set default document encoding (<a>utf8</a>, <a>isoLatin1</a>,
--   <a>usAscii</a>, <a>iso8859_2</a>, ... , <a>iso8859_16</a>, ...). Only
--   XML, HTML and text documents are decoded, default decoding for
--   XML/HTML is utf8, for text iso latin1 (no decoding).
withInputEncoding :: String -> SysConfig
withInputOption :: String -> String -> SysConfig
withInputOptions :: Attributes -> SysConfig

-- | <tt>withMimeTypeFile filename</tt> : input option, set the mime type
--   table for <tt>file:</tt> documents by given file. The format of this
--   config file must be in the syntax of a debian linux "mime.types"
--   config file
withMimeTypeFile :: String -> SysConfig
withNoEmptyElemFor :: [String] -> SysConfig
withXmlPi :: Bool -> SysConfig

-- | <tt>withOutputEncoding encoding</tt> , output option, default is the
--   default input encoding or utf8, if input encoding is not set
withOutputEncoding :: String -> SysConfig

-- | <tt>withOutputXML</tt> : output option, default writing
--   
--   Default is writing XML: quote special XML chars &gt;,&lt;,",',&amp;
--   where neccessary, add XML processing instruction and encode document
--   with respect to <a>withOutputEncoding</a>
withOutputXML :: SysConfig

-- | Write XHTML: quote all special XML chars, use HTML entity refs or char
--   refs for none ASCII chars
withOutputHTML :: SysConfig

-- | Write XML: quote only special XML chars, don't substitute chars by
--   HTML entities, and don't generate empty elements for HTML elements,
--   which may contain any contents, e.g. <tt><a>script
--   src=...</a><a>/script</a></tt> instead of <tt><a>script src=...
--   /</a></tt>
withOutputXHTML :: SysConfig

-- | suppreses all char and entitiy substitution
withOutputPLAIN :: SysConfig

-- | <tt>withParseByMimeType yes/no</tt> : read option, select the parser
--   by the mime type of the document (pulled out of the HTTP header).
--   
--   When the mime type is set to "text/html" the configured HTML parser is
--   taken, when it's set to "text/xml" or "text/xhtml" the configured XML
--   parser is taken. If the mime type is something else, no further
--   processing is performed, the contents is given back to the application
--   in form of a single text node. If the default document encoding is set
--   to isoLatin1, this even enables processing of arbitray binary data.
withParseByMimeType :: Bool -> SysConfig

-- | <tt>withParseHTML yes/no</tt>: read option, use HTML parser, default
--   is <a>no</a> (use XML parser)
withParseHTML :: Bool -> SysConfig

-- | <tt>withPreserveComment yes/no</tt> : read option, preserve comments
--   during canonicalization, default is <a>no</a>
withPreserveComment :: Bool -> SysConfig

-- | <tt>withProxy "host:port"</tt> : input option, configure a proxy for
--   HTTP access, e.g. www-cache:3128
withProxy :: String -> SysConfig

-- | <tt>withRedirect yes/no</tt> : input option, automatically follow
--   redirected URIs, default is <a>yes</a>
withRedirect :: Bool -> SysConfig

-- | <tt>withRemoveWS yes/no</tt> : read and write option, remove all
--   whitespace, used for document indentation, default is <a>no</a>
withRemoveWS :: Bool -> SysConfig
withShowHaskell :: Bool -> SysConfig
withShowTree :: Bool -> SysConfig

-- | <tt>withStrictInput yes/no</tt> : input option, input of file and HTTP
--   contents is read eagerly, default is <a>no</a>
withStrictInput :: Bool -> SysConfig

-- | <tt>withSubstDTDEntities yes/no</tt>: read option, substitute general
--   entities defined in DTD, default is <a>yes</a>. switching this option
--   and the validate option off can lead to faster parsing, because then
--   there is no need to access the DTD
withSubstDTDEntities :: Bool -> SysConfig

-- | <tt>withSubstHTMLEntities yes/no</tt>: read option, substitute general
--   entities defined in HTML DTD, default is <a>no</a>. switching this
--   option on and the substDTDEntities and validate options off can lead
--   to faster parsing because there is no need to access a DTD, but still
--   the HTML general entities are substituted
withSubstHTMLEntities :: Bool -> SysConfig
withTextMode :: Bool -> SysConfig

-- | <tt>withTace level</tt> : system option, set the trace level, (0..4)
withTrace :: Int -> SysConfig

-- | <tt>withValidate yes/no</tt>: read option, validate document against
--   DTD, default is <a>yes</a>
withValidate :: Bool -> SysConfig

-- | <tt>withWarnings yes/no</tt> : system option, issue warnings during
--   reading, HTML parsing and processing, default is <a>yes</a>
withWarnings :: Bool -> SysConfig


-- | State arrows for document input
module Text.XML.HXT.Arrow.DocumentInput
getURIContents :: IOStateArrow s XmlTree XmlTree

-- | Read the content of a document.
--   
--   This routine is usually called from
--   <tt>Text.XML.HXT.Arrow.ProcessDocument.getDocumentContents</tt>.
--   
--   The input must be a root node (constructed with <a>root</a>), usually
--   without children. The attribute list contains all input parameters,
--   e.g. URI or source file name, encoding preferences, ... If the source
--   name is empty, the input is read from standard input.
--   
--   The source is transformed into an absolute URI. If the source is a
--   relative URI, or a file name, it is expanded into an absolut URI with
--   respect to the current base URI. The default base URI is of protocol
--   "file" and points to the current working directory.
--   
--   The currently supported protocols are "http", "file", "stdin" and
--   "string".
--   
--   The latter two are internal protocols. An uri of the form "stdin:"
--   stands for the content of the standard input stream.
--   
--   "string:some text" means, that "some text" is taken as input. This
--   internal protocol is used for reading from normal <a>String</a>
--   values.
getXmlContents :: IOStateArrow s XmlTree XmlTree
getXmlEntityContents :: IOStateArrow s XmlTree XmlTree
getEncoding :: IOStateArrow s XmlTree String
getTextEncoding :: IOStateArrow s XmlTree String
decodeDocument :: IOStateArrow s XmlTree XmlTree
addInputError :: Attributes -> String -> IOStateArrow s XmlTree XmlTree


-- | DTD processing function for including external parts of a DTD
--   parameter entity substitution and general entity substitution
--   
--   Implemtation completely done with arrows
module Text.XML.HXT.Arrow.DTDProcessing

-- | a filter for DTD processing
--   
--   inclusion of external parts of DTD, parameter entity substitution
--   conditional section evaluation
--   
--   input tree must represent a complete document including root node
processDTD :: IOStateArrow s XmlTree XmlTree
instance Eq DTDPart


-- | State arrows for document output
module Text.XML.HXT.Arrow.DocumentOutput

-- | Write the contents of a document tree into an output stream (file or
--   stdout).
--   
--   If textMode is set, writing is done with Haskell string output, else
--   (default) writing is done with lazy ByteString output
putXmlDocument :: Bool -> String -> IOStateArrow s XmlTree XmlTree

-- | write the tree representation of a document to a file
putXmlTree :: String -> IOStateArrow s XmlTree XmlTree

-- | write a document with indentaion and line numers
putXmlSource :: String -> IOStateArrow s XmlTree XmlTree
encodeDocument :: Bool -> Bool -> String -> IOStateArrow s XmlTree XmlTree
encodeDocument' :: ArrowXml a => Bool -> Bool -> String -> a XmlTree XmlTree


-- | general entity substitution
module Text.XML.HXT.Arrow.GeneralEntitySubstitution

-- | substitution of general entities
--   
--   input: a complete document tree including root node
processGeneralEntities :: IOStateArrow s XmlTree XmlTree


-- | Compound arrows for reading, parsing, validating and writing XML
--   documents
--   
--   All arrows use IO and a global state for options, errorhandling, ...
module Text.XML.HXT.Arrow.ProcessDocument

-- | XML parser
--   
--   Input tree must be a root tree with a text tree as child containing
--   the document to be parsed. The parser generates from the input string
--   a tree of a wellformed XML document, processes the DTD (parameter
--   substitution, conditional DTD parts, ...) and substitutes all general
--   entity references. Next step is character reference substitution. Last
--   step is the document validation. Validation can be controlled by an
--   extra parameter.
--   
--   Example:
--   
--   <pre>
--   parseXmlDocument True    -- parse and validate document
--   
--   parseXmlDocument False   -- only parse document, don't validate
--   </pre>
--   
--   This parser is useful for applications processing correct XML
--   documents.
parseXmlDocument :: Bool -> Bool -> Bool -> Bool -> IOStateArrow s XmlTree XmlTree
parseXmlDocumentWithExpat :: IOStateArrow s XmlTree XmlTree

-- | HTML parser
--   
--   Input tree must be a root tree with a text tree as child containing
--   the document to be parsed. The parser tries to parse everything as
--   HTML, if the HTML document is not wellformed XML or if errors occur,
--   warnings are generated. The warnings can be issued, or suppressed.
--   
--   Example: <tt> parseHtmlDocument True </tt> : parse document and issue
--   warnings
--   
--   This parser is useful for applications like web crawlers, where the
--   pages may contain arbitray errors, but the application is only
--   interested in parts of the document, e.g. the plain text.
parseHtmlDocument :: IOStateArrow s XmlTree XmlTree

-- | Document validation
--   
--   Input must be a complete document tree. The document is validated with
--   respect to the DTD spec. Only useful for XML documents containing a
--   DTD.
--   
--   If the document is valid, it is transformed with respect to the DTD,
--   normalization of attribute values, adding default values, sorting
--   attributes by name,...
--   
--   If no error was found, result is the normalized tree, else the error
--   status is set in the list of attributes of the root node "/" and the
--   document content is removed from the tree.
validateDocument :: IOStateArrow s XmlTree XmlTree

-- | Namespace propagation
--   
--   Input must be a complete document tree. The namespace declarations are
--   evaluated and all element and attribute names are processed by
--   splitting the name into prefix, local part and namespace URI.
--   
--   Naames are checked with respect to the XML namespace definition
--   
--   If no error was found, result is the unchanged input tree, else the
--   error status is set in the list of attributes of the root node "/" and
--   the document content is removed from the tree.
propagateAndValidateNamespaces :: IOStateArrow s XmlTree XmlTree
andValidateNamespaces :: IOStateArrow s XmlTree XmlTree

-- | creates a new document root, adds all options as attributes to the
--   document root and calls <a>getXmlContents</a>.
--   
--   If the document name is the empty string, the document will be read
--   from standard input.
--   
--   For supported protocols see <a>getXmlContents</a>
getDocumentContents :: String -> IOStateArrow s b XmlTree


-- | Compound arrow for writing XML documents
module Text.XML.HXT.Arrow.WriteDocument

-- | the main filter for writing documents
--   
--   this filter can be configured by an option list like
--   <tt>Text.XML.HXT.Arrow.ReadDocument.readDocument</tt>
--   
--   usage: <tt> writeDocument optionList destination </tt>
--   
--   if <tt> destination </tt> is the empty string or "-", stdout is used
--   as output device
--   
--   for available options see
--   <tt>Text.XML.HXT.Arrow.XmlState.SystemConfig</tt>
--   
--   <ul>
--   <li><tt>withOutputXML</tt> : (default) issue XML: quote special XML
--   chars &gt;,&lt;,",',&amp; where neccessary add XML processing
--   instruction and encode document with respect to output encoding,</li>
--   <li><tt>withOutputHTML</tt> : issue HTML: translate all special XML
--   chars and all HTML chars with a corresponding entity reference into
--   entity references. Do not generate empty elements, e.g. <tt><a>script
--   .../</a></tt> for HTML elements, that are allowed to contain a none
--   empty body. Result is for the example is <tt><a>script
--   ...</a><a>/script</a></tt>. The short form introduces trouble in
--   various browsers.</li>
--   <li><tt>withOutputXHTML</tt> : same as <tt>withOutputHTML</tt>, but
--   all none ASCII chars are substituted by char references.</li>
--   <li><tt>withOutputPLAIN</tt> : Do not substitute any chars. This is
--   useful when generating something else than XML/HTML, e.g. Haskell
--   source code.</li>
--   <li><tt>withXmlPi yes/no</tt> : Add a <tt><a>?xml version=...
--   encoding=... ?</a></tt> processing instruction to the beginning of the
--   document. Default is yes.</li>
--   <li><tt>withAddDefaultDTD</tt> : if the document to be written was
--   build by reading another document containing a Document Type
--   Declaration, this DTD is inserted into the output document (default:
--   no insert)</li>
--   <li><tt>withShowTree yes/no</tt> : show DOM tree representation of
--   document (for debugging)</li>
--   <li><tt>withShowHaskell yes/no</tt> : show Haskell representaion of
--   document (for debugging)</li>
--   </ul>
--   
--   a minimal main program for copying a document has the following
--   structure:
--   
--   <pre>
--   module Main
--   where
--   
--   import Text.XML.HXT.Core
--   
--   main        :: IO ()
--   main
--       = do
--         runX ( readDocument  [] "hello.xml"
--                &gt;&gt;&gt;
--                writeDocument [] "bye.xml"
--              )
--         return ()
--   </pre>
--   
--   an example for copying a document from the web to standard output with
--   global trace level 1, input trace level 2, output encoding isoLatin1,
--   and evaluation of error code is:
--   
--   <pre>
--   module Main
--   where
--   
--   import Text.XML.HXT.Core
--   import Text.XML.HXT.Curl
--   -- or
--   -- import Text.XML.HXT.HTTP
--   import System.Exit
--   
--   main        :: IO ()
--   main
--       = do
--         [rc] &lt;- runX
--                 ( configSysVars [ withTrace 1          -- set the defaults for all read-,
--                                 , withCurl []          -- write- and other operations
--                                   -- or withHTTP []
--                                 ]
--                   &gt;&gt;&gt;
--                   readDocument  [ withTrace     2      -- use these additional
--                                 , withParseHTML yes    -- options only for this read
--                                 ]
--                                 "http://www.haskell.org/"
--                   &gt;&gt;&gt;
--                   writeDocument [ withOutputEncoding isoLatin1
--                                 ]
--                                 ""                     -- output to stdout
--                   &gt;&gt;&gt;
--                   getErrStatus
--                 )
--         exitWith ( if rc &gt;= c_err
--                    then ExitFailure 1
--                    else ExitSuccess
--                  )
--   </pre>
writeDocument :: SysConfigList -> String -> IOStateArrow s XmlTree XmlTree
writeDocument' :: Bool -> String -> IOStateArrow s XmlTree XmlTree

-- | Convert a document into a string. Formating is done the same way and
--   with the same options as in <a>writeDocument</a>. Default output
--   encoding is no encoding, that means the result is a normal unicode
--   encode haskell string. The default may be overwritten with the
--   <tt>Text.XML.HXT.Arrow.XmlState.SystemConfig.withOutputEncoding</tt>
--   option. The XML PI can be suppressed by the
--   <tt>Text.XML.HXT.XmlKeywords.a_no_xml_pi</tt> option.
--   
--   This arrow fails, when the encoding scheme is not supported. The arrow
--   is pure, it does not run in the IO monad. The XML PI is suppressed, if
--   not explicitly turned on with an option <tt> (a_no_xml_pi, v_0) </tt>
writeDocumentToString :: ArrowXml a => SysConfigList -> a XmlTree String

-- | indent and format output
prepareContents :: ArrowXml a => XIOSysState -> (Bool -> Bool -> String -> a XmlTree XmlTree) -> a XmlTree XmlTree


-- | Module for importing all list arrows
module Control.Arrow.ListArrows


-- | Compound arrows for reading an XML/HTML document or an XML/HTML string
module Text.XML.HXT.Arrow.ReadDocument

-- | the main document input filter
--   
--   this filter can be configured by a list of configuration options, a
--   value of type <tt>Text.XML.HXT.XmlState.TypeDefs.SysConfig</tt>
--   
--   for all available options see module
--   <tt>Text.XML.HXT.XmlState.SystemConfig</tt>
--   
--   <ul>
--   <li><tt>withValidate yes/no</tt> : switch on/off DTD validation. Only
--   for XML parsed documents, not for HTML parsing.</li>
--   <li><tt>withSubstDTDEntities yes/no</tt> : switch on/off entity
--   substitution for general entities defined in DTD validation. Default
--   is <tt>yes</tt>. Switching this option and the validation off can lead
--   to faster parsing, in that case reading the DTD documents is not
--   longer necessary. Only used with XML parsed documents, not with HTML
--   parsing.</li>
--   <li><tt>withSubstHTMLEntities yes/no</tt> : switch on/off entity
--   substitution for general entities defined in HTML validation. Default
--   is <tt>no</tt>. Switching this option on and the validation and
--   substDTDEntities off can lead to faster parsing, in that case reading
--   the DTD documents is not longer necessary, HTML general entities are
--   still substituted. Only used with XML parsed documents, not with HTML
--   parsing.</li>
--   <li><tt>withParseHTML yes/no</tt> : switch on HTML parsing.</li>
--   <li><tt>withParseByMimeType yes/no</tt> : select XML/HTML parser by
--   document mime type. text/xml and text/xhtml are parsed as XML,
--   text/html as HTML.</li>
--   <li><tt>withCheckNamespaces yes/no</tt> : Switch on/off namespace
--   propagation and checking</li>
--   <li><tt>withInputEncoding <a>encoding-spec</a></tt> : Set default
--   encoding.</li>
--   <li><tt>withTagSoup</tt> : use light weight and lazy parser based on
--   tagsoup lib. This is only available when package hxt-tagsoup is
--   installed and <tt>Text.XML.HXT.TagSoup</tt> is imported</li>
--   <li><tt>withRelaxNG <a>schema.rng</a></tt> : validate document with
--   Relax NG, the parameter is for the schema URI. This implies using XML
--   parser, no validation against DTD, and canonicalisation.</li>
--   <li><tt>withCurl [<a>curl-option</a>...]</tt> : Use the libCurl
--   binding for HTTP access. This is only available when package hxt-curl
--   is installed and <tt>Text.XML.HXT.Curl</tt> is imported</li>
--   <li><tt>withHTTP [<a>http-option</a>...]</tt> : Use the Haskell HTTP
--   package for HTTP access. This is only available when package hxt-http
--   is installed and <tt>Text.XML.HXT.HTTP</tt> is imported</li>
--   </ul>
--   
--   examples:
--   
--   <pre>
--   readDocument [] "test.xml"
--   </pre>
--   
--   reads and validates a document "test.xml", no namespace propagation,
--   only canonicalization is performed
--   
--   <pre>
--   ...
--   import Text.XML.HXT.Curl
--   ...
--   
--   readDocument [ withValidate        no
--                , withInputEncoding   isoLatin1
--                , withParseByMimeType yes
--                , withCurl []
--                ] \"http:\/\/localhost\/test.php\"
--   </pre>
--   
--   reads document "test.php", parses it as HTML or XML depending on the
--   mimetype given from the server, but without validation, default
--   encoding <a>isoLatin1</a>. HTTP access is done via libCurl.
--   
--   <pre>
--   readDocument [ withParseHTML       yes
--                , withInputEncoding   isoLatin1
--                ] ""
--   </pre>
--   
--   reads a HTML document from standard input, no validation is done when
--   parsing HTML, default encoding is <a>isoLatin1</a>,
--   
--   <pre>
--   readDocument [ withInputEncoding  isoLatin1
--                , withValidate       no
--                , withMimeTypeFile   "/etc/mime.types"
--                , withStrictInput    yes
--                ] "test.svg"
--   </pre>
--   
--   reads an SVG document from "test.svg", sets the mime type by looking
--   in the system mimetype config file, default encoding is
--   <a>isoLatin1</a>,
--   
--   <pre>
--   ...
--   import Text.XML.HXT.Curl
--   import Text.XML.HXT.TagSoup
--   ...
--   
--   readDocument [ withParseHTML      yes
--                , withTagSoup
--                , withProxy          "www-cache:3128"
--                , withCurl           []
--                , withWarnings       no
--                ] "http://www.haskell.org/"
--   </pre>
--   
--   reads Haskell homepage with HTML parser, ignoring any warnings (at the
--   time of writing, there were some HTML errors), with http access via
--   libCurl interface and proxy "www-cache" at port 3128, parsing is done
--   with tagsoup HTML parser. This requires packages "hxt-curl" and
--   "hxt-tagsoup" to be installed
--   
--   <pre>
--   readDocument [ withValidate          yes
--                , withCheckNamespaces   yes
--                , withRemoveWS          yes
--                , withTrace             2
--                , withHTTP              []
--                ] "http://www.w3c.org/"
--   </pre>
--   
--   read w3c home page (xhtml), validate and check namespaces, remove
--   whitespace between tags, trace activities with level 2. HTTP access is
--   done with Haskell HTTP package
--   
--   <pre>
--   readDocument [ withValidate          no
--                , withSubstDTDEntities  no
--                ...
--                ] "http://www.w3c.org/"
--   </pre>
--   
--   read w3c home page (xhtml), but without accessing the DTD given in
--   that document. Only the predefined XML general entity refs are
--   substituted.
--   
--   <pre>
--   readDocument [ withValidate          no
--                , withSubstDTDEntities  no
--                , withSubstHTMLEntities yes
--                ...
--                ] "http://www.w3c.org/"
--   </pre>
--   
--   same as above, but with substituion of all general entity refs defined
--   in XHTML.
--   
--   for minimal complete examples see
--   <tt>Text.XML.HXT.Arrow.WriteDocument.writeDocument</tt> and
--   <a>runX</a>, the main starting point for running an XML arrow.
readDocument :: SysConfigList -> String -> IOStateArrow s b XmlTree

-- | the arrow version of <a>readDocument</a>, the arrow input is the
--   source URI
readFromDocument :: SysConfigList -> IOStateArrow s String XmlTree

-- | read a document that is stored in a normal Haskell String
--   
--   the same function as readDocument, but the parameter forms the input.
--   All options available for <a>readDocument</a> are applicable for
--   readString.
--   
--   Default encoding: No encoding is done, the String argument is taken as
--   Unicode string
readString :: SysConfigList -> String -> IOStateArrow s b XmlTree

-- | the arrow version of <a>readString</a>, the arrow input is the source
--   URI
readFromString :: SysConfigList -> IOStateArrow s String XmlTree

-- | parse a string as HTML content, substitute all HTML entity refs and
--   canonicalize tree. (substitute char refs, ...). Errors are ignored.
--   
--   This arrow delegates all work to the parseHtmlContent parser in module
--   HtmlParser.
--   
--   This is a simpler version of <a>readFromString</a> without any
--   options, but it does not run in the IO monad.
hread :: ArrowXml a => a String XmlTree

-- | parse a string as XML content, substitute all predefined XML entity
--   refs and canonicalize tree This xread arrow delegates all work to the
--   xread parser function in module XmlParsec
xread :: ArrowXml a => a String XmlTree


-- | Pickler functions for converting between user defined data types and
--   XmlTree data. Usefull for persistent storage and retreival of arbitray
--   data as XML documents.
--   
--   This module is an adaptation of the pickler combinators developed by
--   Andrew Kennedy (
--   http://research.microsoft.com/~akenn/fun/picklercombinators.pdf ).
--   
--   The difference to Kennedys approach is that the target is not a list
--   of Chars but a list of XmlTrees. The basic picklers will convert data
--   into XML text nodes. New are the picklers for creating elements and
--   attributes.
--   
--   One extension was neccessary: The unpickling may fail.
--   
--   Old: Therefore the unpickler has a Maybe result type. Failure is used
--   to unpickle optional elements (Maybe data) and lists of arbitray
--   length.
--   
--   Since hxt-9.2.0: The unpicklers are implemented as a parser monad with
--   an Either err val result type. This enables appropriate error messages
--   , when unpickling XML stuff, that is not generated with the picklers
--   and which contains some elements and/or attributes that are not
--   handled when unpickling.
--   
--   There is an example program demonstrating the use of the picklers for
--   a none trivial data structure. (see "examples/arrows/pickle" directory
--   in the hxt distribution)
module Text.XML.HXT.Arrow.Pickle.Xml
data St
St :: [XmlTree] -> [XmlTree] -> Int -> QName -> Bool -> St
attributes :: St -> [XmlTree]
contents :: St -> [XmlTree]
nesting :: St -> Int
pname :: St -> QName
pelem :: St -> Bool
data PU a
PU :: Pickler a -> Unpickler a -> Schema -> PU a
appPickle :: PU a -> Pickler a
appUnPickle :: PU a -> Unpickler a
theSchema :: PU a -> Schema
type Pickler a = a -> St -> St
newtype Unpickler a
UP :: (St -> (UnpickleVal a, St)) -> Unpickler a
runUP :: Unpickler a -> St -> (UnpickleVal a, St)
type UnpickleVal a = Either UnpickleErr a
type UnpickleErr = (String, St)
throwMsg :: String -> Unpickler a

-- | Choice combinator for unpickling
--   
--   first 2 arguments are applied sequentially, but if the 1. one fails
--   the 3. arg is applied
mchoice :: Unpickler a -> (a -> Unpickler b) -> Unpickler b -> Unpickler b

-- | Lift a Maybe value into the Unpickler monad.
--   
--   The 1. arg is the attached error message
liftMaybe :: String -> Maybe a -> Unpickler a

-- | Lift an Either value into the Unpickler monad
liftUnpickleVal :: UnpickleVal a -> Unpickler a
getCont :: Unpickler XmlTree
getAtt :: QName -> Unpickler XmlTree
getNSAtt :: String -> Unpickler ()
emptySt :: St
putAtt :: QName -> [XmlTree] -> St -> St
putCont :: XmlTree -> St -> St
findElem :: (a -> Bool) -> [a] -> Maybe (a, [a])

-- | Format the context of an error message.
formatSt :: St -> String

-- | conversion of an arbitrary value into an XML document tree.
--   
--   The pickler, first parameter, controls the conversion process. Result
--   is a complete document tree including a root node
pickleDoc :: PU a -> a -> XmlTree

-- | Conversion of an XML document tree into an arbitrary data type
--   
--   The inverse of <a>pickleDoc</a>. This law should hold for all
--   picklers: <tt> unpickle px . pickle px $ v == Just v </tt>. Not every
--   possible combination of picklers does make sense. For reconverting a
--   value from an XML tree, is becomes neccessary, to introduce "enough"
--   markup for unpickling the value
unpickleDoc :: PU a -> XmlTree -> Maybe a

-- | Like unpickleDoc but with a (sometimes) useful error message, when
--   unpickling failed.
unpickleDoc' :: PU a -> XmlTree -> Either String a

-- | The main entry for unpickling, called by unpickleDoc
unpickleElem' :: PU a -> Int -> XmlTree -> UnpickleVal a

-- | Pickles a value, then writes the document to a string.
showPickled :: XmlPickler a => SysConfigList -> a -> String

-- | The zero pickler
--   
--   Encodes nothing, fails always during unpickling
xpZero :: String -> PU a

-- | unit pickler
xpUnit :: PU ()

-- | Check EOF pickler.
--   
--   When pickling, this behaves like the unit pickler. The unpickler
--   fails, when there is some unprocessed XML contents left.
xpCheckEmptyContents :: PU a -> PU a

-- | Like xpCheckEmptyContents, but checks the attribute list
xpCheckEmptyAttributes :: PU a -> PU a

-- | Composition of xpCheckEmptyContents and xpCheckAttributes
xpCheckEmpty :: PU a -> PU a
xpLift :: a -> PU a

-- | Lift a Maybe value to a pickler.
--   
--   <tt>Nothing</tt> is mapped to the zero pickler, <tt>Just x</tt> is
--   pickled with <tt>xpLift x</tt>.
xpLiftMaybe :: Maybe a -> PU a
xpLiftEither :: Either String a -> PU a

-- | Combine two picklers sequentially.
--   
--   If the first fails during unpickling, the whole unpickler fails
xpSeq :: (b -> a) -> PU a -> (a -> PU b) -> PU b

-- | First apply a fixed pickler/unpickler, then a 2. one
--   
--   If the first fails during unpickling, the whole pickler fails. This
--   can be used to check some properties of the input, e.g. whether a
--   given fixed attribute or a namespace declaration exists
--   (<a>xpAddFixedAttr</a>, <a>xpAddNSDecl</a>) or to filter the input,
--   e.g. to ignore some elements or attributes (<a>xpFilterCont</a>,
--   <a>xpFilterAttr</a>).
--   
--   When pickling, this can be used to insert some fixed XML pieces, e.g.
--   namespace declarations, class attributes or other stuff.
xpSeq' :: PU () -> PU a -> PU a

-- | combine tow picklers with a choice
--   
--   Run two picklers in sequence like with xpSeq. When during unpickling
--   the first one fails, an alternative pickler (first argument) is
--   applied. This pickler is only used as combinator for unpickling.
xpChoice :: PU b -> PU a -> (a -> PU b) -> Unpickler b

-- | map value into another domain and apply pickler there
--   
--   One of the most often used picklers.
xpWrap :: (a -> b, b -> a) -> PU a -> PU b

-- | like <a>xpWrap</a>, but if the inverse mapping is undefined, the
--   unpickler fails
--   
--   Map a value into another domain. If the inverse mapping is undefined
--   (Nothing), the unpickler fails
--   
--   Deprecated: Use xpWrapEither, this gives better error messages
xpWrapMaybe :: (a -> Maybe b, b -> a) -> PU a -> PU b

-- | like <a>xpWrap</a>, but if the inverse mapping is undefined, the
--   unpickler fails
--   
--   Map a value into another domain. If the inverse mapping is undefined,
--   the unpickler fails with an error message in the Left component
xpWrapEither :: (a -> Either String b, b -> a) -> PU a -> PU b

-- | pickle a pair of values sequentially
--   
--   Used for pairs or together with wrap for pickling algebraic data types
--   with two components
xpPair :: PU a -> PU b -> PU (a, b)

-- | Like <a>xpPair</a> but for triples
xpTriple :: PU a -> PU b -> PU c -> PU (a, b, c)

-- | Like <a>xpPair</a> and <a>xpTriple</a> but for 4-tuples
xp4Tuple :: PU a -> PU b -> PU c -> PU d -> PU (a, b, c, d)

-- | Like <a>xpPair</a> and <a>xpTriple</a> but for 5-tuples
xp5Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU (a, b, c, d, e)

-- | Like <a>xpPair</a> and <a>xpTriple</a> but for 6-tuples
xp6Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU (a, b, c, d, e, f)

-- | Like <a>xpPair</a> and <a>xpTriple</a> but for 7-tuples
--   
--   Thanks to Tony Morris for doing xp7Tuple, ..., xp24Tuple.
xp7Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU (a, b, c, d, e, f, g)
xp8Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU (a, b, c, d, e, f, g, h)
xp9Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU (a, b, c, d, e, f, g, h, i)
xp10Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU (a, b, c, d, e, f, g, h, i, j)
xp11Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU (a, b, c, d, e, f, g, h, i, j, k)
xp12Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU (a, b, c, d, e, f, g, h, i, j, k, l)
xp13Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m)
xp14Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
xp15Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
xp16Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
xp17Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
xp18Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
xp19Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
xp20Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
xp21Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)
xp22Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU v -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)
xp23Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU v -> PU w -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)

-- | Hopefully no one needs a xp25Tuple
xp24Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU v -> PU w -> PU x -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)

-- | Pickle a string into an XML text node
--   
--   One of the most often used primitive picklers. Attention: For pickling
--   empty strings use <a>xpText0</a>. If the text has a more specific
--   datatype than xsd:string, use <a>xpTextDT</a>
xpText :: PU String

-- | Pickle a string into an XML text node
--   
--   Text pickler with a description of the structure of the text by a
--   schema. A schema for a data type can be defined by <a>scDT</a>. In
--   <tt>Text.XML.HXT.Arrow.Pickle.Schema</tt> there are some more
--   functions for creating simple datatype descriptions.
xpTextDT :: Schema -> PU String

-- | Pickle a possibly empty string into an XML node.
--   
--   Must be used in all places, where empty strings are legal values. If
--   the content of an element can be an empty string, this string
--   disapears during storing the DOM into a document and reparse the
--   document. So the empty text node becomes nothing, and the pickler must
--   deliver an empty string, if there is no text node in the document.
xpText0 :: PU String

-- | Pickle a possibly empty string with a datatype description into an XML
--   node.
--   
--   Like <a>xpText0</a> but with extra Parameter for datatype description
--   as in <a>xpTextDT</a>.
xpText0DT :: Schema -> PU String

-- | Pickle an arbitrary value by applyling show during pickling and read
--   during unpickling.
--   
--   Real pickling is then done with <a>xpText</a>. One of the most often
--   used pimitive picklers. Applicable for all types which are instances
--   of <tt>Read</tt> and <tt>Show</tt>
xpPrim :: (Read a, Show a) => PU a

-- | Pickle an Int
xpInt :: PU Int

-- | Pickle an XmlTree by just adding it
--   
--   Usefull for components of type XmlTree in other data structures
xpTree :: PU XmlTree

-- | Pickle a whole list of XmlTrees by just adding the list, unpickle is
--   done by taking all element contents.
--   
--   This pickler should always be combined with <a>xpElem</a> for taking
--   the whole contents of an element.
xpTrees :: PU [XmlTree]

-- | Pickle a string representing XML contents by inserting the tree
--   representation into the XML document.
--   
--   Unpickling is done by converting the contents with
--   <a>xshowEscapeXml</a> into a string, this function will escape all XML
--   special chars, such that pickling the value back becomes save.
--   Pickling is done with <a>xread</a>
xpXmlText :: PU String

-- | Encoding of optional data by ignoring the Nothing case during pickling
--   and relying on failure during unpickling to recompute the Nothing case
--   
--   The default pickler for Maybe types
xpOption :: PU a -> PU (Maybe a)

-- | Optional conversion with default value
--   
--   The default value is not encoded in the XML document, during
--   unpickling the default value is inserted if the pickler fails
xpDefault :: Eq a => a -> PU a -> PU a

-- | Encoding of list values by pickling all list elements sequentially.
--   
--   Unpickler relies on failure for detecting the end of the list. The
--   standard pickler for lists. Can also be used in combination with
--   <a>xpWrap</a> for constructing set and map picklers
xpList :: PU a -> PU [a]

-- | Encoding of a none empty list of values
--   
--   Attention: when calling this pickler with an empty list, an internal
--   error "head of empty list is raised".
xpList1 :: PU a -> PU [a]

-- | Standard pickler for maps
--   
--   This pickler converts a map into a list of pairs. All key value pairs
--   are mapped to an element with name (1.arg), the key is encoded as an
--   attribute named by the 2. argument, the 3. arg is the pickler for the
--   keys, the last one for the values
xpMap :: Ord k => String -> String -> PU k -> PU v -> PU (Map k v)

-- | Pickler for sum data types.
--   
--   Every constructor is mapped to an index into the list of picklers. The
--   index is used only during pickling, not during unpickling, there the
--   1. match is taken
xpAlt :: (a -> Int) -> [PU a] -> PU a

-- | Pickler for wrapping/unwrapping data into an XML element
--   
--   Extra parameter is the element name given as a QName. THE pickler for
--   constructing nested structures
--   
--   Example:
--   
--   <pre>
--   xpElemQN (mkName "number") $ xpickle
--   </pre>
--   
--   will map an (42::Int) onto
--   
--   <pre>
--   &lt;number&gt;42&lt;/number&gt;
--   </pre>
xpElemQN :: QName -> PU a -> PU a

-- | convenient Pickler for xpElemQN
--   
--   <pre>
--   xpElem n = xpElemQN (mkName n)
--   </pre>
xpElem :: String -> PU a -> PU a

-- | convenient Pickler for xpElemQN for pickling elements with respect to
--   namespaces
--   
--   <pre>
--   xpElemNS ns px lp = xpElemQN (mkQName px lp ns)
--   </pre>
xpElemNS :: String -> String -> String -> PU a -> PU a

-- | Pickler for wrapping/unwrapping data into an XML element with an
--   attribute with given value
--   
--   To make XML structures flexible but limit the number of different
--   elements, it's sometimes useful to use a kind of generic element with
--   a key value structure
--   
--   Example:
--   
--   <pre>
--   &lt;attr name="key1"&gt;value1&lt;/attr&gt;
--   &lt;attr name="key2"&gt;value2&lt;/attr&gt;
--   &lt;attr name="key3"&gt;value3&lt;/attr&gt;
--   </pre>
--   
--   the Haskell datatype may look like this
--   
--   <pre>
--   type T = T { key1 :: Int ; key2 :: String ; key3 :: Double }
--   </pre>
--   
--   Then the picker for that type looks like this
--   
--   <pre>
--   xpT :: PU T
--   xpT = xpWrap ( uncurry3 T, \ t -&gt; (key1 t, key2 t, key3 t) ) $
--         xpTriple (xpElemWithAttrValue "attr" "name" "key1" $ xpickle)
--                  (xpElemWithAttrValue "attr" "name" "key2" $ xpText0)
--                  (xpElemWithAttrValue "attr" "name" "key3" $ xpickle)
--   </pre>
xpElemWithAttrValue :: String -> String -> String -> PU a -> PU a

-- | Pickler for storing/retreiving data into/from an attribute value
--   
--   The attribute is inserted in the surrounding element constructed by
--   the <a>xpElem</a> pickler
xpAttrQN :: QName -> PU a -> PU a

-- | convenient Pickler for xpAttrQN
--   
--   <pre>
--   xpAttr n = xpAttrQN (mkName n)
--   </pre>
xpAttr :: String -> PU a -> PU a

-- | convenient Pickler for xpAttrQN
--   
--   <pre>
--   xpAttr ns px lp = xpAttrQN (mkQName px lp ns)
--   </pre>
xpAttrNS :: String -> String -> String -> PU a -> PU a

-- | A text attribute.
xpTextAttr :: String -> PU String

-- | Add an optional attribute for an optional value (Maybe a).
xpAttrImplied :: String -> PU a -> PU (Maybe a)
xpAttrFixed :: String -> String -> PU ()

-- | Add/Check an attribute with a fixed value.
xpAddFixedAttr :: String -> String -> PU a -> PU a

-- | Add a namespace declaration.
--   
--   When generating XML the namespace decl is added, when reading a
--   document, the unpickler checks whether there is a namespace
--   declaration for the given namespace URI (2. arg)
xpAddNSDecl :: String -> String -> PU a -> PU a
xpAttrNSDecl :: String -> String -> PU ()
xpIgnoreCont :: LA XmlTree XmlTree -> PU ()
xpIgnoreAttr :: LA XmlTree XmlTree -> PU ()

-- | When unpickling, filter the contents of the element currently
--   processed, before applying the pickler argument
--   
--   Maybe useful to ignore some stuff in the input, or to do some cleanup
--   before unpickling.
xpFilterCont :: LA XmlTree XmlTree -> PU a -> PU a

-- | Same as <a>xpFilterCont</a> but for the attribute list of the element
--   currently processed.
--   
--   Maybe useful to ignore some stuff in the input, e.g. class attributes,
--   or to do some cleanup before unpickling.
xpFilterAttr :: LA XmlTree XmlTree -> PU a -> PU a
xpIgnoreInput :: (([XmlTree] -> [XmlTree]) -> St -> St) -> LA XmlTree XmlTree -> PU ()

-- | The class for overloading <a>xpickle</a>, the default pickler
class XmlPickler a
xpickle :: XmlPickler a => PU a
instance Show St
instance XmlPickler a => XmlPickler (Maybe a)
instance XmlPickler a => XmlPickler [a]
instance (XmlPickler a, XmlPickler b, XmlPickler c, XmlPickler d, XmlPickler e) => XmlPickler (a, b, c, d, e)
instance (XmlPickler a, XmlPickler b, XmlPickler c, XmlPickler d) => XmlPickler (a, b, c, d)
instance (XmlPickler a, XmlPickler b, XmlPickler c) => XmlPickler (a, b, c)
instance (XmlPickler a, XmlPickler b) => XmlPickler (a, b)
instance XmlPickler ()
instance XmlPickler Integer
instance XmlPickler Int
instance MonadError UnpickleErr Unpickler
instance MonadState St Unpickler
instance Monad Unpickler


-- | Pickler functions for converting between user defined data types and
--   XmlTree data. Usefull for persistent storage and retreival of arbitray
--   data as XML documents
--   
--   This module is an adaptation of the pickler combinators developed by
--   Andrew Kennedy (
--   http://research.microsoft.com/~akenn/fun/picklercombinators.pdf )
--   
--   The difference to Kennedys approach is that the target is not a list
--   of Chars but a list of XmlTrees. The basic picklers will convert data
--   into XML text nodes. New are the picklers for creating elements and
--   attributes.
--   
--   One extension was neccessary: The unpickling may fail. Therefore the
--   unpickler has a Maybe result type. Failure is used to unpickle
--   optional elements (Maybe data) and lists of arbitray length
--   
--   There is an example program demonstrating the use of the picklers for
--   a none trivial data structure. (see "examples/arrows/pickle"
--   directory)
module Text.XML.HXT.Arrow.Pickle

-- | store an arbitray value in a persistent XML document
--   
--   The pickler converts a value into an XML tree, this is written out
--   with <tt>Text.XML.HXT.Arrow.writeDocument</tt>. The option list is
--   passed to <tt>Text.XML.HXT.Arrow.writeDocument</tt>
--   
--   An option evaluated by this arrow is <a>a_addDTD</a>. If
--   <a>a_addDTD</a> is set (<a>v_1</a>), the pickler DTD is added as an
--   inline DTD into the document.
xpickleDocument :: PU a -> SysConfigList -> String -> IOStateArrow s a XmlTree

-- | read an arbitray value from an XML document
--   
--   The document is read with <tt>Text.XML.HXT.Arrow.readDocument</tt>.
--   Options are passed to <tt>Text.XML.HXT.Arrow.readDocument</tt>. The
--   conversion from XmlTree is done with the pickler.
--   
--   <tt> xpickleDocument xp al dest &gt;&gt;&gt; xunpickleDocument xp al'
--   dest </tt> is the identity arrow when applied with the appropriate
--   options. When during pickling indentation is switched on, the
--   whitespace must be removed during unpickling.
xunpickleDocument :: PU a -> SysConfigList -> String -> IOStateArrow s b a

-- | Write out the DTD generated out of a pickler. Calls
--   <tt>xpicklerDTD</tt>
xpickleWriteDTD :: PU b -> SysConfigList -> String -> IOStateArrow s b XmlTree

-- | The arrow for generating the DTD out of a pickler
--   
--   A DTD is generated from a pickler and check for consistency. Errors
--   concerning the DTD are issued.
xpickleDTD :: PU b -> IOStateArrow s b XmlTree

-- | An arrow for checking picklers
--   
--   A value is transformed into an XML document by a given pickler, the
--   associated DTD is extracted from the pickler and checked, the document
--   including the DTD is tranlated into a string, this string is read and
--   validated against the included DTD, and unpickled. The last step is
--   the equality with the input.
--   
--   If the check succeeds, the arrow works like this, else it fails.
checkPickler :: Eq a => PU a -> IOStateArrow s a a

-- | The arrow version of the pickler function
xpickleVal :: ArrowXml a => PU b -> a b XmlTree

-- | The arrow version of the unpickler function
xunpickleVal :: PU b -> IOStateArrow s XmlTree b

-- | Compute the associated DTD of a pickler
thePicklerDTD :: PU b -> XmlTrees

-- | Option for generating and adding DTD when document is pickled
a_addDTD :: String

-- | conversion of an arbitrary value into an XML document tree.
--   
--   The pickler, first parameter, controls the conversion process. Result
--   is a complete document tree including a root node
pickleDoc :: PU a -> a -> XmlTree

-- | Conversion of an XML document tree into an arbitrary data type
--   
--   The inverse of <a>pickleDoc</a>. This law should hold for all
--   picklers: <tt> unpickle px . pickle px $ v == Just v </tt>. Not every
--   possible combination of picklers does make sense. For reconverting a
--   value from an XML tree, is becomes neccessary, to introduce "enough"
--   markup for unpickling the value
unpickleDoc :: PU a -> XmlTree -> Maybe a

-- | Like unpickleDoc but with a (sometimes) useful error message, when
--   unpickling failed.
unpickleDoc' :: PU a -> XmlTree -> Either String a

-- | Pickles a value, then writes the document to a string.
showPickled :: XmlPickler a => SysConfigList -> a -> String
data PU a
PU :: Pickler a -> Unpickler a -> Schema -> PU a
appPickle :: PU a -> Pickler a
appUnPickle :: PU a -> Unpickler a
theSchema :: PU a -> Schema

-- | The class for overloading <a>xpickle</a>, the default pickler
class XmlPickler a
xpickle :: XmlPickler a => PU a

-- | Like <a>xpPair</a> and <a>xpTriple</a> but for 4-tuples
xp4Tuple :: PU a -> PU b -> PU c -> PU d -> PU (a, b, c, d)

-- | Like <a>xpPair</a> and <a>xpTriple</a> but for 5-tuples
xp5Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU (a, b, c, d, e)

-- | Like <a>xpPair</a> and <a>xpTriple</a> but for 6-tuples
xp6Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU (a, b, c, d, e, f)

-- | Like <a>xpPair</a> and <a>xpTriple</a> but for 7-tuples
--   
--   Thanks to Tony Morris for doing xp7Tuple, ..., xp24Tuple.
xp7Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU (a, b, c, d, e, f, g)
xp8Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU (a, b, c, d, e, f, g, h)
xp9Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU (a, b, c, d, e, f, g, h, i)
xp10Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU (a, b, c, d, e, f, g, h, i, j)
xp11Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU (a, b, c, d, e, f, g, h, i, j, k)
xp12Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU (a, b, c, d, e, f, g, h, i, j, k, l)
xp13Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m)
xp14Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
xp15Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
xp16Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
xp17Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
xp18Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
xp19Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
xp20Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
xp21Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)
xp22Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU v -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)
xp23Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU v -> PU w -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)

-- | Hopefully no one needs a xp25Tuple
xp24Tuple :: PU a -> PU b -> PU c -> PU d -> PU e -> PU f -> PU g -> PU h -> PU i -> PU j -> PU k -> PU l -> PU m -> PU n -> PU o -> PU p -> PU q -> PU r -> PU s -> PU t -> PU u -> PU v -> PU w -> PU x -> PU (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)

-- | Add/Check an attribute with a fixed value.
xpAddFixedAttr :: String -> String -> PU a -> PU a

-- | Add a namespace declaration.
--   
--   When generating XML the namespace decl is added, when reading a
--   document, the unpickler checks whether there is a namespace
--   declaration for the given namespace URI (2. arg)
xpAddNSDecl :: String -> String -> PU a -> PU a

-- | Pickler for sum data types.
--   
--   Every constructor is mapped to an index into the list of picklers. The
--   index is used only during pickling, not during unpickling, there the
--   1. match is taken
xpAlt :: (a -> Int) -> [PU a] -> PU a

-- | convenient Pickler for xpAttrQN
--   
--   <pre>
--   xpAttr n = xpAttrQN (mkName n)
--   </pre>
xpAttr :: String -> PU a -> PU a
xpAttrFixed :: String -> String -> PU ()

-- | Add an optional attribute for an optional value (Maybe a).
xpAttrImplied :: String -> PU a -> PU (Maybe a)

-- | convenient Pickler for xpAttrQN
--   
--   <pre>
--   xpAttr ns px lp = xpAttrQN (mkQName px lp ns)
--   </pre>
xpAttrNS :: String -> String -> String -> PU a -> PU a

-- | Composition of xpCheckEmptyContents and xpCheckAttributes
xpCheckEmpty :: PU a -> PU a

-- | Like xpCheckEmptyContents, but checks the attribute list
xpCheckEmptyAttributes :: PU a -> PU a

-- | Check EOF pickler.
--   
--   When pickling, this behaves like the unit pickler. The unpickler
--   fails, when there is some unprocessed XML contents left.
xpCheckEmptyContents :: PU a -> PU a

-- | A text attribute.
xpTextAttr :: String -> PU String

-- | combine tow picklers with a choice
--   
--   Run two picklers in sequence like with xpSeq. When during unpickling
--   the first one fails, an alternative pickler (first argument) is
--   applied. This pickler is only used as combinator for unpickling.
xpChoice :: PU b -> PU a -> (a -> PU b) -> Unpickler b

-- | Optional conversion with default value
--   
--   The default value is not encoded in the XML document, during
--   unpickling the default value is inserted if the pickler fails
xpDefault :: Eq a => a -> PU a -> PU a

-- | convenient Pickler for xpElemQN
--   
--   <pre>
--   xpElem n = xpElemQN (mkName n)
--   </pre>
xpElem :: String -> PU a -> PU a

-- | convenient Pickler for xpElemQN for pickling elements with respect to
--   namespaces
--   
--   <pre>
--   xpElemNS ns px lp = xpElemQN (mkQName px lp ns)
--   </pre>
xpElemNS :: String -> String -> String -> PU a -> PU a

-- | Pickler for wrapping/unwrapping data into an XML element with an
--   attribute with given value
--   
--   To make XML structures flexible but limit the number of different
--   elements, it's sometimes useful to use a kind of generic element with
--   a key value structure
--   
--   Example:
--   
--   <pre>
--   &lt;attr name="key1"&gt;value1&lt;/attr&gt;
--   &lt;attr name="key2"&gt;value2&lt;/attr&gt;
--   &lt;attr name="key3"&gt;value3&lt;/attr&gt;
--   </pre>
--   
--   the Haskell datatype may look like this
--   
--   <pre>
--   type T = T { key1 :: Int ; key2 :: String ; key3 :: Double }
--   </pre>
--   
--   Then the picker for that type looks like this
--   
--   <pre>
--   xpT :: PU T
--   xpT = xpWrap ( uncurry3 T, \ t -&gt; (key1 t, key2 t, key3 t) ) $
--         xpTriple (xpElemWithAttrValue "attr" "name" "key1" $ xpickle)
--                  (xpElemWithAttrValue "attr" "name" "key2" $ xpText0)
--                  (xpElemWithAttrValue "attr" "name" "key3" $ xpickle)
--   </pre>
xpElemWithAttrValue :: String -> String -> String -> PU a -> PU a

-- | Pickle an Int
xpInt :: PU Int
xpLift :: a -> PU a
xpLiftEither :: Either String a -> PU a

-- | Lift a Maybe value to a pickler.
--   
--   <tt>Nothing</tt> is mapped to the zero pickler, <tt>Just x</tt> is
--   pickled with <tt>xpLift x</tt>.
xpLiftMaybe :: Maybe a -> PU a

-- | Encoding of list values by pickling all list elements sequentially.
--   
--   Unpickler relies on failure for detecting the end of the list. The
--   standard pickler for lists. Can also be used in combination with
--   <a>xpWrap</a> for constructing set and map picklers
xpList :: PU a -> PU [a]

-- | Encoding of a none empty list of values
--   
--   Attention: when calling this pickler with an empty list, an internal
--   error "head of empty list is raised".
xpList1 :: PU a -> PU [a]

-- | Standard pickler for maps
--   
--   This pickler converts a map into a list of pairs. All key value pairs
--   are mapped to an element with name (1.arg), the key is encoded as an
--   attribute named by the 2. argument, the 3. arg is the pickler for the
--   keys, the last one for the values
xpMap :: Ord k => String -> String -> PU k -> PU v -> PU (Map k v)

-- | Encoding of optional data by ignoring the Nothing case during pickling
--   and relying on failure during unpickling to recompute the Nothing case
--   
--   The default pickler for Maybe types
xpOption :: PU a -> PU (Maybe a)

-- | pickle a pair of values sequentially
--   
--   Used for pairs or together with wrap for pickling algebraic data types
--   with two components
xpPair :: PU a -> PU b -> PU (a, b)

-- | Pickle an arbitrary value by applyling show during pickling and read
--   during unpickling.
--   
--   Real pickling is then done with <a>xpText</a>. One of the most often
--   used pimitive picklers. Applicable for all types which are instances
--   of <tt>Read</tt> and <tt>Show</tt>
xpPrim :: (Read a, Show a) => PU a

-- | Combine two picklers sequentially.
--   
--   If the first fails during unpickling, the whole unpickler fails
xpSeq :: (b -> a) -> PU a -> (a -> PU b) -> PU b

-- | Pickle a string into an XML text node
--   
--   One of the most often used primitive picklers. Attention: For pickling
--   empty strings use <a>xpText0</a>. If the text has a more specific
--   datatype than xsd:string, use <a>xpTextDT</a>
xpText :: PU String

-- | Pickle a possibly empty string into an XML node.
--   
--   Must be used in all places, where empty strings are legal values. If
--   the content of an element can be an empty string, this string
--   disapears during storing the DOM into a document and reparse the
--   document. So the empty text node becomes nothing, and the pickler must
--   deliver an empty string, if there is no text node in the document.
xpText0 :: PU String

-- | Pickle a string into an XML text node
--   
--   Text pickler with a description of the structure of the text by a
--   schema. A schema for a data type can be defined by <a>scDT</a>. In
--   <tt>Text.XML.HXT.Arrow.Pickle.Schema</tt> there are some more
--   functions for creating simple datatype descriptions.
xpTextDT :: Schema -> PU String

-- | Pickle a possibly empty string with a datatype description into an XML
--   node.
--   
--   Like <a>xpText0</a> but with extra Parameter for datatype description
--   as in <a>xpTextDT</a>.
xpText0DT :: Schema -> PU String

-- | Pickle an XmlTree by just adding it
--   
--   Usefull for components of type XmlTree in other data structures
xpTree :: PU XmlTree

-- | Pickle a whole list of XmlTrees by just adding the list, unpickle is
--   done by taking all element contents.
--   
--   This pickler should always be combined with <a>xpElem</a> for taking
--   the whole contents of an element.
xpTrees :: PU [XmlTree]

-- | Like <a>xpPair</a> but for triples
xpTriple :: PU a -> PU b -> PU c -> PU (a, b, c)

-- | unit pickler
xpUnit :: PU ()

-- | map value into another domain and apply pickler there
--   
--   One of the most often used picklers.
xpWrap :: (a -> b, b -> a) -> PU a -> PU b

-- | like <a>xpWrap</a>, but if the inverse mapping is undefined, the
--   unpickler fails
--   
--   Map a value into another domain. If the inverse mapping is undefined,
--   the unpickler fails with an error message in the Left component
xpWrapEither :: (a -> Either String b, b -> a) -> PU a -> PU b

-- | like <a>xpWrap</a>, but if the inverse mapping is undefined, the
--   unpickler fails
--   
--   Map a value into another domain. If the inverse mapping is undefined
--   (Nothing), the unpickler fails
--   
--   Deprecated: Use xpWrapEither, this gives better error messages
xpWrapMaybe :: (a -> Maybe b, b -> a) -> PU a -> PU b

-- | Pickle a string representing XML contents by inserting the tree
--   representation into the XML document.
--   
--   Unpickling is done by converting the contents with
--   <a>xshowEscapeXml</a> into a string, this function will escape all XML
--   special chars, such that pickling the value back becomes save.
--   Pickling is done with <a>xread</a>
xpXmlText :: PU String

-- | The zero pickler
--   
--   Encodes nothing, fails always during unpickling
xpZero :: String -> PU a

-- | The datatype for modelling the structure of an
data Schema
type Schemas = [Schema]
data DataTypeDescr


-- | Regular Expression Matcher working on lists of XmlTrees
--   
--   It's intendet to import this module with an explicit import
--   declaration for not spoiling the namespace with these somewhat special
--   arrows
module Text.XML.HXT.Arrow.XmlRegex
data XmlRegex
mkZero :: String -> XmlRegex
mkUnit :: XmlRegex
mkPrim :: (XmlTree -> Bool) -> XmlRegex
mkPrimA :: LA XmlTree XmlTree -> XmlRegex
mkDot :: XmlRegex
mkStar :: XmlRegex -> XmlRegex
mkAlt :: XmlRegex -> XmlRegex -> XmlRegex
mkAlts :: [XmlRegex] -> XmlRegex
mkSeq :: XmlRegex -> XmlRegex -> XmlRegex
mkSeqs :: [XmlRegex] -> XmlRegex
mkRep :: Int -> XmlRegex -> XmlRegex
mkRng :: Int -> Int -> XmlRegex -> XmlRegex
mkOpt :: XmlRegex -> XmlRegex
nullable :: XmlRegex -> Bool
delta :: XmlRegex -> XmlTree -> XmlRegex

-- | match a sequence of XML trees with a regular expression over trees
--   
--   If the input matches, the result is Nothing, else Just an error
--   message is returned
matchXmlRegex :: XmlRegex -> XmlTrees -> Maybe String

-- | split a sequence of XML trees into a pair of a a matching prefix and a
--   rest
--   
--   If there is no matching prefix, Nothing is returned
splitXmlRegex :: XmlRegex -> XmlTrees -> Maybe (XmlTrees, XmlTrees)

-- | scan a sequence of XML trees and split it into parts matching the
--   given regex
--   
--   If the parts cannot be split because of a missing match, or because of
--   the empty sequence as match, Nothing is returned
scanXmlRegex :: XmlRegex -> XmlTrees -> Maybe [XmlTrees]

-- | check whether a sequence of XmlTrees match an Xml regular expression
--   
--   The arrow for <a>matchXmlRegex</a>.
--   
--   The expession is build up from simple arrows acting as predicate
--   (<a>mkPrimA</a>) for an XmlTree and of the usual cobinators for
--   sequence (<a>mkSeq</a>), repetition (<a>mkStar</a>, mkRep',
--   <a>mkRng</a>) and choice (<a>mkAlt</a>, <a>mkOpt</a>)
matchRegexA :: XmlRegex -> LA XmlTree XmlTree -> LA XmlTree XmlTrees

-- | split the sequence of trees computed by the filter a into
--   
--   The arrow for <a>splitXmlRegex</a>.
--   
--   a first part matching the regex and a rest, if a prefix of the input
--   sequence does not match the regex, the arrow fails else the pair
--   containing the result lists is returned
splitRegexA :: XmlRegex -> LA XmlTree XmlTree -> LA XmlTree (XmlTrees, XmlTrees)

-- | scan the input sequence with a regex and give the result as a list of
--   lists of trees back the regex must at least match one input tree, so
--   the empty sequence should not match the regex
--   
--   The arrow for <a>scanXmlRegex</a>.
scanRegexA :: XmlRegex -> LA XmlTree XmlTree -> LA XmlTree XmlTrees
instance Show XmlRegex


-- | De-/Serialisation arrows for XmlTrees and other arbitrary values with
--   a Binary instance
module Text.XML.HXT.Arrow.Binary
readBinaryValue :: Binary a => String -> IOStateArrow s b a

-- | Serialize a value, optionally compress it, and write it to a file. In
--   case of an error, the error message is issued and the arrow fails
writeBinaryValue :: Binary a => String -> IOStateArrow s a ()


-- | The HXT arrow interface
--   
--   The application programming interface to the arrow modules of the
--   Haskell XML Toolbox. This module exports all important arrows for
--   input, output, parsing, validating and transforming XML. It also
--   exports all basic datatypes and functions of the toolbox.
module Text.XML.HXT.Core