Text.XML.Writer

Overcome XML insanity, node by node.

{-# LANGUAGE OverloadedStrings #-}

let doc = document "root" $ do
    element "hello" $ content "world"
    element "hierarchy" $ do
        element "simple" True
        element "as" ("it should be" :: Text)
        toXML $ Just . T.pack $ "like this"
    comment "that's it!"

Documents

document

Arguments

:: Name

Root node name

-> XML

Contents

-> Document

Create a simple Document starting with a root element.

soap :: (ToXML h, ToXML b) => h -> b -> Document

Generate a SOAPv1.1 document.

Empty header will be ignored. Envelope uses a soapenv prefix. Works great with ToXML class.

data BigData = BigData { webScale :: Bool }
instance ToXML BigData where
    toXML (BigData ws) = element ("v" !: "{vendor:uri}bigData") $ toXML ws
let doc = soap () (BigData True)

pprint :: Document -> IO ()

Render document using xml-conduit's pretty-printer.

Elements

type XML = Writer (DList Node) ()

Node container to be rendered as children nodes.

Node creation

node :: Node -> XML

Insert one node.

instruction :: Text -> Text -> XML

Insert an Instruction node.

comment :: Text -> XML

Insert a text comment node.

element :: ToXML a => Name -> a -> XML

Insert an Element node constructed with name and children.

elementMaybe :: ToXML a => Name -> Maybe a -> XML

Insert an Element node converted from Maybe value or do nothing.

elementA :: ToXML a => Name -> [(Name, Text)] -> a -> XML

Insert an Element node constructed with name, attributes and children.

content :: Text -> XML

Insert text content node.

empty :: XML

Do nothing.

many

Arguments

:: ToXML a

=> Name

Container element name.

-> [a]

Items to convert.

-> XML

Mass-convert to nodes.

let array = element "container" $ many "wrapper" [1..3]

Which gives:

<container>
    <wrapper>1</wrapper>
    <wrapper>2</wrapper>
    <wrapper>3</wrapper>
</container>

Use `mapM_ toXML xs` to convert a list without wrapping each item in separate element.

let mess = element "container" $ mapM_ toXML ["chunky", "chunk"]

Content nodes tend to glue together:

<container>chunkychunk</container>

Element helpers

render :: XML -> [Node]

Convert collected nodes to a list of child nodes.

(!:) :: Text -> Name -> Name

Attach a prefix to a Name.

Because simply placing a colon in an element name yields Nothing as a prefix and children will revert to en empty namespace.

Converting data

class ToXML a where

Provide instances for this class to use your data as XML nodes.

Minimal complete definition

toXML

Methods

toXML :: a -> XML

Instances

ToXML Bool

XML schema uses lower case.

Methods

toXML :: Bool -> XML

ToXML Char

Methods

toXML :: Char -> XML

ToXML Double

Methods

toXML :: Double -> XML

ToXML Float

Methods

toXML :: Float -> XML

ToXML Int

Methods

toXML :: Int -> XML

ToXML Integer

Methods

toXML :: Integer -> XML

ToXML ()

Do nothing.

Methods

toXML :: () -> XML

ToXML Text

Don't use [Char] please, it will scare OverloadedStrings.

Methods

toXML :: Text -> XML

ToXML XML

Insert already prepared nodes.

Methods

toXML :: XML -> XML

ToXML a => ToXML (Maybe a)

Insert node if available. Otherwise do nothing.

Methods

toXML :: Maybe a -> XML

Orphan instances

IsString XML

Methods

fromString :: String -> XML