!q .      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                           !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! ! !!!!!!!!!!!!!!!!!!! !!!"!#!$!%!&!'!(!)!*!+!,!-!.!/!0!1!2!3!4!5!6!7!8!9!:!;!<!=!>!?!@!A!B!C!D!E!F!G!H!I!J!K!L!M!N!O!P!Q!R!S!T!U!V!W!X!Y!Z![!\!]!^!_!`!a!b!c!d!e!f!g!h!i!j!k!l!m!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! ! !!!!!!!!!!!!!!!!!!! "!"""#"$"%"&"'"(")"*"+","-"."/"0"1"2"3"4"5"6"7"8"9":";"<"=">"?"@"A"B"C"D"E"F"G"H"I"J"K"L"M"N"O"P"Q"R"S"T"U"V"W"X"Y"Z"["\"]"^"_"`"a"b"c#d#e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~##############################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%&&&&&''''''''''''''''((((((((((((((())) ) ) ) ) ))))))))))))))))))) *!*"*#*$*%*&*'*(*)***+*,+-++SafeEXmRHaXmlString holds default value. HaXmlNon-empty lists. HaXmlXML's contentspec allows ANYHaXmlmixed (#PCDATA | ... )*HaXmlstring only (#PCDATA)HaXmlBool for main/aux.HaXml9Need to keep both the XML and Haskell versions of a name.HaXmloriginal XML nameHaXmlmangled Haskell nameHaXmlPretty print Haskell name.HaXmlPretty print XML name.HaXml%Pretty print Haskell attributes name.HaXml/Make a type name valid in both XML and Haskell.HaXml8Append an underscore to the Haskell version of the name. HaXmlNPrefix an attribute enumeration type name with its containing element name.!HaXmlhPrefix an attribute enumeration constructor with its element-tag name, and its enumeration type name."HaXml4Prefix a field name with its enclosing element name.#HaXml'Convert an XML name to a Haskell conid..HaXmlFEnsure a generated name does not conflict with a standard haskell one.$HaXml'Convert an XML name to a Haskell varid./HaXml-Convert colon to prime, hyphen to underscore.    !"#$    !"#$SafeEXpo)HaXml<Convert typedef to appropriate instance declaration, either  XmlContent,  XmlAttributes, or  XmlAttrType.))SafeEX}*HaXmlSource positions contain a filename, line, column, and an inclusion point, which is itself another source position, recursively..HaXmlODummy value for generated data, where a true source position does not exist./HaXmlposInNewCxt name pos creates a new source position from an old one. It is used when opening a new file (e.g. a DTD inclusion), to denote the start of the file nameJ, but retain the stacked information that it was included from the old pos.0HaXmlRJust used to strictify the internal values of a position, to avoid space leaks.1HaXml0Add n character positions to the given position.2HaXml+Add a newline or tab to the given position.3HaXml+Add a newline or tab to the given position.4HaXmlFAdd the given whitespace char to the given position. Precondition: white c | isSpace c = True *+,-./01234 */.01234+,-SafeEX%AHaXmlThe basic token type.BHaXml<!--CHaXml->DHaXml<?EHaXml?>FHaXml<![GHaXml]]>HHaXmlCDATA INCLUDE IGNORE etcIHaXml<!JHaXmlDOCTYPE ELEMENT ATTLIST etcKHaXml</LHaXml/>MHaXml<NHaXml OHaXml[PHaXml]QHaXml=RHaXml?SHaXml*THaXml+UHaXml&VHaXml;WHaXml#XHaXml(YHaXml)ZHaXml|[HaXml%\HaXml,]HaXml'' or ""^HaXmlbegins with letter, no spaces_HaXmlany character data`HaXml fake tokenaHaXml lexical errorbHaXml`All tokens are paired up with a source position. Lexical errors are passed back as a special TokenT value.cHaXmlThe first argument to c is the filename (used for source positions, especially in error messages), and the second is the string content of the XML file.dHaXmld is used when the parser expands a macro (PE reference). The expansion of the macro must be re-lexed as if for the first time.eHaXmle1 is used solely within parsing an entityvalue. Normally, a PERef is logically separated from its surroundings by whitespace. But in an entityvalue, a PERef can be juxtaposed to an identifier, so the expansion forms a new identifier. Thus the need to rescan the whole text for possible PERefs./789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde/cdebABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a;<=>?@789:SafeEX~HaXmlANamespaces are not defined in the XML spec itself, but at http://www.w3.org/TR/xml-namesHaXmlGA QName is a (possibly) qualified name, in the sense of XML namespaces.HaXmlJust OneHaXml Zero Or OneHaXml Zero Or MoreHaXml One Or MoreHaXml)bool is whether whitespace is significantHaXml\The symbol table stored in a document holds all its general entity reference definitions.mnopqrstuvwxyz{|}~ xy vwstuqrop~}|{znm SafeEXUHaXmlxThis instance is pretty unsatisfactory, and is useful only for building environments involving recursive modules. The mappend! method is left-biased, and the mempty* value contains lots of undefined values.klmnopqtrsuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=C>A?@BDEFGHIJKLMNOPQklmnopqtrsuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=C>A?@BDEFGHIJKLMNOPQSafe=EX)HaXml|Ultimately, an XML parser will find some plain text as the content of a simpleType, which will need to be parsed. We use a TextParser, because values of simpleTypes can also be given elsewhere, e.g. as attribute values in an XSD definition, e.g. to restrict the permissible values of the simpleType. Such restrictions are therefore implemented as layered parsers.0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~W SafeEQX aHaXml'The null Namespace (no prefix, no URI).bHaXmlfEvery Name can be split into a Namespace and local Name. The Namespace might of course be missing.cHaXml;Return the (possibly absent) Namespace component of a Name.dHaXml<Return the local component of a Name, without its Namespace.eHaXmleReturn the printable string for a Name, i.e. attaching a prefix for its namespace (if it has one).fHaXmlfM splits a Name of the form "pr:nm" into the prefix "pr" and local name "nm", and looks up the prefix in the given environment to determine its Namespace. There may also be a default namespace (the first argument) for unqualified names. In the absence of a default Namespace, a Name that does not have a prefix remains unqualified. A prefix that is not known in the environment becomes a fresh namespace with null URI. A Name that is already qualified is passed unchanged, unless its URI was null, in which case we check afresh for that prefix in the environment.gHaXmlg has the same signature as f{, but ignores the arguments for default namespace and environment, and simply removes any pre-existing qualification.hHaXmlh converts names to qualified names, except where an existing qualification matches the default namespace, in which case the qualification is removed. (This is useful when translating QNames to Haskell, because Haskell qualified names cannot use the current module name.)iHaXmlOThe initial Namespace environment. It always has bindings for the prefixes xml and xmlns.jHaXmleAdd a fresh Namespace into the Namespace environment. It is not permitted to rebind the prefixes xml or xmlns", but that is not checked here.kHaXml)resolveAllNames in a document, causes every name to be properly qualified with its namespace. There is a default namespace for any name that was originally unqualified. This is likely only useful when dealing with parsed document, less useful when generating a document from scratch. abcdefghijk abcdefghijk SafeEX lHaXmlA NameConverter is a collection of functions that convert an XName into an HName, for various Haskell namespaces. You can define your own arbitrary resolver, but should ensure that you abide by the Haskell rules for conid, varid, etc.sHaXmlfor forward type declsuHaXmlAn HName is a resolved version of an XName. It should conform to the various namespace rules, and may already include a module qualifier if appropriate.wHaXmlAn XName just holds the original XSD qualified name. It does not ensure that the string conforms to any rules of the various Haskell namespaces. Use a NameConverter to define how you would like names to be mangled.yHaXml?A simple default set of rules for resolving XNames into HNames.zHaXml7Character escapes to create a valid Haskell identifier.{HaXml6Ensure that a string does not match a Haskell keyword.|HaXmlA specialised module-name converter for FpML module names with multiple dashes, including version numbers, e.g. fpml-dividend-swaps-4-7.xsd becomes FpML.V47.Swaps.Dividend but fpml-posttrade-execution-4-7.xsd becomes FpML.V47.PostTrade.Execution}HaXmlkChop a list into segments, at separators identified by the predicate. The separator items are discarded.~HaXml>Remove any prefix directory names, and given suffix extension.lmnopqrstuvwxyz{|}~lmnopqrstuvwxyz{|}~ SafeEXp SafeEXHaXmlA concrete representation of any user-defined Haskell constructor. The constructor has a name, and a sequence of component types. The first sequence of types represents the minimum set of free type variables occurring in the (second) list of real component types. If there are fieldnames, they are contained in the final list, and correspond one-to-one with the component types.HaXml.A concrete representation of any Haskell type.HaXml"separate Haskell name and XML nameHaXmlA user-defined type has a name, a sequence of type variables, and a set of constructors. (The variables might already be instantiated to actual types.)HaXml HTypeableW promises that we can create an explicit representation of of the type of any value.HaXmleProject the n'th constructor from an HType and convert it to a string suitable for an XML tagname.HaXml^ converts a concrete representation of the Haskell type of a value (obtained by the method ) into a real DocTypeDecl. It ensures that PERefs are defined before they are used, and that no element or attribute-list is declared more than once.NoneEXHaXml=XParser is just a specialisation of the PolyStateLazy parser.HaXmlTo parse a whole document, xmlParse file content takes a filename (for generating error reports) and the string content of that file. A parse error causes program failure, with message to stderr.HaXmlTo parse just a DTD, dtdParse file contentz takes a filename (for generating error reports) and the string content of that file. If no DTD was found, you get Nothing^ rather than an error. However, if a DTD is found but contains errors, the program crashes.HaXmlMTo parse a partial document, e.g. from an XML-based stream protocol, where you may later want to get more document elements from the same stream. Arguments are: a parser for the item you want, and the already-lexed input to parse from. Returns the item you wanted (or an error message), plus the remainder of the input.HaXml2Some empty symbol tables for GE and PE references.HaXmlHReturn the next token from the input only if it matches the given token.HaXmlReturn a qualified name (although the namespace qualification is not processed here; this is merely to get the correct type).HaXml6Return just a name, e.g. element name, attribute name.HaXmlAReturn an entire XML document including prolog and trailing junk.HaXmlReturn an XML comment.HaXmlParse a processing instruction.HaXml(Return a DOCTYPE decl, indicating a DTD.HaXml4Return a DTD markup decl, e.g. ELEMENT, ATTLIST, etcHaXml:Return a complete element including all its inner content.HaXml>Parse only the parts between angle brackets in an element tag.HaXmlGFor use with stream parsers - returns the complete opening element tag.HaXmlcFor use with stream parsers - accepts a closing tag, provided it matches the given element name.HaXml=Return a content particle, e.g. text, element, reference, etcHaXmlCReturn either a general entity reference, or a character reference.HaXml3Return parsed freetext (i.e. until the next markup)NoneEXCHaXml9XParser is just a specialisation of the PolyState parser.HaXmlTo parse a whole document, xmlParse file content takes a filename (for generating error reports) and the string content of that file. A parse error causes program failure, with message to stderr.HaXmlTo parse just a DTD, dtdParse file contentz takes a filename (for generating error reports) and the string content of that file. If no DTD was found, you get Nothing^ rather than an error. However, if a DTD is found but contains errors, the program crashes.HaXmlTo parse a whole document, xmlParse' file content takes a filename (for generating error reports) and the string content of that file. Any parse error message is passed back to the caller through the Either type.HaXmlTo parse just a DTD, dtdParse' file contentz takes a filename (for generating error reports) and the string content of that file. If no DTD was found, you get  Right Nothing7. If a DTD was found but contains errors, you get a  Left message.HaXmlMTo parse a partial document, e.g. from an XML-based stream protocol, where you may later want to get more document elements from the same stream. Arguments are: a parser for the item you want, and the already-lexed input to parse from. Returns the item you wanted (or an error message), plus the remainder of the input.HaXml2Some empty symbol tables for GE and PE references.HaXmlHReturn the next token from the input only if it matches the given token.HaXmlReturn a qualified name (although the namespace qualification is not processed here; this is merely to get the correct type).HaXml6Return just a name, e.g. element name, attribute name.HaXmlAReturn an entire XML document including prolog and trailing junk.HaXmlReturn an XML comment.HaXmlParse a processing instruction.HaXml(Return a DOCTYPE decl, indicating a DTD.HaXml4Return a DTD markup decl, e.g. ELEMENT, ATTLIST, etcHaXml:Return a complete element including all its inner content.HaXml>Parse only the parts between angle brackets in an element tag.HaXmlGFor use with stream parsers - returns the complete opening element tag.HaXmlcFor use with stream parsers - accepts a closing tag, provided it matches the given element name.HaXml=Return a content particle, e.g. text, element, reference, etcHaXmlCReturn either a general entity reference, or a character reference.HaXml3Return parsed freetext (i.e. until the next markup)NoneEXO^ HaXml)A doctype declaration occured(<!DOCTYPE>)HaXml'A processing instruction occured (<??>)HaXmlA comment occured (<!-- -->)HaXmlAn element was opened (<>)HaXmlAn element was closed (</>)HaXml(An element without content occured (</>)HaXmlSome string data occuredHaXmlA reference occuredHaXmlsaxParse file contentS takes a filename and the string content of that file and generates a stream of  SaxElementOs. If an error occurs, the parsing stops and a string is returned using the Maybe type.HaXml The filenameHaXmlThe content of the fileHaXml#A tuple of the parsed elements and Nothing, if no error occured, or Just String if an error occured.  SafeEXONoneEXSHaXmlThe first argument is the name of the file, the second is the string contents of the file. The result is the generic representation of an XML document. Any errors cause program failure with message to stderr.SafeEX[-HaXmlThe first argument is the name of the file, the second is the string contents of the file. The result is the generic representation of an XML document. Any errors cause program failure with message to stderr.HaXmlThe first argument is the name of the file, the second is the string contents of the file. The result is the generic representation of an XML document. Any parsing errors are returned in the Either type.SafeEX[SafeEX\SafeEX7*HaXmlpA LabelFilter is like a CFilter except that it pairs up a polymorphic value (label) with each of its results.HaXml*Conjoin the two branches of a conditional.HaXml!All document transformations are content filters!. A filter takes a single XML $ value and returns a sequence of  values, possibly empty.HaXml>Throw away current node, keep just the (unprocessed) children.HaXml Select the n"'th positional result of a filter. HaXml!For a mandatory attribute field,  find key cont- looks up the value of the attribute name key, and applies the continuation cont to the value. HaXml+When an attribute field may be absent, use iffind key yes noE to lookup its value. If the attribute is absent, it acts as the no% filter, otherwise it applies the yes filter. HaXml ifTxt yes no( processes any textual content with the yes- filter, but otherwise is the same as the no filter. HaXml8Select between the two branches of a joined conditional. HaXml Sequential (Irish, backwards ) compositionHaXmlBinary parallel composition. Each filter uses a copy of the input, rather than one filter using the result of the other. (Has a more general type than just CFilter.)HaXmloGlue a list of filters together. (A list version of union; also has a more general type than just CFilter.)HaXmlA special form of filter composition where the second filter works over the same data as the first, but also uses the first's result.HaXml)Process children using specified filters.HaXmlDirectional choice: in f |>| g, give g-productions only if no f-productionsHaXml Pruning: in f  gG, keep only those f-productions which have at least one g-productionHaXml Pruning: in f  g>, keep only those f-productions which have no g-productionsHaXml Pronounced slash, f /> g means g inside fHaXml Pronounced outside, f </ g means f containing gHaXml7Join an element-matching filter with a text-only filterHaXml7Express a list of filters like an XPath query, e.g. Apath [children, tag "name1", attr "attr1", children, tag "name2"] is like the XPath query /name1[@attr1]/name2.HaXmlInterior editing: f  g applies f only when the predicate g1 succeeds, otherwise the content is unchanged.HaXmlInterior editing: g  f applies f only when the predicate g1 succeeds, otherwise the content is discarded.HaXmlProcess CHildren In Place. The filter is applied to any children of an element content, and the element rebuilt around the results.HaXmlProcess an element In Place. The filter is applied to the element itself, and then the original element rebuilt around the results. HaXmlRecursively process an element in place. That is, the filter is applied to the element itself, then recursively to the results of the filter, all the way to the bottom, then the original element rebuilt around the final results.!HaXmlGRecursive application of filters: a fold-like operator. Defined as f   chip (foldXml f)."HaXmlfBuild an element with the given tag name - its content is the results of the given list of filters.#HaXml>Build an element with the given name, attributes, and content.$HaXmlBuild some textual content.%HaXmlBuild some CDATA content.&HaXml4Rename an element tag (leaving attributes in place).'HaXml<Replace the attributes of an element (leaving tag the same).(HaXmlrAdd the desired attribute name and value to the topmost element, without changing the element in any other way.)HaXmlACompose a label-processing filter with a label-generating filter.*HaXmlECombine labels. Think of this as a pair-wise zip on labels. e.g.  (numbered * tagged)+HaXml"Number the results from 1 upwards.,HaXmlIn interspersed a f b, label each result of f with the string a?, except for the last one which is labelled with the string b.-HaXmlfLabel each element in the result with its tag name. Non-element results get an empty string label..HaXmlLabel each element in the result with the value of the named attribute. Elements without the attribute, and non-element results, get an empty string label./HaXmlcLabel each textual part of the result with its text. Element results get an empty string label.0HaXml?Label each content with some information extracted from itself.6      !"#$%&'()*+,-./06     !"#$%&'( )*+,-./0 3 3 5555665544)5SafeEX,123456789:;<=>?@ABCDEFGHIJKLMNO123456789BCDEFG:;<=>MN?@AHIJKLOSafeEXrPQRSTUPTSRQU665simons@cryp.to experimentalportableSafeEXVHaXml&This class promises that the function WT knows how to format this data type into a string without changing the formatting.YHaXmlfThis is a helper function is required because Haskell does not allow to make an ordinary tuple (like x) an instance of a class. The resulting output will preface the actual attribute with a single blank so that lists of <s can be handled implicitly by the definition for lists of V data types.VWXYXVWYSafeEXaHaXmlRGet the main element of the document so that you can apply CFilters directly. i/ is typically (posInNewCxt "filename" Nothing) bHaXmldIf you know that your CFilter returns a tag, you can use this function to get the tagged Element.abcdabcdSafeEXKeeNoneEXzfHaXmlThis useful auxiliary checks the commandline arguments for two filenames, the input and output file respectively. If either is missing, it is replaced by C, which can be interpreted by the caller as stdin and/or stdout.gHaXml The wrapper processXmlWith returns an IO () computation that collects the filenames (or stdin/stdout) to use when reading/writing XML documents. Its CFilter argument is applied to transform the XML document from the input and write it to the output. No DTD is attached to the output.If the input filename ends with .html or .htm, it is parsed using the error-correcting HTML parser rather than the strict XML parser.hHaXml The wrapper  onContentn simply applies a given content filter to a document. Ambiguous or empty results raise an error exception.fghfghSafeEX{iHaXml}The List1 type represents lists with at least one element. It is required for DTD content models that use + as a modifier.kHaXmlYA type corresponding to XML's ANY contentspec. It is either a list of unconverted xml  or some w -able value.Parsing functions (e.g. x) will always produce m. Note: The Show instance for m uses W.nHaXmlIf an attribute is defaultable, then it either takes the default value (which is omitted from the output), or a non-default value (which obviously must be printed).qHaXmlThe  XmlAttrTypep class promises that an attribute taking an XML enumerated type can be converted to and from a Haskell value.tHaXmlThe  XmlAttributesb class promises that a list of XML tag attributes can be converted to and from a Haskell value.wHaXmlThe  XmlContent\ class promises that an XML Content element can be converted to and from a Haskell value.xHaXmlConvert from XML to HaskellyHaXmlConvert from Haskell to XMLzHaXml'Dummy functions (for most types): used only@ in the Char instance for coercing lists of Char into String.|HaXmlWe need a parsing monad for reading generic XML Content into specific datatypes. This is a specialisation of the Text.ParserCombinators.Poly ones, where the input token type is fixed as XML Content.}HaXml'Read a single attribute called "value".~HaXmlGenerate a single attribute.HaXml<Generate an element with no attributes, named for its HType.HaXml7Generate an element with no attributes, named directly.HaXml#Turn a simple string into XML text.HaXmlJTurn a string into an XML CDATA section. (i.e. special characters like &' are preserved without interpretation.)HaXmlCThe most primitive combinator for XMLParser - get one content item.HaXmlGet the next content element, checking that it has one of the required tags, using the given matching function. (Skips over comments and whitespace, rejects text and refs. Also returns position of element.)HaXmlA specialisation of posnElementWith (==).HaXmlGet the next content element, checking that it has one of the required tags. (Skips over comments and whitespace, rejects text and refs.)HaXmlELike element, only permits a more flexible match against the tagname.HaXmlRun an XMLParser on the contents of the given element (i.e. not on the current monadic content sequence), checking that the contents are exhausted, before returning the calculated value within the current parser context.HaXml$A combination of element + interior.HaXml(A combination of elementWith + interior.HaXml6Do some parsing of the attributes of the given elementHaXml is a counterpart to T, parsing text content if it exists. Adjacent text and references are coalesced.HaXmln'choice f p' means if parseContents succeeds, apply f to the result, otherwise use the continuation parser.HaXmlnot sure this is needed now. 'definite p' previously ensured that an element was definitely present. Now I think the monad might take care of that for us.0123456789:;<=>?@ABCDEFGHIJKLfghijklmnopqrstuvwxyz{|}~xyijklmnopqsrtuvwyxz{|}~Cxywyxz{tuvqsr|~nop}ijklmNoneEX HaXmlRRead an XML document from a file and convert it to a fully-typed Haskell value.HaXmlJWrite a fully-typed Haskell value to the given file as an XML document.HaXmlWrite any Haskell value to the given file as an XML document, using the FastPackedString interface (output will not be prettified).HaXml.Read a fully-typed XML document from a string.HaXml=Convert a fully-typed XML document to a string (without DTD).HaXmlAConvert a fully-typed XML document to a ByteString (without DTD).HaXmlEConvert a fully-typed XML document to a string (with or without DTD).HaXml~Read a Haskell value from an XML document, ignoring the DTD and using the Haskell result type to determine how to parse it.HaXml3Read a fully-typed XML document from a file handle.HaXml2Write a fully-typed XML document to a file handle.HaXml{Write a fully-typed XML document to a file handle, using the FastPackedString interface (output will not be prettified).0123456789:;<=>?@ABCDEFGHIJKLfghijklmnopqrstuvwxyz{|}~xyijklmnopqsrtuvwyxz{|}~ NoneEX HaXmlRRead an XML document from a file and convert it to a fully-typed Haskell value.HaXmlJWrite a fully-typed Haskell value to the given file as an XML document.HaXmlWrite any Haskell value to the given file as an XML document, using the FastPackedString interface (output will not be prettified).HaXml.Read a fully-typed XML document from a string.HaXml=Convert a fully-typed XML document to a string (without DTD).HaXmlAConvert a fully-typed XML document to a ByteString (without DTD).HaXmlEConvert a fully-typed XML document to a string (with or without DTD).HaXml~Read a Haskell value from an XML document, ignoring the DTD and using the Haskell result type to determine how to parse it.HaXml3Read a fully-typed XML document from a file handle.HaXml2Write a fully-typed XML document to a file handle.HaXml{Write a fully-typed XML document to a file handle, using the FastPackedString interface (output will not be prettified).0123456789:;<=>?@ABCDEFGHIJKLfghijklmnopqrstuvwxyz{|}~xyijklmnopqsrtuvwyxz{|}~ NoneEXHaXmlk takes a DTD and a tagged element, and returns a list of errors in the document with respect to its DTD.If you have several documents to validate against a single DTD, then you will gain efficiency by freezing-in the DTD through partial application, e.g. checkMyDTD = validate myDTD.HaXmlq is like validate, except that it does not check that the element type matches that of the DTD's root element.NoneEXmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOVWXYefg fge NoneEX#HaXml=Convert a fully-typed XML document to a string (without DTD).HaXmlEConvert a fully-typed XML document to a string (with or without DTD).!NoneEX'JHaXmlUEquivalent to the Either type, but using the regular naming scheme of this module.HaXmlgSomewhat of a nonsense - a choice of a single item. But sometimes it occurs in auto-generated code.     #"! $43210/.-,+*)('&%5DCBA@?>=<;:9876ESRQPONMLKJIHGFTa`_^]\[ZYXWVUbnmlkjihgfedcozyxwvutsrqp{~}|{~}|ozyxwvutsrqpbnmlkjihgfedcTa`_^]\[ZYXWVUESRQPONMLKJIHGF5DCBA@?>=<;:9876$43210/.-,+*)('&%#"!      "None=@ACEXD  HaXmlThe  xsd:any' type. Parsing will always produce an UnconvertedANY.#HaXmlA trick to enable forward-declaration of a type that will be defined properly in another module, higher in the dependency graph. fd# is a dummy type e.g. the empty  data FwdA, where a is the proper data A, not yet available.$HaXmlA type t can restrict another type s, that is, t admits fewer values than s, but all the values t does admit also belong to the type s.&HaXml~A type t can extend another type s by the addition of extra elements and/or attributes. s is therefore the supertype of t.(HaXmlA SchemaType promises to interconvert between a generic XML content tree and a Haskell value, according to the rules of XSD.+HaXmlGiven a TextParser for a SimpleType, make it into an XMLParser, i.e. consuming textual XML content as input rather than a String.,HaXml|Between is a list parser that tries to ensure that any range specification (min and max elements) is obeyed when parsing.-HaXmlGenerated parsers will use -O as a convenient wrapper to lift a SchemaAttribute parser into an XMLParser./HaXml'Parse the textual part of mixed content4HaXmlFor a ComplexType that is an extension of a SimpleType, it is necessary to convert the value to XML first, then add in the extra attributes that constitute the extension.v0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~|      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./01234%()*&'$%#-,+/ !".|01234#SafeEXk5cHaXmlWe need a Parser monad for reading from a sequence of generic XML Contents into specific datatypes that model the structure of XSD descriptions. This is a specialisation of the polyparse combinators, fixing the input token type.dHaXml Lift boolean  over predicates.eHaXml0Qualify an ordinary name with the XSD namespace.fHaXmlPredicate for comparing against an XSD-qualified name. (Also accepts unqualified names, but this is probably a bit too lax. Doing it right would require checking to see whether the current schema module's default namespace is XSD or not.)gHaXml1Get the next content element, checking that it matches some criterion given by the predicate. (Skips over comments and whitespace, rejects text and refs. Also returns position of element.) The list of strings argument is for error reporting - it usually represents a list of expected tags.hHaXmlfGet the next content element, checking that it has the required tag belonging to the XSD namespace.iHaXml-Get the next content element, whatever it is.jHaXml8Grab and parse any and all children of the next element.kHaXmlRun an XsdParser on the child contents of the given element (i.e. not in the current monadic content sequence), filtering the children before parsing, and checking that the contents are exhausted, before returning the calculated value within the current parser context.lHaXmlgCheck for the presence (and value) of an attribute in the given element. Absence results in failure.mHaXmlSGrab any attributes that declare a locally-used prefix for a specific namespace.nHaXml@Predicate for whether an attribute belongs to a given namespace.oHaXmlTidy up the parsing context.pHaXmlxGiven a URI for a targetNamespace, and a list of Namespaces, tell me the prefix corresponding to the targetNamespace.qHaXml2An auxiliary you might expect to find in Data.ListrHaXmlTurn a qualified attribute value (two strings) into a qualified name (QName), but excluding the case where the namespace prefix corresponds to the targetNamespace of the current schema document.sHaXmlParse a Schema declarationtHaXmlParse a (possibly missing)  xsd:annotation element.uHaXmlParse a definitely-occurring  xsd:annotation element.vHaXmlParse a FormDefault attribute.wHaXml!Parse a Final or Block attribute.yHaXml-Parse a schema item (just under the toplevel  xsd:schema)zHaXml Parse an  xsd:include.{HaXml Parse an  xsd:import.|HaXmlParse a  xsd:redefine.}HaXmlParse a  xsd:simpleType decl.HaXmlParse a  xsd:complexType decl.HaXml$Parse the alternative contents of a  xsd:complexType decl.HaXmlParse a particle decl.HaXml/Parse a particle decl with optional attributes.HaXml Parse an  xsd:all,  xsd:choice, or  xsd:sequence decl.HaXmlParse a  xsd:group decl.HaXml Parse an  xsd:element,  xsd:group,  xsd:all,  xsd:choice,  xsd:sequence or  xsd:any.HaXml Parse an  xsd:any.HaXml Parse an  xsd:anyAttribute.HaXml Parse an  xsd:attributegroup.HaXml Parse an  xsd:element decl.HaXmlParse name and type attributes.HaXml Parse an  xsd:attribute decl.HaXml;Parse an occurrence range from attributes of given element.HaXmlParse a  xsd:unique,  xsd:key, or  xsd:keyref.HaXmlParse a  xsd:unique.HaXmlParse a  xsd:key.HaXmlParse a  xsd:keyref.HaXmlParse a  xsd:selector.HaXmlParse a  xsd:field.HaXmlHText parser for a URI (very simple, non-validating, probably incorrect).HaXmlKText parser for an arbitrary string consisting of possibly multiple tokens.HaXml:Parse a textual boolean, i.e. "true", "false", "0", or "1"HaXmlKParse a "use" attribute value, i.e. "required", "optional", or "prohibited"HaXmlEParse a "processContents" attribute, i.e. "skip", "lax", or "strict".HaXml0Parse an attribute value that should be a QName.HaXml6Parse an attribute value that should be a simple Name.9cdefghijklmnopqrstuvwxyz{|}~9cdefghijklmnopqrstuvwxyz{|}~$SafeEX7HaXmlRestrictions on simpleTypeHaXmlThere are essentially simple types, and complex types, each of which can be either restricted or extended. There are four kinds of complex type: choices, sequences, named groups, or a simple element with content.HaXmlThe whole Haskell module.HaXmlHComments can be attached to most things, but not all of them will exist.HaXml2A helper for building the formal Module structure.77%SafeEXoHaXmlZVertically pretty-print a list of things, with open and close brackets, and separators.HaXmlZGenerate aligned haddock-style documentation. (but without escapes in comment text yet)HaXml"Pretty-print a Haskell-style name.HaXmlPretty-print an XML-style name.HaXml2Some different ways of using a Haskell identifier.HaXml2Some different ways of using a Haskell identifier.HaXml2Some different ways of using a Haskell identifier.HaXml2Some different ways of using a Haskell identifier.HaXml2Some different ways of using a Haskell identifier.HaXml2Some different ways of using a Haskell identifier.HaXmlFConvert a whole document from HaskellTypeModel to Haskell source text.HaXml/Generate a fragmentary parser for an attribute.HaXml-Generate a fragmentary parser for an element.HaXml?Convert multiple HaskellTypeModel Decls to Haskell source text.HaXml7Convert a single Haskell Decl into Haskell source text.HaXmlInstances that depend on FwdDecl'd types, need to be declared in a different module. So they have been separated out from ppHighLevelDecl.HaXmlIGenerate an instance of the Extension class for a subtype/supertype pair.HaXml}Generate an instance of the Extension class for a type and its "grand"-supertype, that is, the supertype of its supertype.HaXml3Generate named fields from elements and attributes.HaXml.Generate a single named field from an element.HaXmlDWhat is the name of the type for an Element (or choice of Elements)?HaXml0Generate a single named field from an attribute.HaXml<Generate a list or maybe type name (possibly parenthesised).HaXml,Generate a parser for a list or Maybe value.HaXmlGSplit long lines of comment text into a paragraph with a maximum width.&SafeEXsHaXmlZVertically pretty-print a list of things, with open and close brackets, and separators.HaXmlZGenerate aligned haddock-style documentation. (but without escapes in comment text yet)HaXmlGenerate aligned haddock-style docs for choices (where each choice has its own documentation, but haddock cannot place it directly next to the appropriate component.HaXml"Pretty-print a Haskell-style name.HaXmlPretty-print an XML-style name.HaXml2Some different ways of using a Haskell identifier.HaXml2Some different ways of using a Haskell identifier.HaXml2Some different ways of using a Haskell identifier.HaXml2Some different ways of using a Haskell identifier.HaXml2Some different ways of using a Haskell identifier.HaXml2Some different ways of using a Haskell identifier.HaXmlFConvert a whole document from HaskellTypeModel to Haskell source text.HaXml/Generate a fragmentary parser for an attribute.HaXml.Generate a fragmentary toXML for an attribute.HaXml-Generate a fragmentary parser for an element.HaXmlkGenerate a fragmentary toXML for an element. Fragment must still be applied to an actual element value.HaXml?Convert multiple HaskellTypeModel Decls to Haskell source text.HaXml7Convert a single Haskell Decl into Haskell source text.HaXmlIGenerate an instance of the Extension class for a subtype/supertype pair.HaXml}Generate an instance of the Extension class for a type and its "grand"-supertype, that is, the supertype of its supertype.HaXml3Generate named fields from elements and attributes.HaXmlCGenerate a single named field (including type sig) from an element.HaXml<Generate a single named field (no type sig) from an element.HaXmlDWhat is the name of the type for an Element (or choice of Elements)?HaXml0Generate a single named field from an attribute.HaXml<Generate a list or maybe type name (possibly parenthesised).HaXml,Generate a parser for a list or Maybe value.HaXml+Generate a toXML for a list or Maybe value.HaXmlEliminate a Maybe type modifier, when it occurs directly inside a choice construct (since a parsed Nothing would always be preferred over a real value later in the choice). Likewise, empty lists must be disallowed inside choice.HaXmlSometimes, a choice without a type modifier contains element sequences, all of which have the same modifier. In that case, it makes sense to lift the modifier (typically Maybe) to the outer layer.HaXmlGSplit long lines of comment text into a paragraph with a maximum width.'SafeEQX; HaXmltype definitions in scopeHaXml)all type definitions, regardless of scopeHaXmlsupertype -> subtypesHaXmlsubstitution groupsHaXmlwhere type is definedHaXml*An empty environment of XSD type mappings.HaXmlCCombine two environments (e.g. read from different interface files)HaXml?Build an environment of XSD type mappings from a schema module.HaXml$Find all direct module dependencies.(SafeEQX[HaXmlTransform a Schema by lifting all locally-defined anonymous types to the top-level, naming them, and planting a referend at their original location.HaXmlGiven an environment of schema type mappings, and a schema module, create a bunch of Decls that describe the types in a more Haskell-friendly way.HaXml:Consolidate a Facet occurrence into a single Occurs value.HaXml6Push another Occurs value inside an existing Modifier.HaXmlJConvert an occurs range to a Haskell-style type modifier (Maybe, List, Id)HaXml7Find the supertype (if it exists) of a given type name.HaXml{Keep applying the function to transform the value, until it yields Nothing. Returns the sequence of transformed values.  )SafeEXOHaXml<double content filter - takes document root + local subtree.HaXml3lift an ordinary content filter to a double filter.HaXml3lift an ordinary content filter to a double filter. HaXmlddrop a double filter to an ordinary content filter. (permitting interior access to document root) HaXmldrop a double filter to an ordinary content filter. (Where interior access to the document root is not needed, the retaining pointer to the outer element can be pruned away.   is more space-efficient than   in this situation.) HaXml1lift a CFilter combinator to a DFilter combinator HaXml1lift a CFilter combinator to a DFilter combinator HaXml'lifted composition over double filters.HaXmllifted choice.HaXml lifted union.HaXmllifted predicates.HaXmllifted predicates.HaXmllifted unit and zero.HaXmllifted unit and zero.          *SafeEXo'HaXmlFirst argument is a transformer for pattern strings, e.g. map toLower, but only applying to parts of the pattern not in quotation marks. (Needed to canonicalise HTML where tags are case-insensitive, but attribute values are case sensitive.) !"#$%&''$% !"#&+SafeEX,HaXmlTo convert an Xtract query into an ordinary HaXml combinator expression. First arg is a tag-transformation function (e.g. map toLower) applied-HaXmlSThe cool thing is that the Xtract command parser directly builds a higher-order  (see !Text.XML.HaXml.Xtract.CombinatorsF) which can be applied to an XML document without further ado. ( parseXtract. halts the program if a parse error is found.)HaXml parseXtract'0 returns error messages through the Either type.,--,,-.,-/,-0123456789:;<=>?@ABCDEFGHIJJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~J      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{| } ~                              C   / .                                                                                       A A                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8  9 : ; < = > ? ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s ? @ t u v w x y z { | } ~               JJ(Y         ! " # $ % & ' ( ) ) * + , - . / 0 1 1 2 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C C D ; = ? E C D F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e fghijklmnopQ=qr?@stuAvwghixyjklmnopQ=qrz?@stuAvw{|}~=@A=>?@ABp><    A @ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL89:;<=>?@ABDFGMN O!P!P!Q!R!S!T!U!V!W!X!Y!Z![!\!]!^!_!`!a!b!c!d!d!e!f!g!h!i!j!k!l!m!n!o!p!q!r!s!t!u!v!w!w!x!y!z!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! ! ! !!!!!!!!!!!!!!!!!!!!!!! !!!!!"!#!$!%!&!'!(!)!*!+!,!-!.!/!0!1!2!3!4!5!6!7!8!9!:!;!<!=!>!?!@!A!B!C!D!E!F!G!H!I!J!K!L!M!N!O!P!Q!R!S!T!U!V!W!X!Y!Z![!\!]!^!_!`!a!b!c!d!e!f!g!h!i!j!k!l!m!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!!"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""##### ###################################################p#Q$$$$$$$$$$$$$$$$$$@$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$$$$$ $!$"$#$$$$%$&$'$&$'$($)$*$+$w$x%,%-%.%/%0&,&-&.&/&0'1'1'2'3'4'5'6'7'8'9':';'<'='>'?(@(A(q(B(C(D(E(F(G(H(I(J(K(L(M)N)O)P)Q)R)S)T)))))))))))U))))))))*t*V*W*X*]*Y**Z*h**i*+[+\]^4_`4_a4_b4_c4_d4_e4_f4gh4gi4gj4gk4gl4gm4gn4go4go4gp4qr4qr4qs4tu4_v4_w4_x4_y4_z4_{4_|4_}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~4 4%N%O%%%%%%%%%%%%%%%%%%&&N&O&&&&&&&&&&&&&&&&&&&&&&&+#HaXml-1.25.5-KUim09QcrmFIBqtM7qN39l$Text.XML.HaXml.Schema.PrimitiveTypes Text.XML.HaXml.XmlContent.ParserText.XML.HaXml#Text.XML.HaXml.DtdToHaskell.TypeDef$Text.XML.HaXml.DtdToHaskell.InstanceText.XML.HaXml.PosnText.XML.HaXml.LexText.XML.HaXml.Types"Text.XML.HaXml.Schema.XSDTypeModelText.XML.HaXml.Namespaces$Text.XML.HaXml.Schema.NameConversionText.XML.HaXml.PrettyText.XML.HaXml.TypeMappingText.XML.HaXml.ParseLazyText.XML.HaXml.ParseText.XML.HaXml.SAXText.XML.HaXml.Html.PrettyText.XML.HaXml.Html.ParseLazyText.XML.HaXml.Html.ParseText.XML.HaXml.Escape#Text.XML.HaXml.DtdToHaskell.ConvertText.XML.HaXml.CombinatorsText.XML.HaXml.Html.GenerateText.XML.HaXml.ByteStringPPText.XML.HaXml.VerbatimText.XML.HaXml.UtilText.XML.HaXml.VersionText.XML.HaXml.Wrappers!Text.XML.HaXml.XmlContent.HaskellText.XML.HaXml.XmlContentText.XML.HaXml.ValidateText.XML.HaXml.ShowXmlLazyText.XML.HaXml.OneOfNText.XML.HaXml.Schema.SchemaText.XML.HaXml.Schema.Parse&Text.XML.HaXml.Schema.HaskellTypeModel"Text.XML.HaXml.Schema.PrettyHsBoot#Text.XML.HaXml.Schema.PrettyHaskell!Text.XML.HaXml.Schema.Environment$Text.XML.HaXml.Schema.TypeConversion!Text.XML.HaXml.Xtract.CombinatorsText.XML.HaXml.Xtract.LexText.XML.HaXml.Xtract.Parseghc-prim GHC.TypesDoubleFloatInt integer-gmpGHC.Integer.TypeIntegerbase Data.Maybe catMaybespretty-1.1.3.6Text.PrettyPrint.HughesPJrender StructTypeMaybe DefaultableListList1TupleOneOfAny StringMixedStringDefined AttrFields ConstructorsTypeDefDataDefEnumDefNamexNamehName ppTypeDefppHNameppXNameppANamenamename_name_aname_acname_fmanglemanglef$fShowStructType$fEqName$fEqStructType $fEqTypeDef mkInstancePosn posnFilenameposnLine posnColumnnoPos posInNewCxtforcepaddcolnewlinetabwhite $fShowPosn$fEqPosnSectionCDATAxINCLUDExIGNORExSpecialDOCTYPExELEMENTxATTLISTxENTITYx NOTATIONxTokenTTokCommentOpenTokCommentClose TokPIOpen TokPICloseTokSectionOpenTokSectionClose TokSectionTokSpecialOpen TokSpecial TokEndOpen TokEndClose TokAnyOpen TokAnyClose TokSqOpen TokSqCloseTokEqualTokQueryTokStarTokPlusTokAmpTokSemiTokHash TokBraOpen TokBraCloseTokPipe TokPercentTokCommaTokQuoteTokName TokFreeTextTokNullTokErrorTokenxmlLexxmlReLexreLexEntityValue $fShowTokenT $fEqWhere $fEqSpecial $fShowSpecial $fEqSection $fShowSection $fEqTokenTCDSectCharData SystemLiteral PubidLiteralEVEVStringEVRef EntityValueAttValueNmTokensNmTokenNames NamespacensPrefixnsURIQNameNQN EncodingDeclPublicIDPUBLICID NotationDeclNOTATIONExtPE ExtParsedEntTextDecl NDataDeclNDATA ExternalIDSYSTEMPUBLICPEDefPEDefEntityValuePEDefExternalID EntityDefDefEntityValue DefExternalIDPEDeclGEDecl EntityDecl EntityGEDecl EntityPEDecl PEReferenceCharRef EntityRef Reference RefEntityRefCharIgnoreSectContentsIgnore IgnoreSect IncludeSectConditionalSectFIXED DefaultDeclREQUIREDIMPLIED DefaultTo Enumeration NotationTypeEnumeratedType TokenizedTypeIDIDREFIDREFSENTITYENTITIESNMTOKENNMTOKENSAttType StringTypeAttDef AttListDeclMixedPCDATA PCDATAplusModifierNoneQueryStarPlusCPTagNameChoiceSeq ContentSpecEMPTYANY ElementDeclContentCElemCStringCRefCMisc AttributeElemTagElementElem ExtSubsetDecl ExtMarkupDeclExtConditionalSect ExtSubset MarkupDeclAttListEntityNotation MarkupMisc DocTypeDeclDTDPITargetComment VersionInfoSDDeclProcessingInstructionMiscPIXMLDeclPrologDocumentSymTabemptySTaddSTlookupSTinfo $fEqNamespace $fOrdQName$fShowAttValue $fEqElemTag$fFunctorContent$fFunctorElement $fEqContent$fFunctorDocument$fEqMisc $fShowMisc $fEqModifier$fShowModifier$fEqTokenizedType$fShowTokenizedType $fEqFIXED $fShowFIXED $fEqIgnore $fShowIgnore$fEqIgnoreSectContents$fShowIgnoreSectContents$fEqEncodingDecl$fShowEncodingDecl $fEqTextDecl$fShowTextDecl $fEqXMLDecl $fShowXMLDecl$fShowNamespace $fEqQName $fShowQName $fEqMixed $fShowMixed$fEqCP$fShowCP$fEqContentSpec$fShowContentSpec$fEqElementDecl$fShowElementDecl $fEqNDataDecl$fShowNDataDecl $fEqReference$fShowReference$fEqEnumeratedType$fShowEnumeratedType $fEqAttType $fShowAttType $fEqAttValue$fEqDefaultDecl$fShowDefaultDecl $fEqAttDef $fShowAttDef$fEqAttListDecl$fShowAttListDecl$fEqEV$fShowEV$fEqEntityValue$fShowEntityValue$fEqPubidLiteral$fShowPubidLiteral $fEqPublicID$fShowPublicID$fEqSystemLiteral$fShowSystemLiteral$fEqExternalID$fShowExternalID$fEqNotationDecl$fShowNotationDecl $fEqPEDef $fShowPEDef $fEqPEDecl $fShowPEDecl $fEqEntityDef$fShowEntityDef $fEqGEDecl $fShowGEDecl$fEqEntityDecl$fShowEntityDecl$fEqMarkupDecl$fShowMarkupDecl$fEqExtSubsetDecl$fShowExtSubsetDecl$fEqConditionalSect$fShowConditionalSect $fEqExtPE $fShowExtPE $fEqExtSubset$fShowExtSubset$fEqDocTypeDecl$fShowDocTypeDecl $fEqProlog $fShowProlog $fShowContent $fEqElement $fShowElement$fEqExtParsedEnt$fShowExtParsedEnt $fEqDocument$fShowDocumentTypeNameURIRegexp FixedValue DefaultValueSchemaLocationProcessContentsSkipLaxStrictBlockFinal NoExtension NoRestrictionAllFinalTargetNamespaceQForm Qualified Unqualified Annotation DocumentationAppInfo NoAnnotationFixedNillable MyRestrictionRangePattern PrimitiveTypeBooleanDecimalDurationDateTimeTimeDate GYearMonthGYear GMonthDayGDayGMonth Base64Binary HexBinaryAnyURIUseRequiredOptional ProhibitedOccursFieldfield_annotation field_xpathSelectorselector_annotationselector_xpathKeyRefkeyref_annotation keyref_name keyref_referkeyref_selector keyref_fieldsKeykey_annotationkey_name key_selector key_fieldsUniqueunique_annotation unique_nameunique_selector unique_fieldsUniqueKeyOrKeyRefUKKR AttributeDeclattr_annotationattr_nameOrRefattr_use attr_defFixed attr_formattr_simpleType NameAndTypeNTtheNametheTypeelem_annotationelem_nameOrRef elem_occurs elem_nillableelem_substGroup elem_abstract elem_final elem_block elem_form elem_content elem_stuff AttrGroupattrgroup_annotationattrgroup_nameOrRefattrgroup_stuffAnyAttranyattr_annotationanyattr_namespaceanyattr_processContentsany_annotation any_namespaceany_processContents any_occurs ElementEtc HasElementHasGroupHasCSHasAny ChoiceOrSeqAllSequenceGroupgroup_annotationgroup_nameOrRef group_occurs group_stuff ParticleAttrsPAParticle Extensionextension_annotationextension_baseextension_newstuff Restriction1 ComplexItem SimpleContentComplexContentThisType ci_annotationci_stuffci_mixed ci_thistype ComplexTypecomplex_annotation complex_namecomplex_abstract complex_final complex_block complex_mixedcomplex_content FacetTypeOrderedBoundsMinInclOrderedBoundsMinExclOrderedBoundsMaxInclOrderedBoundsMaxExclOrderedNumericTotalDigitsOrderedNumericFractionDigitsUnorderedPatternUnorderedEnumerationUnorderedWhitespaceUnorderedLengthUnorderedMaxLengthUnorderedMinLengthFacetfacet_facetTypefacet_annotationfacet_facetValue facet_fixed Restriction RestrictSim1 RestrictTyperestrict_annotation restrict_base restrict_r1 restrict_typerestrict_facets SimpleType Primitive RestrictedListOfUnionOfsimple_primitivesimple_annotation simple_name simple_finalsimple_restriction simple_type simple_unionsimple_members SchemaItemIncludeImportRedefineSimpleComplex SchemaElementSchemaAttributeAttributeGroup SchemaGroupSchemaschema_elementFormDefaultschema_attributeFormDefaultschema_finalDefaultschema_blockDefaultschema_targetNamespaceschema_versionschema_namespaces schema_items$fSemigroupAnnotation$fMonoidAnnotation$fSemigroupSchema$fMonoidSchema $fEqFacetType$fShowFacetType$fEqNameAndType$fShowNameAndType $fEqOccurs $fShowOccurs$fEqUse $fShowUse$fEqPrimitiveType$fShowPrimitiveType$fEqAnnotation$fShowAnnotation $fEqField $fShowField $fEqSelector$fShowSelector $fEqKeyRef $fShowKeyRef$fEqKey $fShowKey $fEqUnique $fShowUnique$fEqUniqueKeyOrKeyRef$fShowUniqueKeyOrKeyRef $fEqFacet $fShowFacet $fEqQForm $fShowQForm $fEqFinal $fShowFinal$fEqProcessContents$fShowProcessContents$fEqMyRestriction$fShowMyRestriction $fEqAnyAttr $fShowAnyAttr$fEqAny $fShowAny$fEqElementEtc$fShowElementEtc$fEqComplexType$fShowComplexType$fEqComplexItem$fShowComplexItem$fEqParticleAttrs$fShowParticleAttrs$fEqAttributeDecl$fShowAttributeDecl$fEqSimpleType$fShowSimpleType$fEqRestriction$fShowRestriction$fEqRestriction1$fShowRestriction1$fEqChoiceOrSeq$fShowChoiceOrSeq $fEqGroup $fShowGroup $fEqAttrGroup$fShowAttrGroup $fEqExtension$fShowExtension$fEqSchemaItem$fShowSchemaItem $fEqSchema $fShowSchemaPositiveIntegerPositive UnsignedByteUByte UnsignedShortUShort UnsignedIntUInt UnsignedLongULongNonNegativeIntegerNonNegByteShortLongNegativeIntegerNegativeNonPositiveIntegerNonPosNCNameLanguageNormalizedString Normalized XsdStringacceptingParsersimpleTypeText$fSimpleTypeInt$fSimpleTypeInteger$fSimpleTypeDouble$fSimpleTypeFloat$fSimpleTypeBool$fSimpleTypeXsdString$fSimpleTypeBase64Binary$fSimpleTypeHexBinary$fSimpleTypeAnyURI$fSimpleTypeNOTATION$fSimpleTypeDecimal$fSimpleTypeDuration$fSimpleTypeDateTime$fSimpleTypeTime$fSimpleTypeDate$fSimpleTypeGYearMonth$fSimpleTypeGYear$fSimpleTypeGMonthDay$fSimpleTypeGDay$fSimpleTypeGMonth$fSimpleTypeNormalizedString$fSimpleTypeToken$fSimpleTypeLanguage$fSimpleTypeName$fSimpleTypeNCName$fSimpleTypeID$fSimpleTypeIDREF$fSimpleTypeIDREFS$fSimpleTypeENTITY$fSimpleTypeENTITIES$fSimpleTypeNMTOKEN$fSimpleTypeNMTOKENS$fSimpleTypeNonPositiveInteger$fSimpleTypeNegativeInteger$fSimpleTypeLong$fSimpleTypeShort$fSimpleTypeByte$fSimpleTypeNonNegativeInteger$fSimpleTypeUnsignedLong$fSimpleTypeUnsignedInt$fSimpleTypeUnsignedShort$fSimpleTypeUnsignedByte$fSimpleTypePositiveInteger $fEqXsdString$fShowXsdString$fEqBase64Binary$fShowBase64Binary $fEqHexBinary$fShowHexBinary $fEqAnyURI $fShowAnyURI $fEqNOTATION$fShowNOTATION $fEqDecimal $fShowDecimal $fEqDuration$fShowDuration $fEqDateTime$fShowDateTime$fEqTime $fShowTime$fEqDate $fShowDate$fEqGYearMonth$fShowGYearMonth $fEqGYear $fShowGYear $fEqGMonthDay$fShowGMonthDay$fEqGDay $fShowGDay $fEqGMonth $fShowGMonth$fEqNormalizedString$fShowNormalizedString $fEqToken $fShowToken $fEqLanguage$fShowLanguage $fShowName $fEqNCName $fShowNCName$fEqID$fShowID $fEqIDREF $fShowIDREF $fEqIDREFS $fShowIDREFS $fEqENTITY $fShowENTITY $fEqENTITIES$fShowENTITIES $fEqNMTOKEN $fShowNMTOKEN $fEqNMTOKENS$fShowNMTOKENS$fEqNonPositiveInteger$fShowNonPositiveInteger$fEqNegativeInteger$fShowNegativeInteger$fEqLong $fShowLong $fEqShort $fShowShort$fEqByte $fShowByte$fEqNonNegativeInteger$fShowNonNegativeInteger$fEqUnsignedLong$fShowUnsignedLong$fEqUnsignedInt$fShowUnsignedInt$fEqUnsignedShort$fShowUnsignedShort$fEqUnsignedByte$fShowUnsignedByte$fEqPositiveInteger$fShowPositiveInteger nullNamespace expandedName namespaceName localName printableNamequalify deQualifyqualifyExceptLocalinitNamespaceEnvaugmentNamespaceEnvresolveAllNames NameConvertermodidconidvaridunqconidunqvaridfwdconidfieldidHNameXNamesimpleNameConverterescape avoidKeywordsfpmlwordsBybasenamefpmlNameConverter $fEqXName $fShowXName $fShowHNamedocumentprolog doctypedeclelementcontentcpConstrHTypePrim HTypeabletoHType showConstrtoDTD showHType $fEqHType $fHTypeable[]$fHTypeableEither$fHTypeableMaybe$fHTypeable(,,,,,,,,,,,,,,)$fHTypeable(,,,,,,,,,,,,,)$fHTypeable(,,,,,,,,,,,,)$fHTypeable(,,,,,,,,,,,)$fHTypeable(,,,,,,,,,,)$fHTypeable(,,,,,,,,,)$fHTypeable(,,,,,,,,)$fHTypeable(,,,,,,,)$fHTypeable(,,,,,,)$fHTypeable(,,,,,)$fHTypeable(,,,,)$fHTypeable(,,,)$fHTypeable(,,)$fHTypeable(,) $fHTypeable()$fHTypeableChar$fHTypeableDouble$fHTypeableFloat$fHTypeableInteger$fHTypeableInt$fHTypeableBool $fEqConstr $fShowConstr $fShowHTypeXParserxmlParsedtdParse xmlParseWithemptySTsfst3snd3thd3tokqnamecommentprocessinginstructionelemtag elemOpenTag elemCloseTag referencechardata xmlParse' dtdParse'cdsect SaxElementSaxDocTypeDeclSaxProcessingInstruction SaxCommentSaxElementOpenSaxElementClose SaxElementTag SaxCharData SaxReferencesaxParse attribute htmlParse htmlParse' XmlEscaper xmlEscapexmlEscapeContent xmlUnEscapexmlUnEscapeContent stdXmlEscaper mkXmlEscaper dtd2TypeDef LabelFilterThenElse:>CFilterkeepnonechildrenpositionelmtxttagtagWithattrattrvalfindiffindifTxt?>ounioncatandThen childrenBy|>|withwithout/>*>liftA2<*Control.Applicativeoptional WrappedMonad WrapMonad unwrapMonad WrappedArrow WrapArrow unwrapArrowZipList getZipListData.Functor.ConstConstgetConst Data.Functor<$>liftA3liftA<**> Alternativeempty<|>somemany'polyparse-1.12.1-FeZxex5koKh2BIaglzjzIj Text.Parse allAsString parseLitChar parseLitChar' parseFloatparseHexparseOctparseDecparseInt parseSigned enumeration constructorsfieldoptionalParensisWordwordreadsPrecByParsePrec readByParse parseByRead TextParserParseparse parsePrec parseList!Text.ParserCombinators.Poly.Plain runParser"Text.ParserCombinators.Poly.Parserreparse satisfyMsgsatisfyeofnextonFailParserP"Text.ParserCombinators.Poly.ResultResultSuccessFailure Committed Text.ParserCombinators.Poly.Base manyFinally' manyFinallybracket bracketSepsepBy1sepBymany1uptoexactlyindentoneOf adjustErrBadfailBaddiscardapply Commitmentcommit adjustErroneOf' PolyParse markupdecl<><+>$$GHC.Num- toXmlLazy Data.FoldableorppModIdppConIdppVarId ppUnqConId ppUnqVarId ppFwdConIdppAttrppElemppHighLevelInstances ppExtensionppSuperExtensionppFieldsppFieldElementppElemTypeNameppFieldAttributeppTypeModifierppElemModifier paragraphppCommentForChoice toXmlAttr toXmlElem ppFieldNamexmlElemModifier cleanChoicesliftedElemModifier parseXtract'