Text.ParserCombinators.HuttonMeijerWallace

Primitive parser combinators

Text.ParserCombinators.HuttonMeijerWallace

Contents

The parser monad
Primitive parser combinators
Derived combinators
Error handling
State handling
Re-parsing

Description

This library of monadic parser combinators is based on the ones - defined by Graham Hutton and Erik Meijer. It has been extended by - Malcolm Wallace to use an abstract token type (no longer just a - string) as input, and to incorporate a State Transformer monad, useful - for symbol tables, macros, and so on. Basic facilities for error - reporting have also been added, and later extended by Graham Klyne - to return the errors through an Either type, rather than just - calling error.

Synopsis

data Parser s t e a = P (s -> [Either e t] -> ParseResult s t e a)

item :: Parser s t e t

eof :: (Show p) => Parser s (p, t) String ()

papply :: Parser s t String a -> s -> [Either String t] -> [(a, s, [Either String t])]

papply' :: Parser s t e a -> s -> [Either e t] -> Either e [(a, s, [Either e t])]

(+++) :: Parser s t e a -> Parser s t e a -> Parser s t e a

tok :: (Eq t) => t -> Parser s (p, t) e t

nottok :: (Eq t) => [t] -> Parser s (p, t) e t

many :: Parser s t e a -> Parser s t e [a]

many1 :: Parser s t e a -> Parser s t e [a]

sepby :: Parser s t e a -> Parser s t e b -> Parser s t e [a]

sepby1 :: Parser s t e a -> Parser s t e b -> Parser s t e [a]

chainl :: Parser s t e a -> Parser s t e (a -> a -> a) -> a -> Parser s t e a

chainl1 :: Parser s t e a -> Parser s t e (a -> a -> a) -> Parser s t e a

chainr :: Parser s t e a -> Parser s t e (a -> a -> a) -> a -> Parser s t e a

chainr1 :: Parser s t e a -> Parser s t e (a -> a -> a) -> Parser s t e a

ops :: [(Parser s t e a, b)] -> Parser s t e b

bracket :: (Show p, Show t) => Parser s (p, t) e a -> Parser s (p, t) e b -> Parser s (p, t) e c -> Parser s (p, t) e b

toEOF :: (Show p) => Parser s (p, t) String a -> Parser s (p, t) String a

elserror :: (Show p, Show t) => Parser s (p, t) String a -> String -> Parser s (p, t) String a

stupd :: (s -> s) -> Parser s t e ()

stquery :: (s -> a) -> Parser s t e a

stget :: Parser s t e s

reparse :: [Either e t] -> Parser s t e ()

The parser monad

data Parser s t e a

Constructors

P (s -> [Either e t] -> ParseResult s t e a) The parser type is parametrised on the types of the state s, - the input tokens t, error-type e, and the result value a. - The state and remaining input are threaded through the monad.

Instances

Functor (Parser s t e)

Monad (Parser s t e)

MonadPlus (Parser s t e)

item :: Parser s t e t

Deliver the first remaining token.

eof :: (Show p) => Parser s (p, t) String ()

Fail if end of input is not reached

papply :: Parser s t String a -> s -> [Either String t] -> [(a, s, [Either String t])]

Apply the parser to some real input, given an initial state value. - If the parser fails, raise error to halt the program. - (This is the original exported behaviour - to allow the caller to - deal with the error differently, see papply'.)

papply' :: Parser s t e a -> s -> [Either e t] -> Either e [(a, s, [Either e t])]

Apply the parser to some real input, given an initial state value. - If the parser fails, return a diagnostic message to the caller.

Derived combinators

(+++) :: Parser s t e a -> Parser s t e a -> Parser s t e a

A choice between parsers. Keep only the first success.

tok :: (Eq t) => t -> Parser s (p, t) e t

Deliver the first token if it equals the argument.

nottok :: (Eq t) => [t] -> Parser s (p, t) e t

Deliver the first token if it does not equal the argument.

many :: Parser s t e a -> Parser s t e [a]

Deliver zero or more values of a.

many1 :: Parser s t e a -> Parser s t e [a]

Deliver one or more values of a.

sepby :: Parser s t e a -> Parser s t e b -> Parser s t e [a]

Deliver zero or more values of a separated by b's.

sepby1 :: Parser s t e a -> Parser s t e b -> Parser s t e [a]

Deliver one or more values of a separated by b's.

chainl :: Parser s t e a -> Parser s t e (a -> a -> a) -> a -> Parser s t e a

chainl1 :: Parser s t e a -> Parser s t e (a -> a -> a) -> Parser s t e a

chainr :: Parser s t e a -> Parser s t e (a -> a -> a) -> a -> Parser s t e a

chainr1 :: Parser s t e a -> Parser s t e (a -> a -> a) -> Parser s t e a

ops :: [(Parser s t e a, b)] -> Parser s t e b

bracket :: (Show p, Show t) => Parser s (p, t) e a -> Parser s (p, t) e b -> Parser s (p, t) e c -> Parser s (p, t) e b

toEOF :: (Show p) => Parser s (p, t) String a -> Parser s (p, t) String a

Accept a complete parse of the input only, no partial parses.

Error handling

elserror :: (Show p, Show t) => Parser s (p, t) String a -> String -> Parser s (p, t) String a

If the parser fails, generate an error message.

State handling

stupd :: (s -> s) -> Parser s t e ()

Update the internal state.

stquery :: (s -> a) -> Parser s t e a

Query the internal state.

stget :: Parser s t e s

Deliver the entire internal state.

Re-parsing

reparse :: [Either e t] -> Parser s t e ()

This is useful for recursively expanding macros. When the - user-parser recognises a macro use, it can lookup the macro - expansion from the parse state, lex it, and then stuff the - lexed expansion back down into the parser.

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.ParserCombinators.HuttonMeijerWallace.html hunk ./docs/HaXml/Text.PrettyPrint.HughesPJ.html 1 - - -Text.PrettyPrint.HughesPJ

Text.PrettyPrint.HughesPJ

data Doc

Instances

Show Doc

data Mode

Constructors

PageMode
ZigZagMode
LeftMode
OneLineMode

data TextDetails

Constructors

Chr Char
Str String
PStr String

empty :: Doc

nest :: Int -> Doc -> Doc

text :: String -> Doc

char :: Char -> Doc

int :: Int -> Doc

integer :: Integer -> Doc

float :: Float -> Doc

double :: Double -> Doc

rational :: Rational -> Doc

parens :: Doc -> Doc

brackets :: Doc -> Doc

braces :: Doc -> Doc

quotes :: Doc -> Doc

doubleQuotes :: Doc -> Doc

semi :: Doc

comma :: Doc

colon :: Doc

space :: Doc

equals :: Doc

lparen :: Doc

rparen :: Doc

lbrack :: Doc

rbrack :: Doc

lbrace :: Doc

rbrace :: Doc

(<>) :: Doc -> Doc -> Doc

(<+>) :: Doc -> Doc -> Doc

hcat :: [Doc] -> Doc

hsep :: [Doc] -> Doc

($$) :: Doc -> Doc -> Doc

vcat :: [Doc] -> Doc

sep :: [Doc] -> Doc

cat :: [Doc] -> Doc

fsep :: [Doc] -> Doc

fcat :: [Doc] -> Doc

hang :: Doc -> Int -> Doc -> Doc

punctuate :: Doc -> [Doc] -> [Doc]

render :: Doc -> String

fullRender :: Mode -> Int -> Float -> (TextDetails -> a -> a) -> a -> Doc -> a

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.PrettyPrint.HughesPJ.html hunk ./docs/HaXml/Text.XML.HaXml.Combinators.html 1 - - -Text.XML.HaXml.Combinators

HaXml

The content filter type.

Text.XML.HaXml.Combinators

Contents

Simple filters.

Selection filters.
Predicate filters.
Search filters.

Filter combinators

Basic combinators.
Recursive search.
Interior editing.
Constructive filters.

C-like conditionals.

Filters with labelled results.

Using and combining labelled filters.
Some label-generating filters.

Description

This module defines the notion of filters and filter combinators - for processing XML documents.

These XML transformation combinators are described in the paper - ``Haskell and XML: Generic Combinators or Type-Based Translation?'' - Malcolm Wallace and Colin Runciman, Proceedings ICFP'99.

Synopsis

type CFilter = Content -> [Content]

keep :: a -> [a]

none :: a -> [a]

children :: CFilter

position :: Int -> CFilter -> CFilter

elm :: CFilter

txt :: CFilter

tag :: String -> CFilter

attr :: Name -> CFilter

attrval :: Attribute -> CFilter

tagWith :: (String -> Bool) -> CFilter

find :: String -> (String -> CFilter) -> CFilter

iffind :: String -> (String -> CFilter) -> CFilter -> CFilter

ifTxt :: (String -> CFilter) -> CFilter -> CFilter

o :: CFilter -> CFilter -> CFilter

union :: (a -> [b]) -> (a -> [b]) -> a -> [b]

cat :: [a -> [b]] -> a -> [b]

andThen :: (a -> c) -> (c -> a -> b) -> a -> b

(|>|) :: (a -> [b]) -> (a -> [b]) -> a -> [b]

with :: CFilter -> CFilter -> CFilter

without :: CFilter -> CFilter -> CFilter

(/>) :: CFilter -> CFilter -> CFilter

(</) :: CFilter -> CFilter -> CFilter

et :: (String -> CFilter) -> CFilter -> CFilter

path :: [CFilter] -> CFilter

deep :: CFilter -> CFilter

deepest :: CFilter -> CFilter

multi :: CFilter -> CFilter

when :: CFilter -> CFilter -> CFilter

guards :: CFilter -> CFilter -> CFilter

chip :: CFilter -> CFilter

foldXml :: CFilter -> CFilter

mkElem :: String -> [CFilter] -> CFilter

mkElemAttr :: String -> [(String, CFilter)] -> [CFilter] -> CFilter

literal :: String -> CFilter

cdata :: String -> CFilter

replaceTag :: String -> CFilter

replaceAttrs :: [(String, String)] -> CFilter

data ThenElse a = (:>) a a

(?>) :: (a -> [b]) -> ThenElse (a -> [b]) -> a -> [b]

type LabelFilter a = Content -> [(a, Content)]

oo :: (a -> CFilter) -> LabelFilter a -> CFilter

x :: (CFilter -> LabelFilter a) -> (CFilter -> LabelFilter b) -> CFilter -> LabelFilter (a, b)

numbered :: CFilter -> LabelFilter String

interspersed :: String -> CFilter -> String -> LabelFilter String

tagged :: CFilter -> LabelFilter String

attributed :: String -> CFilter -> LabelFilter String

textlabelled :: CFilter -> LabelFilter (Maybe String)

extracted :: (Content -> a) -> CFilter -> LabelFilter a

The content filter type.

type CFilter = Content -> [Content]

All document transformations are content filters. - A filter takes a single XML Content value and returns a sequence - of Content values, possibly empty.

Simple filters.

Selection filters.

In the algebra of combinators, none is the zero, and keep the identity. - (They have a more general type than just CFilter.)

keep :: a -> [a]

none :: a -> [a]

children :: CFilter

Throw away current node, keep just the (unprocessed) children.

position :: Int -> CFilter -> CFilter

Select the n'th positional result of a filter.

Predicate filters.

These filters either keep or throw away some content based on - a simple test. For instance, elm keeps only a tagged element, - txt keeps only non-element text, tag keeps only an element - with the named tag, attr keeps only an element with the named - attribute, attrval keeps only an element with the given - attribute value, tagWith keeps only an element whose tag name - satisfies the given predicate.

elm :: CFilter

txt :: CFilter

tag :: String -> CFilter

attr :: Name -> CFilter

attrval :: Attribute -> CFilter

tagWith :: (String -> Bool) -> CFilter

Search filters.

find :: String -> (String -> CFilter) -> CFilter

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.

iffind :: String -> (String -> CFilter) -> CFilter -> CFilter

When an attribute field may be absent, use iffind key yes no to lookup - its value. If the attribute is absent, it acts as the no filter, - otherwise it applies the yes filter.

ifTxt :: (String -> CFilter) -> CFilter -> CFilter

ifTxt yes no processes any textual content with the yes filter, - but otherwise is the same as the no filter.

Filter combinators

Basic combinators.

o :: CFilter -> CFilter -> CFilter

Sequential (Irish,backwards) composition

union :: (a -> [b]) -> (a -> [b]) -> a -> [b]

Binary 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.)

cat :: [a -> [b]] -> a -> [b]

Glue a list of filters together. (A list version of union; - also has a more general type than just CFilter.)

andThen :: (a -> c) -> (c -> a -> b) -> a -> b

A special form of filter composition where the second filter - works over the same data as the first, but also uses the - first's result.

(|>|) :: (a -> [b]) -> (a -> [b]) -> a -> [b]

Directional choice: - in f |>| g give g-productions only if no f-productions

with :: CFilter -> CFilter -> CFilter

Pruning: in f with g, - keep only those f-productions which have at least one g-production

without :: CFilter -> CFilter -> CFilter

Pruning: in f without g, - keep only those f-productions which have no g-productions

(/>) :: CFilter -> CFilter -> CFilter

Pronounced slash, f /> g means g inside f

(</) :: CFilter -> CFilter -> CFilter

Pronounced outside, f </ g means f containing g

et :: (String -> CFilter) -> CFilter -> CFilter

Join an element-matching filter with a text-only filter

path :: [CFilter] -> CFilter

Express a list of filters like an XPath query, e.g. - path [children, tag "name1", attr "attr1", children, tag "name2"] - is like the XPath query /name1[@attr1]/name2.

Recursive search.

Recursive search has three variants: deep does a breadth-first - search of the tree, deepest does a depth-first search, multi returns - content at all tree-levels, even those strictly contained within results - that have already been returned.

deep :: CFilter -> CFilter

deepest :: CFilter -> CFilter

multi :: CFilter -> CFilter

Interior editing.

when :: CFilter -> CFilter -> CFilter

Interior editing: - f when g applies f only when the predicate g succeeds, - otherwise the content is unchanged.

guards :: CFilter -> CFilter -> CFilter

Interior editing: - g guards f applies f only when the predicate g succeeds, - otherwise the content is discarded.

chip :: CFilter -> CFilter

Process CHildren In Place. The filter is applied to any children - of an element content, and the element rebuilt around the results.

foldXml :: CFilter -> CFilter

Recursive application of filters: a fold-like operator. Defined - as f o chip (foldXml f).

Constructive filters.

mkElem :: String -> [CFilter] -> CFilter

Build an element with the given tag name - its content is the results - of the given list of filters.

mkElemAttr :: String -> [(String, CFilter)] -> [CFilter] -> CFilter

Build an element with the given name, attributes, and content.

literal :: String -> CFilter

Build some textual content.

cdata :: String -> CFilter

Build some CDATA content.

replaceTag :: String -> CFilter

Rename an element tag.

replaceAttrs :: [(String, String)] -> CFilter

Replace the attributes of an element.

C-like conditionals.

These definitions provide C-like conditionals, lifted to the filter level.

The (cond ? yes : no) style in C becomes (cond ?> yes :> no) in Haskell.

data ThenElse a

Conjoin the two branches of a conditional.

Constructors

(:>) a a

(?>) :: (a -> [b]) -> ThenElse (a -> [b]) -> a -> [b]

Select between the two branches of a joined conditional.

Filters with labelled results.

type LabelFilter a = Content -> [(a, Content)]

A LabelFilter is like a CFilter except that it pairs up a polymorphic - value (label) with each of its results.

Using and combining labelled filters.

oo :: (a -> CFilter) -> LabelFilter a -> CFilter

Compose a label-processing filter with a label-generating filter.

x :: (CFilter -> LabelFilter a) -> (CFilter -> LabelFilter b) -> CFilter -> LabelFilter (a, b)

Combine labels. Think of this as a pair-wise zip on labels.

Some label-generating filters.

numbered :: CFilter -> LabelFilter String

Number the results from 1 upwards.

interspersed :: String -> CFilter -> String -> LabelFilter String

In 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.

tagged :: CFilter -> LabelFilter String

Label each element in the result with its tag name. Non-element - results get an empty string label.

attributed :: String -> CFilter -> LabelFilter String

Label 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.

textlabelled :: CFilter -> LabelFilter (Maybe String)

Label each textual part of the result with its text. Element - results get an empty string label.

extracted :: (Content -> a) -> CFilter -> LabelFilter a

Label each content with some information extracted from itself.

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Combinators.html hunk ./docs/HaXml/Text.XML.HaXml.DtdToHaskell.Convert.html 1 - - -Text.XML.HaXml.DtdToHaskell.Convert

Text.XML.HaXml.DtdToHaskell.Convert

Description

This module performs the translation of a parsed XML DTD into the - internal representation of corresponding Haskell data/newtypes.

dtd2TypeDef :: [MarkupDecl] -> [TypeDef]

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.DtdToHaskell.Convert.html hunk ./docs/HaXml/Text.XML.HaXml.DtdToHaskell.Instance.html 1 - - -Text.XML.HaXml.DtdToHaskell.Instance

HaXml

Text.XML.HaXml.DtdToHaskell.Instance

Synopsis

mkInstance :: TypeDef -> Doc

Documentation

mkInstance :: TypeDef -> Doc

Convert typedef to appropriate instance declaration, either XmlContent, - XmlAttributes, or XmlAttrType.

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.DtdToHaskell.Instance.html hunk ./docs/HaXml/Text.XML.HaXml.DtdToHaskell.TypeDef.html 1 - - -Text.XML.HaXml.DtdToHaskell.TypeDef

HaXml

Internal representation of types

Text.XML.HaXml.DtdToHaskell.TypeDef

Contents

Internal representation of types
Pretty-print a TypeDef
Name mangling

Description

Defines an internal representation of Haskell data/newtype definitions - that correspond to the XML DTD types, and provides pretty-printers to - convert these types into the Doc type of Text.PrettyPrint.HughesPJ.

Synopsis

data TypeDef

= DataDef Bool Name AttrFields Constructors

| EnumDef Name [Name]

type Constructors = [(Name, [StructType])]

type AttrFields = [(Name, StructType)]

data StructType

= Maybe StructType

| Defaultable StructType String

| List StructType

| List1 StructType

| Tuple [StructType]

| OneOf [StructType]

| Any

| String

| Defined Name

ppTypeDef :: TypeDef -> Doc

ppHName :: Name -> Doc

ppXName :: Name -> Doc

ppAName :: Name -> Doc

data Name = Name {

xName :: String

hName :: String

}

name :: String -> Name

name_ :: String -> Name

name_a :: String -> String -> Name

name_ac :: String -> String -> String -> Name

name_f :: String -> String -> Name

mangle :: String -> String

manglef :: String -> String

data TypeDef

Constructors

DataDef Bool Name AttrFields Constructors	Bool for main/aux.
EnumDef Name [Name]

type Constructors = [(Name, [StructType])]

type AttrFields = [(Name, StructType)]

data StructType

Constructors

Maybe StructType
Defaultable StructType String	String holds default value.
List StructType
List1 StructType	Non-empty lists.
Tuple [StructType]
OneOf [StructType]
Any	XML's contentspec allows ANY
String
Defined Name

Instances

Show StructType

Pretty-print a TypeDef

ppTypeDef :: TypeDef -> Doc

ppHName :: Name -> Doc

Pretty print Haskell name.

ppXName :: Name -> Doc

Pretty print XML name.

ppAName :: Name -> Doc

Pretty print Haskell attributes name.

Name mangling

data Name

Need to keep both the XML and Haskell versions of a name.

Constructors

Name

xName :: String	original XML name
hName :: String	mangled Haskell name

name :: String -> Name

Make a name valid in both XML and Haskell.

name_ :: String -> Name

Append an underscore to the Haskell version of the name.

name_a :: String -> String -> Name

Prefix an attribute enumeration type name with its containing element - name.

name_ac :: String -> String -> String -> Name

Prefix an attribute enumeration constructor with its element-tag name, - and its enumeration type name.

name_f :: String -> String -> Name

Prefix a field name with its enclosing element name.

mangle :: String -> String

Convert an XML name to a Haskell conid.

manglef :: String -> String

Convert an XML name to a Haskell varid.

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.DtdToHaskell.TypeDef.html hunk ./docs/HaXml/Text.XML.HaXml.Escape.html 1 - - -Text.XML.HaXml.Escape

Text.XML.HaXml.Escape

xmlEscape :: XmlEscaper -> Element -> Element

xmlUnEscape :: XmlEscaper -> Element -> Element

data XmlEscaper

stdXmlEscaper :: XmlEscaper

mkXmlEscaper :: [(Char, String)] -> (Char -> Bool) -> XmlEscaper

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Escape.html hunk ./docs/HaXml/Text.XML.HaXml.Haskell2Xml.html 1 - - -Text.XML.HaXml.Haskell2Xml

HaXml

Re-export the entire set of XML type definitions

Text.XML.HaXml.Haskell2Xml

Contents

The class Haskell2Xml

Conversion functions
IO conversion functions

Auxiliary types

Description

The class Haskell2Xml is a replacement for Read and Show: it provides - textual conversions (to and from an XML representation) for your - Haskell data values. Use the tool - DrIFT to derive this class for your own datatypes, then - include this module where you want to use the facilities.

The methods toContents and fromContents convert a value to and from - a generic internal representation of an XML document without a DTD. - The functions toXml and fromXml convert a value to and from a generic - internal representation of an XML document including a DTD. - The functions readXml and showXml convert to and from Strings. - The functions fReadXml and fWriteXml do the conversion to and from - the given filenames. - The functions hGetXml and hPutXml do the conversion to and from - the given file handles. - (See the type signatures.)

Synopsis

Re-export the entire set of XML type definitions

class Haskell2Xml a where

xFromChar :: Char -> a

xToChar :: a -> Char

fromContents :: [Content] -> (a, [Content])

toContents :: a -> [Content]

toHType :: a -> HType

toXml :: (Haskell2Xml a) => a -> Document

toDTD :: HType -> DocTypeDecl

fromXml :: (Haskell2Xml a) => Document -> a

readXml :: (Haskell2Xml a) => String -> Maybe a

showXml :: (Haskell2Xml a) => a -> String

fReadXml :: (Haskell2Xml a) => FilePath -> IO a

fWriteXml :: (Haskell2Xml a) => FilePath -> a -> IO ()

hGetXml :: (Haskell2Xml a) => Handle -> IO a

hPutXml :: (Haskell2Xml a) => Handle -> a -> IO ()

data HType

= Maybe HType

| List HType

| Tuple [HType]

| Prim String String

| String

| Defined String [HType] [Constr]

data Constr = Constr String [HType] [HType]

HTML construction filters

The class Haskell2Xml

class Haskell2Xml a where

A class to convert any Haskell value to and from an XML representation.

Methods

xFromChar :: Char -> a

xToChar :: a -> Char

fromContents :: [Content] -> (a, [Content])

This function is a dummy for most types: it is used only in - the Char instance for coercing lists of Char into String.

toContents :: a -> [Content]

Parse a Haskell value from a generic XML representation, returning - the value and the remainder of the XML.

toHType :: a -> HType

Convert the Haskell value to a generic XML value.

Instances

Haskell2Xml Bool

Haskell2Xml Int

Haskell2Xml Integer

Haskell2Xml Float

Haskell2Xml Double

Haskell2Xml Char

(Haskell2Xml a) => Haskell2Xml [a]

(Haskell2Xml a, Haskell2Xml b) => Haskell2Xml (a, b)

(Haskell2Xml a) => Haskell2Xml (Maybe a)

(Haskell2Xml a, Haskell2Xml b) => Haskell2Xml (Either a b)

Haskell2Xml ()

Conversion functions

toXml :: (Haskell2Xml a) => a -> Document

Convert any Haskell value to an XML document, including both DTD and - content.

toDTD :: HType -> DocTypeDecl

toDTD converts a concrete representation of the Haskell type of - a value (obtained by the method toHType) 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.

fromXml :: (Haskell2Xml a) => Document -> a

Read a Haskell value from an XML document, ignoring the DTD and - using the Haskell result type to determine how to parse it.

readXml :: (Haskell2Xml a) => String -> Maybe a

Convert an XML document encoded as a String, into a Haskell value.

showXml :: (Haskell2Xml a) => a -> String

Convert a Haskell value to an XML document, encoded as a String.

IO conversion functions

fReadXml :: (Haskell2Xml a) => FilePath -> IO a

Read a Haskell value from an XML document stored in a file.

fWriteXml :: (Haskell2Xml a) => FilePath -> a -> IO ()

Write a Haskell value to the given file as an XML document.

hGetXml :: (Haskell2Xml a) => Handle -> IO a

Read a Haskell value from an XML document transmitted through the - given Handle.

hPutXml :: (Haskell2Xml a) => Handle -> a -> IO ()

Write a Haskell value to the given Handle as an XML document.

Auxiliary types

data HType

A concrete representation of any Haskell type.

Constructors

Maybe HType
List HType
Tuple [HType]
Prim String String	separate Haskell name and Xml name
String
Defined String [HType] [Constr]	A user-defined type has a name, a sequence of type variables, - and a set of constructors.

Instances

Eq HType

data Constr

A 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.

Constructors

Constr String [HType] [HType]

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Haskell2Xml.html hunk ./docs/HaXml/Text.XML.HaXml.Html.Generate.html 1 - - -Text.XML.HaXml.Html.Generate

Text.XML.HaXml.Html.Generate

Contents

Containers
Anchors
Text style
Tables
Breaks, lines
Attributes

A simple HTML pretty-printer

Description

These are just some common abbreviations for generating HTML - content within the XML transformation framework defined - by Text.Xml.HaXml.Combinators.

Synopsis

html :: [CFilter] -> CFilter

hhead :: [CFilter] -> CFilter

htitle :: [CFilter] -> CFilter

hbody :: [CFilter] -> CFilter

h1 :: [CFilter] -> CFilter

h2 :: [CFilter] -> CFilter

h3 :: [CFilter] -> CFilter

h4 :: [CFilter] -> CFilter

hpara :: [CFilter] -> CFilter

hdiv :: [CFilter] -> CFilter

hspan :: [CFilter] -> CFilter

margin :: [CFilter] -> CFilter

anchor :: [(String, CFilter)] -> [CFilter] -> CFilter

makehref :: CFilter -> [CFilter] -> CFilter

anchorname :: CFilter -> [CFilter] -> CFilter

hpre :: [CFilter] -> CFilter

hcentre :: [CFilter] -> CFilter

hem :: [CFilter] -> CFilter

htt :: [CFilter] -> CFilter

hbold :: [CFilter] -> CFilter

parens :: CFilter -> CFilter

bullet :: [CFilter] -> CFilter

htable :: [CFilter] -> CFilter

hrow :: [CFilter] -> CFilter

hcol :: [CFilter] -> CFilter

hbr :: CFilter

hhr :: CFilter

showattr :: String -> CFilter

(!) :: String -> CFilter

(?) :: String -> CFilter

htmlprint :: [Content] -> Doc

HTML construction filters

Containers

html :: [CFilter] -> CFilter

hhead :: [CFilter] -> CFilter

htitle :: [CFilter] -> CFilter

hbody :: [CFilter] -> CFilter

h1 :: [CFilter] -> CFilter

h2 :: [CFilter] -> CFilter

h3 :: [CFilter] -> CFilter

h4 :: [CFilter] -> CFilter

hpara :: [CFilter] -> CFilter

hdiv :: [CFilter] -> CFilter

hspan :: [CFilter] -> CFilter

margin :: [CFilter] -> CFilter

Anchors

anchor :: [(String, CFilter)] -> [CFilter] -> CFilter

makehref :: CFilter -> [CFilter] -> CFilter

anchorname :: CFilter -> [CFilter] -> CFilter

Text style

hpre :: [CFilter] -> CFilter

hcentre :: [CFilter] -> CFilter

hem :: [CFilter] -> CFilter

htt :: [CFilter] -> CFilter

hbold :: [CFilter] -> CFilter

parens :: CFilter -> CFilter

bullet :: [CFilter] -> CFilter

Tables

htable :: [CFilter] -> CFilter

hrow :: [CFilter] -> CFilter

hcol :: [CFilter] -> CFilter

Breaks, lines

hbr :: CFilter

hhr :: CFilter

Attributes

showattr :: String -> CFilter

(!) :: String -> CFilter

(?) :: String -> CFilter

A simple HTML pretty-printer

htmlprint :: [Content] -> Doc

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Html.Generate.html hunk ./docs/HaXml/Text.XML.HaXml.Html.Parse.html 1 - - -Text.XML.HaXml.Html.Parse

Text.XML.HaXml.Html.Parse

Description

This is a parser for HTML documents. Unlike for XML documents, it - must include a certain amount of error-correction to account for - HTML features like self-terminating tags, unterminated tags, and - incorrect nesting. The input is tokenised by the - XML lexer (a separate lexer is not required for HTML).

Synopsis

htmlParse :: String -> String -> Document

Documentation

htmlParse :: String -> String -> Document

The 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.

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Html.Parse.html hunk ./docs/HaXml/Text.XML.HaXml.Html.Pretty.html 1 - - -Text.XML.HaXml.Html.Pretty

Text.XML.HaXml.Html.Pretty

Description

This is a separate pretty-printer for HTML documents, recognising - some of the differences between HTML and true XML.

document :: Document -> Doc

element :: Element -> Doc

attribute :: Attribute -> Doc

content :: Content -> Doc

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Html.Pretty.html hunk ./docs/HaXml/Text.XML.HaXml.Lex.html 1 - - -Text.XML.HaXml.Lex

HaXml

Entry points to the lexer

Text.XML.HaXml.Lex

Contents

Entry points to the lexer
Token and position types

Description

You don't normally need to use this Lex module directly - it is - called automatically by the parser. (This interface is only exposed - for debugging purposes.)

This is a hand-written lexer for tokenising the text of an XML - document so that it is ready for parsing. It attaches position - information in (line,column) format to every token. The main - entry point is xmlLex. A secondary entry point, xmlReLex, is - provided for when the parser needs to stuff a string back onto - the front of the text and re-tokenise it (typically when expanding - macros).

As one would expect, the lexer is essentially a small finite - state machine.

Synopsis

xmlLex :: String -> String -> [Token]

xmlReLex :: Posn -> String -> [Token]

posInNewCxt :: String -> Maybe Posn -> Posn

type Token = Either String (Posn, TokenT)

data Posn = Pn String !Int !Int (Maybe Posn)

data TokenT

| TokStar

| TokPlus

| TokAmp

| TokSemi

| TokHash

| TokPipe

| TokName String

| TokFreeText String

| TokNull

data Special

| ENTITYx

data Section

= CDATAx

| INCLUDEx

| IGNOREx

xmlLex :: String -> String -> [Token]

The first argument to xmlLex is the filename (used for source positions, - especially in error messages), and the second is the string content of - the XML file.

xmlReLex :: Posn -> String -> [Token]

xmlReLex 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.

posInNewCxt :: String -> Maybe Posn -> Posn

posInNewCxt 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 name, but retain the stacked information that - it was included from the old pos.

Token and position types

type Token = Either String (Posn, TokenT)

All tokens are paired up with a source position. - Lexical errors are passed back through the Either type.

data Posn

Source positions contain a filename, line, column, and an - inclusion point, which is itself another source position, - recursively.

Constructors

Pn String !Int !Int (Maybe Posn)

Instances

Show Posn

data TokenT

The basic token type.

Constructors

TokCommentOpen	<!--
TokCommentClose	-->
TokPIOpen	<?
TokPIClose	?>
TokSectionOpen	<![
TokSectionClose	]]>
TokSection Section	CDATA INCLUDE IGNORE etc
TokSpecialOpen	<!
TokSpecial Special	DOCTYPE ELEMENT ATTLIST etc
TokEndOpen	</
TokEndClose	/>
TokAnyOpen	<
TokAnyClose	>
TokSqOpen	[
TokSqClose	]
TokEqual	=
TokQuery	?
TokStar	*
TokPlus	+
TokAmp	&
TokSemi	;
TokHash	#
TokBraOpen	(
TokBraClose	)
TokPipe	\|
TokPercent	%
TokComma	,
TokQuote	'' or ""
TokName String	begins with letter, no spaces
TokFreeText String	any character data
TokNull	fake token

Instances

Show TokenT

data Special

Constructors

DOCTYPEx
ELEMENTx
ATTLISTx
ENTITYx
NOTATIONx

data Section

Constructors

CDATAx
INCLUDEx
IGNOREx

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Lex.html hunk ./docs/HaXml/Text.XML.HaXml.OneOfN.html 1 - - -Text.XML.HaXml.OneOfN

Text.XML.HaXml.OneOfN

data OneOf2 a b

Constructors

OneOf2 a
TwoOf2 b

Instances

(XmlContent a, XmlContent b) => XmlContent (OneOf2 a b)

data OneOf3 a b c

Constructors

OneOf3 a
TwoOf3 b
ThreeOf3 c

Instances

(XmlContent a, XmlContent b, XmlContent c) => XmlContent (OneOf3 a b c)

data OneOf4 a b c d

Constructors

OneOf4 a
TwoOf4 b
ThreeOf4 c
FourOf4 d

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d) => XmlContent (OneOf4 a b c d)

data OneOf5 a b c d e

Constructors

OneOf5 a
TwoOf5 b
ThreeOf5 c
FourOf5 d
FiveOf5 e

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e) => XmlContent (OneOf5 a b c d e)

data OneOf6 a b c d e f

Constructors

OneOf6 a
TwoOf6 b
ThreeOf6 c
FourOf6 d
FiveOf6 e
SixOf6 f

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f) => XmlContent (OneOf6 a b c d e f)

data OneOf7 a b c d e f g

Constructors

OneOf7 a
TwoOf7 b
ThreeOf7 c
FourOf7 d
FiveOf7 e
SixOf7 f
SevenOf7 g

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g) => XmlContent (OneOf7 a b c d e f g)

data OneOf8 a b c d e f g h

Constructors

OneOf8 a
TwoOf8 b
ThreeOf8 c
FourOf8 d
FiveOf8 e
SixOf8 f
SevenOf8 g
EightOf8 h

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h) => XmlContent (OneOf8 a b c d e f g h)

data OneOf9 a b c d e f g h i

Constructors

OneOf9 a
TwoOf9 b
ThreeOf9 c
FourOf9 d
FiveOf9 e
SixOf9 f
SevenOf9 g
EightOf9 h
NineOf9 i

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i) => XmlContent (OneOf9 a b c d e f g h i)

data OneOf10 a b c d e f g h i j

Constructors

OneOf10 a
TwoOf10 b
ThreeOf10 c
FourOf10 d
FiveOf10 e
SixOf10 f
SevenOf10 g
EightOf10 h
NineOf10 i
TenOf10 j

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j) => XmlContent (OneOf10 a b c d e f g h i j)

data OneOf11 a b c d e f g h i j k

Constructors

OneOf11 a
TwoOf11 b
ThreeOf11 c
FourOf11 d
FiveOf11 e
SixOf11 f
SevenOf11 g
EightOf11 h
NineOf11 i
TenOf11 j
ElevenOf11 k

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k) => XmlContent (OneOf11 a b c d e f g h i j k)

data OneOf12 a b c d e f g h i j k l

Constructors

OneOf12 a
TwoOf12 b
ThreeOf12 c
FourOf12 d
FiveOf12 e
SixOf12 f
SevenOf12 g
EightOf12 h
NineOf12 i
TenOf12 j
ElevenOf12 k
TwelveOf12 l

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k, XmlContent l) => XmlContent (OneOf12 a b c d e f g h i j k l)

data OneOf13 a b c d e f g h i j k l m

Constructors

OneOf13 a
TwoOf13 b
ThreeOf13 c
FourOf13 d
FiveOf13 e
SixOf13 f
SevenOf13 g
EightOf13 h
NineOf13 i
TenOf13 j
ElevenOf13 k
TwelveOf13 l
ThirteenOf13 m

Instances

data OneOf14 a b c d e f g h i j k l m n

Constructors

OneOf14 a
TwoOf14 b
ThreeOf14 c
FourOf14 d
FiveOf14 e
SixOf14 f
SevenOf14 g
EightOf14 h
NineOf14 i
TenOf14 j
ElevenOf14 k
TwelveOf14 l
ThirteenOf14 m
FourteenOf14 n

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k, XmlContent l, XmlContent m, XmlContent n) => XmlContent (OneOf14 a b c d e f g h i j k l m n)

data OneOf15 a b c d e f g h i j k l m n o

Constructors

OneOf15 a
TwoOf15 b
ThreeOf15 c
FourOf15 d
FiveOf15 e
SixOf15 f
SevenOf15 g
EightOf15 h
NineOf15 i
TenOf15 j
ElevenOf15 k
TwelveOf15 l
ThirteenOf15 m
FourteenOf15 n
FifteenOf15 o

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k, XmlContent l, XmlContent m, XmlContent n, XmlContent o) => XmlContent (OneOf15 a b c d e f g h i j k l m n o)

data OneOf16 a b c d e f g h i j k l m n o p

Constructors

OneOf16 a
TwoOf16 b
ThreeOf16 c
FourOf16 d
FiveOf16 e
SixOf16 f
SevenOf16 g
EightOf16 h
NineOf16 i
TenOf16 j
ElevenOf16 k
TwelveOf16 l
ThirteenOf16 m
FourteenOf16 n
FifteenOf16 o
SixteenOf16 p

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k, XmlContent l, XmlContent m, XmlContent n, XmlContent o, XmlContent p) => XmlContent (OneOf16 a b c d e f g h i j k l m n o p)

data OneOf17 a b c d e f g h i j k l m n o p q

Constructors

OneOf17 a
TwoOf17 b
ThreeOf17 c
FourOf17 d
FiveOf17 e
SixOf17 f
SevenOf17 g
EightOf17 h
NineOf17 i
TenOf17 j
ElevenOf17 k
TwelveOf17 l
ThirteenOf17 m
FourteenOf17 n
FifteenOf17 o
SixteenOf17 p
SeventeenOf17 q

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k, XmlContent l, XmlContent m, XmlContent n, XmlContent o, XmlContent p, XmlContent q) => XmlContent (OneOf17 a b c d e f g h i j k l m n o p q)

data OneOf18 a b c d e f g h i j k l m n o p q r

Constructors

OneOf18 a
TwoOf18 b
ThreeOf18 c
FourOf18 d
FiveOf18 e
SixOf18 f
SevenOf18 g
EightOf18 h
NineOf18 i
TenOf18 j
ElevenOf18 k
TwelveOf18 l
ThirteenOf18 m
FourteenOf18 n
FifteenOf18 o
SixteenOf18 p
SeventeenOf18 q
EighteenOf18 r

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k, XmlContent l, XmlContent m, XmlContent n, XmlContent o, XmlContent p, XmlContent q, XmlContent r) => XmlContent (OneOf18 a b c d e f g h i j k l m n o p q r)

data OneOf19 a b c d e f g h i j k l m n o p q r s

Constructors

OneOf19 a
TwoOf19 b
ThreeOf19 c
FourOf19 d
FiveOf19 e
SixOf19 f
SevenOf19 g
EightOf19 h
NineOf19 i
TenOf19 j
ElevenOf19 k
TwelveOf19 l
ThirteenOf19 m
FourteenOf19 n
FifteenOf19 o
SixteenOf19 p
SeventeenOf19 q
EighteenOf19 r
NineteenOf19 s

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k, XmlContent l, XmlContent m, XmlContent n, XmlContent o, XmlContent p, XmlContent q, XmlContent r, XmlContent s) => XmlContent (OneOf19 a b c d e f g h i j k l m n o p q r s)

data OneOf20 a b c d e f g h i j k l m n o p q r s t

Constructors

OneOf20 a
TwoOf20 b
ThreeOf20 c
FourOf20 d
FiveOf20 e
SixOf20 f
SevenOf20 g
EightOf20 h
NineOf20 i
TenOf20 j
ElevenOf20 k
TwelveOf20 l
ThirteenOf20 m
FourteenOf20 n
FifteenOf20 o
SixteenOf20 p
SeventeenOf20 q
EighteenOf20 r
NineteenOf20 s
TwentyOf20 t

Instances

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k, XmlContent l, XmlContent m, XmlContent n, XmlContent o, XmlContent p, XmlContent q, XmlContent r, XmlContent s, XmlContent t) => XmlContent (OneOf20 a b c d e f g h i j k l m n o p q r s t)

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.OneOfN.html hunk ./docs/HaXml/Text.XML.HaXml.Parse.html 1 - - -Text.XML.HaXml.Parse

HaXml

Pretty-print a whole document

Text.XML.HaXml.Parse

Contents

Parse a whole document
Parse just a DTD

Description

A non-validating XML parser. For the input grammar, see - http://www.w3.org/TR/REC-xml.

Synopsis

xmlParse :: String -> String -> Document

xmlParse' :: String -> String -> Either String Document

dtdParse :: String -> String -> Maybe DocTypeDecl

dtdParse' :: String -> String -> Either String (Maybe DocTypeDecl)

Parse a whole document

xmlParse :: String -> String -> Document

To 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.

xmlParse' :: String -> String -> Either String Document

To 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.

Parse just a DTD

dtdParse :: String -> String -> Maybe DocTypeDecl

To parse just a DTD, dtdParse file content 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.

dtdParse' :: String -> String -> Either String (Maybe DocTypeDecl)

To parse just a DTD, dtdParse' file content takes a filename - (for generating error reports) and the string content of that - file. If no DTD was found, you get Right Nothing. - If a DTD was found but contains errors, you get a Left message.

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Parse.html hunk ./docs/HaXml/Text.XML.HaXml.Pretty.html 1 - - -Text.XML.HaXml.Pretty

Text.XML.HaXml.Pretty

Contents

Just one content
Just one tagged element

Pretty-print just a DTD

The prolog
A content particle description

Description

This is a pretty-printer for turning the internal representation - of generic structured XML documents into the Doc type (which can - later be rendered using Text.ParserCombinators.HughesPJ.render). - Essentially there is one pp function for each type in - Text.Xml.HaXml.Types, so you can pretty-print as much or as little - of the document as you wish.

Synopsis

document :: Document -> Doc

content :: Content -> Doc

element :: Element -> Doc

doctypedecl :: DocTypeDecl -> Doc

prolog :: Prolog -> Doc

cp :: CP -> Doc

Pretty-print a whole document

document :: Document -> Doc

Just one content

content :: Content -> Doc

Just one tagged element

element :: Element -> Doc

Pretty-print just a DTD

doctypedecl :: DocTypeDecl -> Doc

The prolog

prolog :: Prolog -> Doc

A content particle description

cp :: CP -> Doc

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Pretty.html hunk ./docs/HaXml/Text.XML.HaXml.Types.html 1 - - -Text.XML.HaXml.Types

Text.XML.HaXml.Types

Contents

A simple symbol table mapping strings (references) to values.

Symbol table operations

XML Types

The top-level document container

The main document content

Administrative parts of the document

The DTD

content model
attribute model
conditional sections

References

Entities

Basic value types

Description

This module defines an internal (generic) representation for XML - documents including their DTDs.

History: - The original module was derived by hand from the XML specification, - following the grammar precisely. Then we simplified the types, - removing layers of indirection and redundancy, and generally making - things easier to work with. Then we allowed PEReferences to be - ubiquitous, by removing them from the types and resolving all - PE references at parse-time. Finally, we added a per-document - symbol table for GEReferences, and a whitespace-significance flag - for plaintext. -

Synopsis

type SymTab a = [(String, a)]

emptyST :: SymTab a

addST :: String -> a -> SymTab a -> SymTab a

lookupST :: String -> SymTab a -> Maybe a

data Document = Document Prolog (SymTab EntityDef) Element [Misc]

data Element = Elem Name [Attribute] [Content]

data ElemTag = ElemTag Name [Attribute]

data Content

= CElem Element

| CString Bool CharData

| CRef Reference

| CMisc Misc

type Attribute = (Name, AttValue)

data AttValue = AttValue [Either String Reference]

data Prolog = Prolog (Maybe XMLDecl) [Misc] (Maybe DocTypeDecl) [Misc]

data XMLDecl = XMLDecl VersionInfo (Maybe EncodingDecl) (Maybe SDDecl)

data Misc

= Comment Comment

| PI ProcessingInstruction

type ProcessingInstruction = (PITarget, String)

type SDDecl = Bool

type VersionInfo = String

type Comment = String

type PITarget = String

data DocTypeDecl = DTD Name (Maybe ExternalID) [MarkupDecl]

data MarkupDecl

= Element ElementDecl

| AttList AttListDecl

| Entity EntityDecl

| Notation NotationDecl

| MarkupMisc Misc

data ExtSubset = ExtSubset (Maybe TextDecl) [ExtSubsetDecl]

data ExtSubsetDecl

= ExtMarkupDecl MarkupDecl

| ExtConditionalSect ConditionalSect

data ElementDecl = ElementDecl Name ContentSpec

data ContentSpec

= EMPTY

| ANY

| Mixed Mixed

| ContentSpec CP

data CP

= TagName Name Modifier

| Choice [CP] Modifier

| Seq [CP] Modifier

data Modifier

= None

| Query

| Star

| Plus

data Mixed

= PCDATA

| PCDATAplus [Name]

data AttListDecl = AttListDecl Name [AttDef]

data AttDef = AttDef Name AttType DefaultDecl

data AttType

= StringType

| TokenizedType TokenizedType

| EnumeratedType EnumeratedType

data TokenizedType

= ID

| IDREF

| IDREFS

| ENTITY

| ENTITIES

| NMTOKEN

| NMTOKENS

data EnumeratedType

= NotationType NotationType

| Enumeration Enumeration

type NotationType = [Name]

type Enumeration = [NmToken]

data DefaultDecl

= REQUIRED

| IMPLIED

| DefaultTo AttValue (Maybe FIXED)

data FIXED = FIXED

data ConditionalSect

= IncludeSect IncludeSect

| IgnoreSect IgnoreSect

type IncludeSect = [ExtSubsetDecl]

type IgnoreSect = [IgnoreSectContents]

data Ignore = Ignore

data IgnoreSectContents = IgnoreSectContents Ignore [(IgnoreSectContents, Ignore)]

data Reference

= RefEntity EntityRef

| RefChar CharRef

type EntityRef = Name

type CharRef = Int

type PEReference = Name

data EntityDecl

= EntityGEDecl GEDecl

| EntityPEDecl PEDecl

data GEDecl = GEDecl Name EntityDef

data PEDecl = PEDecl Name PEDef

data EntityDef

= DefEntityValue EntityValue

| DefExternalID ExternalID (Maybe NDataDecl)

data PEDef

= PEDefEntityValue EntityValue

| PEDefExternalID ExternalID

data ExternalID

= SYSTEM SystemLiteral

| PUBLIC PubidLiteral SystemLiteral

data NDataDecl = NDATA Name

data TextDecl = TextDecl (Maybe VersionInfo) EncodingDecl

data ExtParsedEnt = ExtParsedEnt (Maybe TextDecl) Content

data ExtPE = ExtPE (Maybe TextDecl) [ExtSubsetDecl]

data NotationDecl = NOTATION Name (Either ExternalID PublicID)

data PublicID = PUBLICID PubidLiteral

data EncodingDecl = EncodingDecl String

data EntityValue = EntityValue [EV]

data EV

= EVString String

| EVRef Reference

data PubidLiteral = PubidLiteral String

data SystemLiteral = SystemLiteral String

type Name = String

type Names = [Name]

type NmToken = String

type NmTokens = [NmToken]

type CharData = String

type CDSect = CharData

A simple symbol table mapping strings (references) to values.

type SymTab a = [(String, a)]

Symbol table operations

emptyST :: SymTab a

addST :: String -> a -> SymTab a -> SymTab a

lookupST :: String -> SymTab a -> Maybe a

XML Types

The top-level document container

data Document

The symbol table stored in a document holds all its general entity - reference definitions.

Constructors

Document Prolog (SymTab EntityDef) Element [Misc]

The main document content

data Element

Constructors

Elem Name [Attribute] [Content]

Instances

Verbatim Element

data ElemTag

Constructors

ElemTag Name [Attribute]

intermediate for parsing

Instances

Eq ElemTag

data Content

Constructors

CElem Element
CString Bool CharData	bool is whether whitespace is significant
CRef Reference
CMisc Misc

Instances

Verbatim Content

type Attribute = (Name, AttValue)

data AttValue

Constructors

AttValue [Either String Reference]

Administrative parts of the document

data Prolog

Constructors

Prolog (Maybe XMLDecl) [Misc] (Maybe DocTypeDecl) [Misc]

data XMLDecl

Constructors

XMLDecl VersionInfo (Maybe EncodingDecl) (Maybe SDDecl)

data Misc

Constructors

Comment Comment
PI ProcessingInstruction

type ProcessingInstruction = (PITarget, String)

type SDDecl = Bool

type VersionInfo = String

type Comment = String

type PITarget = String

The DTD

content model

data DocTypeDecl

Constructors

DTD Name (Maybe ExternalID) [MarkupDecl]

data MarkupDecl

Constructors

Element ElementDecl
AttList AttListDecl
Entity EntityDecl
Notation NotationDecl
MarkupMisc Misc

data ExtSubset

Constructors

ExtSubset (Maybe TextDecl) [ExtSubsetDecl]

data ExtSubsetDecl

Constructors

ExtMarkupDecl MarkupDecl
ExtConditionalSect ConditionalSect

data ElementDecl

Constructors

ElementDecl Name ContentSpec

data ContentSpec

Constructors

EMPTY
ANY
Mixed Mixed
ContentSpec CP

data CP

Constructors

TagName Name Modifier
Choice [CP] Modifier
Seq [CP] Modifier

Instances

Show CP

data Modifier

Constructors

None	Just One
Query	Zero Or One
Star	Zero Or More
Plus	One Or More

Instances

Show Modifier

data Mixed

Constructors

PCDATA
PCDATAplus [Name]

attribute model

data AttListDecl

Constructors

AttListDecl Name [AttDef]

data AttDef

Constructors

AttDef Name AttType DefaultDecl

data AttType

Constructors

StringType
TokenizedType TokenizedType
EnumeratedType EnumeratedType

data TokenizedType

Constructors

ID
IDREF
IDREFS
ENTITY
ENTITIES
NMTOKEN
NMTOKENS

data EnumeratedType

Constructors

NotationType NotationType
Enumeration Enumeration

type NotationType = [Name]

type Enumeration = [NmToken]

data DefaultDecl

Constructors

REQUIRED
IMPLIED
DefaultTo AttValue (Maybe FIXED)

data FIXED

Constructors

FIXED

conditional sections

data ConditionalSect

Constructors

IncludeSect IncludeSect
IgnoreSect IgnoreSect

type IncludeSect = [ExtSubsetDecl]

type IgnoreSect = [IgnoreSectContents]

data Ignore

Constructors

Ignore

data IgnoreSectContents

Constructors

IgnoreSectContents Ignore [(IgnoreSectContents, Ignore)]

References

data Reference

Constructors

RefEntity EntityRef
RefChar CharRef

Instances

Verbatim Reference

type EntityRef = Name

type CharRef = Int

type PEReference = Name

Entities

data EntityDecl

Constructors

EntityGEDecl GEDecl
EntityPEDecl PEDecl

data GEDecl

Constructors

GEDecl Name EntityDef

data PEDecl

Constructors

PEDecl Name PEDef

data EntityDef

Constructors

DefEntityValue EntityValue
DefExternalID ExternalID (Maybe NDataDecl)

data PEDef

Constructors

PEDefEntityValue EntityValue
PEDefExternalID ExternalID

data ExternalID

Constructors

SYSTEM SystemLiteral
PUBLIC PubidLiteral SystemLiteral

data NDataDecl

Constructors

NDATA Name

data TextDecl

Constructors

TextDecl (Maybe VersionInfo) EncodingDecl

data ExtParsedEnt

Constructors

ExtParsedEnt (Maybe TextDecl) Content

data ExtPE

Constructors

ExtPE (Maybe TextDecl) [ExtSubsetDecl]

data NotationDecl

Constructors

NOTATION Name (Either ExternalID PublicID)

data PublicID

Constructors

PUBLICID PubidLiteral

data EncodingDecl

Constructors

EncodingDecl String

data EntityValue

Constructors

EntityValue [EV]

data EV

Constructors

EVString String
EVRef Reference

data PubidLiteral

Constructors

PubidLiteral String

data SystemLiteral

Constructors

SystemLiteral String

Basic value types

type Name = String

type Names = [Name]

type NmToken = String

type NmTokens = [NmToken]

type CharData = String

type CDSect = CharData

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Types.html hunk ./docs/HaXml/Text.XML.HaXml.Validate.html 1 - - -Text.XML.HaXml.Validate

HaXml

Text.XML.HaXml.Validate

Description

Validate a document against a dtd.

Synopsis

validate :: DocTypeDecl -> Element -> [String]

partialValidate :: DocTypeDecl -> Element -> [String]

Documentation

validate :: DocTypeDecl -> Element -> [String]

validate 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.

partialValidate :: DocTypeDecl -> Element -> [String]

partialValidate is like validate, except that it does not check that - the element type matches that of the DTD's root element.

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Validate.html hunk ./docs/HaXml/Text.XML.HaXml.Verbatim.html 1 - - -Text.XML.HaXml.Verbatim

HaXml

Text.XML.HaXml.Verbatim

Portability	portable
Stability	experimental
Maintainer	simons@cryp.to

Description

The preferred method for rendering a Document or single Content - is by using the pretty printing facility defined in Pretty. - Pretty-printing does not work well for cases, however, where the - formatting in the XML document is significant. Examples of this - case are XHTML's <pre> tag, Docbook's <literallayout> tag, - and many more.

Theoretically, the document author could avoid this problem by - wrapping the contents of these tags in a <![CDATA[...]]> section, - but often this is not practical, for instance when the - literal-layout section contains other elements. Finally, program - writers could manually format these elements by transforming them - into a literal string in their CFliter, etc., but this is - annoying to do and prone to omissions and formatting errors.

As an alternative, this module provides the function verbatim, - which will format XML Content as a String while retaining the - formatting of the input document unchanged.

Know problems:

HaXml's parser eats line feeds between two tags.
Attributes should be formatted by making them an instance of - Verbatim as well, but since an Attribute is just a tuple, - not a full data type, the helper function verbAttr must be - used instead.
CMisc is not yet supported.
Elements, which contain no content, are formatted as - <element-name/>, even if they were not defined as being of - type EMPTY. In XML this perfectly alright, but in SGML it is - not. Those, who wish to use verbatim to format parts of say - an HTML page will have to (a) replace problematic elements by - literals before running verbatim or (b) use a second - search-and-replace stage to fix this. -

Synopsis

class Verbatim a where

verbatim :: a -> String

verbAttr :: Attribute -> String

Documentation

class Verbatim a where

This class promises that the function verbatim knows how to - format this data type into a string without changing the - formatting.

Methods

verbatim :: a -> String

Instances

(Verbatim a) => Verbatim [a]

Verbatim Char

(Verbatim a, Verbatim b) => Verbatim (Either a b)

Verbatim Content

Verbatim Element

Verbatim Reference

verbAttr :: Attribute -> String

This is a helper function is required because Haskell does not - allow to make an ordinary tuple (like Attribute) an instance of a - class. The resulting output will preface the actual attribute with - a single blank so that lists of Attributes can be handled - implicitly by the definition for lists of Verbatim data types.

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Verbatim.html hunk ./docs/HaXml/Text.XML.HaXml.Wrappers.html 1 - - -Text.XML.HaXml.Wrappers

HaXml

Text.XML.HaXml.Wrappers

Synopsis

fix2Args :: IO (String, String)

processXmlWith :: CFilter -> IO ()

Documentation

fix2Args :: IO (String, String)

This useful auxiliary checks the commandline arguments for two - filenames, the input and output file respectively. If either - is missing, it is replaced by '-', which can be interpreted by the - caller as stdin and/or stdout.

processXmlWith :: CFilter -> IO ()

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.

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Wrappers.html hunk ./docs/HaXml/Text.XML.HaXml.Xml2Haskell.html 1 - - -Text.XML.HaXml.Xml2Haskell

HaXml

Reading and writing XML data into a typed Haskell representation.

Text.XML.HaXml.Xml2Haskell

Contents

Reading and writing XML data into a typed Haskell representation.
The enabling classes.
Parsing and printing helper functions
Re-exports

Description

This module provides the XmlContent class and readXml and writeXml - functions that you will need if you generate a module of Haskell - datatype definitions from an XML DTD. Use the DtdToHaskell - program to generate both datatypes and instances of this class, - then import this module to read and write values to and from XML files.

Synopsis

readXml :: (XmlContent a) => String -> Maybe a

showXml :: (XmlContent a) => a -> String

hGetXml :: (XmlContent a) => Handle -> IO a

hPutXml :: (XmlContent a) => Handle -> a -> IO ()

fReadXml :: (XmlContent a) => FilePath -> IO a

fWriteXml :: (XmlContent a) => FilePath -> a -> IO ()

class XmlContent a where

toElem :: a -> [Content]

fromElem :: [Content] -> (Maybe a, [Content])

class XmlAttributes a where

toAttrs :: a -> [Attribute]

fromAttrs :: [Attribute] -> a

class XmlAttrType a where

toAttrFrTyp :: String -> a -> Maybe Attribute

fromAttrToTyp :: String -> Attribute -> Maybe a

choice :: (XmlContent a) => (a -> b) -> ([Content] -> (Maybe b, [Content])) -> [Content] -> (Maybe b, [Content])

definite :: ([Content] -> (Maybe a, [Content])) -> String -> String -> [Content] -> (a, [Content])

many :: ([Content] -> (Maybe a, [Content])) -> [Content] -> ([a], [Content])

fromText :: [Content] -> (Maybe String, [Content])

toText :: String -> [Content]

data List1 a = NonEmpty [a]

data ANYContent = ANYContent

maybeToAttr :: (String -> a -> Maybe Attribute) -> String -> Maybe a -> Maybe Attribute

defaultToAttr :: (String -> a -> Maybe Attribute) -> String -> Defaultable a -> Maybe Attribute

definiteA :: (String -> Attribute -> Maybe a) -> String -> String -> [Attribute] -> a

defaultA :: (String -> Attribute -> Maybe a) -> a -> String -> [Attribute] -> Defaultable a

possibleA :: (String -> Attribute -> Maybe a) -> String -> [Attribute] -> Maybe a

fromAttrToStr :: String -> Attribute -> Maybe String

toAttrFrStr :: String -> String -> Maybe Attribute

data Defaultable a

= Default a

| NonDefault a

str2attr :: String -> AttValue

attr2str :: AttValue -> String

data Element = Elem Name [Attribute] [Content]

data Content

= CElem Element

| CString Bool CharData

| CRef Reference

| CMisc Misc

readXml :: (XmlContent a) => String -> Maybe a

Read a fully-typed XML document from a string.

showXml :: (XmlContent a) => a -> String

Convert a fully-typed XML document to a string.

hGetXml :: (XmlContent a) => Handle -> IO a

Read a fully-typed XML document from a file handle.

hPutXml :: (XmlContent a) => Handle -> a -> IO ()

Write a fully-typed XML document to a file handle.

fReadXml :: (XmlContent a) => FilePath -> IO a

Read an XML document from a file and convert it to a fully-typed - Haskell value.

fWriteXml :: (XmlContent a) => FilePath -> a -> IO ()

Write a fully-typed Haskell value to the given file as an XML - document.

The enabling classes.

class XmlContent a where

The XmlContent class promises that an XML content element can be - converted to and from a Haskell value.

Methods

toElem :: a -> [Content]

fromElem :: [Content] -> (Maybe a, [Content])

Instances

(XmlContent a, XmlContent b) => XmlContent (OneOf2 a b)

(XmlContent a, XmlContent b, XmlContent c) => XmlContent (OneOf3 a b c)

(XmlContent a, XmlContent b, XmlContent c, XmlContent d) => XmlContent (OneOf4 a b c d)

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e) => XmlContent (OneOf5 a b c d e)

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f) => XmlContent (OneOf6 a b c d e f)

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g) => XmlContent (OneOf7 a b c d e f g)

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h) => XmlContent (OneOf8 a b c d e f g h)

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i) => XmlContent (OneOf9 a b c d e f g h i)

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j) => XmlContent (OneOf10 a b c d e f g h i j)

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k, XmlContent l, XmlContent m, XmlContent n, XmlContent o) => XmlContent (OneOf15 a b c d e f g h i j k l m n o)

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k, XmlContent l, XmlContent m, XmlContent n, XmlContent o, XmlContent p) => XmlContent (OneOf16 a b c d e f g h i j k l m n o p)

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k, XmlContent l, XmlContent m, XmlContent n, XmlContent o, XmlContent p, XmlContent q) => XmlContent (OneOf17 a b c d e f g h i j k l m n o p q)

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k, XmlContent l, XmlContent m, XmlContent n, XmlContent o, XmlContent p, XmlContent q, XmlContent r) => XmlContent (OneOf18 a b c d e f g h i j k l m n o p q r)

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k, XmlContent l, XmlContent m, XmlContent n, XmlContent o, XmlContent p, XmlContent q, XmlContent r, XmlContent s) => XmlContent (OneOf19 a b c d e f g h i j k l m n o p q r s)

(XmlContent a, XmlContent b, XmlContent c, XmlContent d, XmlContent e, XmlContent f, XmlContent g, XmlContent h, XmlContent i, XmlContent j, XmlContent k, XmlContent l, XmlContent m, XmlContent n, XmlContent o, XmlContent p, XmlContent q, XmlContent r, XmlContent s, XmlContent t) => XmlContent (OneOf20 a b c d e f g h i j k l m n o p q r s t)

(XmlContent a, XmlContent b) => XmlContent (a, b)

(XmlContent a, XmlContent b, XmlContent c) => XmlContent (a, b, c)

(XmlContent a) => XmlContent [a]

(XmlContent a) => XmlContent (Maybe a)

(XmlContent a) => XmlContent (List1 a)

XmlContent ANYContent

class XmlAttributes a where

The XmlAttributes class promises that a list of XML tag attributes - can be converted to and from a Haskell value.

Methods

toAttrs :: a -> [Attribute]

fromAttrs :: [Attribute] -> a

class XmlAttrType a where

The XmlAttrType class promises that an attribute taking an XML enumerated - type can be converted to and from a Haskell value.

Methods

toAttrFrTyp :: String -> a -> Maybe Attribute

fromAttrToTyp :: String -> Attribute -> Maybe a

Parsing and printing helper functions

choice :: (XmlContent a) => (a -> b) -> ([Content] -> (Maybe b, [Content])) -> [Content] -> (Maybe b, [Content])

definite :: ([Content] -> (Maybe a, [Content])) -> String -> String -> [Content] -> (a, [Content])

many :: ([Content] -> (Maybe a, [Content])) -> [Content] -> ([a], [Content])

fromText :: [Content] -> (Maybe String, [Content])

toText :: String -> [Content]

data List1 a

The List1 type represents lists with at least one element. - It is required for DTD content models that use + as a modifier.

Constructors

NonEmpty [a]

Instances

(XmlContent a) => XmlContent (List1 a)

data ANYContent

A type corresponding to XML's ANY contentspec -data ANYContent = forall a . XmlContent a => ANYContent a

Constructors

ANYContent

Instances

XmlContent ANYContent

maybeToAttr :: (String -> a -> Maybe Attribute) -> String -> Maybe a -> Maybe Attribute

defaultToAttr :: (String -> a -> Maybe Attribute) -> String -> Defaultable a -> Maybe Attribute

definiteA :: (String -> Attribute -> Maybe a) -> String -> String -> [Attribute] -> a

defaultA :: (String -> Attribute -> Maybe a) -> a -> String -> [Attribute] -> Defaultable a

possibleA :: (String -> Attribute -> Maybe a) -> String -> [Attribute] -> Maybe a

fromAttrToStr :: String -> Attribute -> Maybe String

toAttrFrStr :: String -> String -> Maybe Attribute

data Defaultable a

If 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).

Constructors

Default a
NonDefault a

str2attr :: String -> AttValue

attr2str :: AttValue -> String

Re-exports

data Element

Constructors

Elem Name [Attribute] [Content]

Instances

Verbatim Element

data Content

Constructors

CElem Element
CString Bool CharData	bool is whether whitespace is significant
CRef Reference
CMisc Misc

Instances

Verbatim Content

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Xml2Haskell.html hunk ./docs/HaXml/Text.XML.HaXml.Xtract.Combinators.html 1 - - -Text.XML.HaXml.Xtract.Combinators

HaXml

Text.XML.HaXml.Xtract.Combinators

Description

This is a new set of XML combinators for Xtract, not standard, - but based on the standard set in Text.Xml.Haxml.Combinators. - The main difference is that the Content Filter type becomes a - Double Filter. A Double Filter always takes the whole document - as an extra argument, so you can start to traverse it again from - any inner location within the document tree.

The new combinators definitions are derived from the old ones. - New names are derived from the old by surrounding with the letter o, - or by doubling the operator symbols.

Synopsis

type DFilter = Content -> Content -> [Content]

local :: CFilter -> DFilter

global :: CFilter -> DFilter

dfilter :: DFilter -> CFilter

oloco :: (CFilter -> CFilter) -> DFilter -> DFilter

oglobo :: (CFilter -> CFilter) -> DFilter -> DFilter

ooo :: DFilter -> DFilter -> DFilter

(||>||) :: (a -> b -> [c]) -> (a -> b -> [c]) -> a -> b -> [c]

owitho :: DFilter -> DFilter -> DFilter

owithouto :: DFilter -> DFilter -> DFilter

okeepo :: DFilter

ononeo :: DFilter

ochildreno :: DFilter

oelmo :: DFilter

otxto :: DFilter

applypred :: CFilter -> DFilter -> CFilter

oiffindo :: String -> (String -> DFilter) -> DFilter -> DFilter

oifTxto :: (String -> DFilter) -> DFilter -> DFilter

ocato :: [a -> b -> [c]] -> a -> b -> [c]

(//>>) :: DFilter -> DFilter -> DFilter

(<<//) :: DFilter -> DFilter -> DFilter

odeepo :: DFilter -> DFilter

Documentation

type DFilter = Content -> Content -> [Content]

double content filter - takes document root + local subtree.

local :: CFilter -> DFilter

lift an ordinary content filter to a double filter.

global :: CFilter -> DFilter

dfilter :: DFilter -> CFilter

drop a double filter to an ordinary content filter

oloco :: (CFilter -> CFilter) -> DFilter -> DFilter

lift a CFilter combinator to a DFilter combinator

oglobo :: (CFilter -> CFilter) -> DFilter -> DFilter

ooo :: DFilter -> DFilter -> DFilter

lifted composition over double filters.

(||>||) :: (a -> b -> [c]) -> (a -> b -> [c]) -> a -> b -> [c]

lifted choice.

owitho :: DFilter -> DFilter -> DFilter

lifted predicates.

owithouto :: DFilter -> DFilter -> DFilter

okeepo :: DFilter

lifted unit and zero.

ononeo :: DFilter

ochildreno :: DFilter

oelmo :: DFilter

otxto :: DFilter

applypred :: CFilter -> DFilter -> CFilter

oiffindo :: String -> (String -> DFilter) -> DFilter -> DFilter

oifTxto :: (String -> DFilter) -> DFilter -> DFilter

ocato :: [a -> b -> [c]] -> a -> b -> [c]

(//>>) :: DFilter -> DFilter -> DFilter

(<<//) :: DFilter -> DFilter -> DFilter

odeepo :: DFilter -> DFilter

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Xtract.Combinators.html hunk ./docs/HaXml/Text.XML.HaXml.Xtract.Lex.html 1 - - -Text.XML.HaXml.Xtract.Lex

Text.XML.HaXml.Xtract.Lex

Description

This is another hand-written lexer, this time for the Xtract - command-language. The entry point is lexXtract. You don't - normally need to use this module directly - the lexer is called - automatically by the parser. (We only expose this interface - for debugging purposes.)

The Xtract command language is very like the XPath specification.

lexXtract :: String -> [Token]

data Posn

Constructors

Pn Int

Instances

Show Posn

data TokenT

Constructors

Symbol String
TokString String
TokNum Integer

Instances

Show TokenT

type Token = Either String (Posn, TokenT)

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Xtract.Lex.html hunk ./docs/HaXml/Text.XML.HaXml.Xtract.Parse.html 1 - - -Text.XML.HaXml.Xtract.Parse

HaXml

Text.XML.HaXml.Xtract.Parse

Description

A parser for the Xtract command-language. (The string input is - tokenised internally by the lexer lexXtract.) - See http://www.haskell.org/HaXml/Xtract.html for the grammar that - is accepted.

Synopsis

parseXtract :: String -> DFilter

xtract :: String -> CFilter

Documentation

parseXtract :: String -> DFilter

The cool thing is that the Xtract command parser directly builds - a higher-order DFilter (see Text.Xml.HaXml.Xtract.Combinators) - which can be applied to an XML document without further ado.

xtract :: String -> CFilter

To mix an Xtract query into an ordinary HaXml combinator expression.

Produced by Haddock version 0.4

rmfile ./docs/HaXml/Text.XML.HaXml.Xtract.Parse.html hunk ./docs/HaXml/Text.XML.HaXml.html 1 - - -Text.XML.HaXml

Text.XML.HaXml

Description

This is just a convenient way of bunching the XML combinators - together with some other things you are likely to want at the - same time.

Synopsis

module Text.XML.HaXml.Combinators

module Text.XML.HaXml.Parse

module Text.XML.HaXml.Pretty

module Text.XML.HaXml.Html.Generate

module Text.XML.HaXml.Html.Parse

module Text.XML.HaXml.Validate

module Text.XML.HaXml.Wrappers

module Text.XML.HaXml.Verbatim

module Text.XML.HaXml.Escape

render :: Doc -> String

version :: String

Documentation