A pure tree representation that uses a list as its container type, annotated variant.

In the hexpat package, a list of nodes has the type [Node tag text], but note that you can also use the more general type function ListOf to give a list of any node type, using that node's associated list type, e.g. ListOf (UNode Text).

Annotated variant of the tree representation of the XML document, meaning that it has an extra piece of information of your choice attached to each Element.

c is the container type for the element's children, which would normally be [], but could potentially be a monadic list type to allow for chunked I/O.

tag is the tag type, which can either be one of several string types, or a special type from the Text.XML.Expat.Namespaced or Text.XML.Expat.Qualified modules.

text is the string type for text content.

a is the type of the annotation. One of the things this can be used for is to store the XML parse location, which is useful for error handling.

Note that some functions in the Text.XML.Expat.Cursor module need to create new nodes through the MkElementClass type class. Normally this can only be done if a is a Maybe type or () (so it can provide the Nothing value for the annotation on newly created nodes). Or, you can write your own MkElementClass instance. Apart from that, there is no requirement for a to be a Maybe type.

Type alias for an annotated node with unqualified tag names where tag and text are the same string type

Type alias for an annotated node, annotated with parse location

Type alias for an annotated node with unqualified tag names where tag and text are the same string type, annotated with parse location

Modify this node's annotation (non-recursively) if it's an element, otherwise no-op.

Modify this node's annotation and all its children recursively if it's an element, otherwise no-op.

Type alias for an annotated node where qualified names are used for tags

Type alias for an annotated node where qualified names are used for tags, annotated with parse location

Type alias for an annotated node where namespaced names are used for tags

Type alias for an annotated node where namespaced names are used for tags, annotated with parse location

Lazily parse XML to tree. Note that forcing the XMLParseError return value will force the entire parse. Therefore, to ensure lazy operation, don't check the error status until you have processed the tree.

Strictly parse XML to tree. Returns error message or valid parsed tree.

Parse a generalized list to a tree, ignoring parse errors. This function allows for a parse from an enumerator/iteratee to a "lazy" tree structure using the List-enumerator package.

Parse error, consisting of message text and error location

Specifies a location of an event within the input text

Lazily parse XML to tree. In the event of an error, throw XMLParseException.

parseThrowing can throw an exception from pure code, which is generally a bad way to handle errors, because Haskell's lazy evaluation means it's hard to predict where it will be thrown from. However, it may be acceptable in situations where it's not expected during normal operation, depending on the design of your program.

An exception indicating an XML parse error, used by the ..Throwing variants.

A lower level function that lazily converts a SAX stream into a tree structure. Variant that takes annotations for start tags.

A lower level function that converts a generalized SAX stream into a tree structure. Ignores parse errors.

An abstraction for any string type you want to use as xml text (that is, attribute values or element text content). If you want to use a new string type with hexpat, you must make it an instance of GenericXMLString.