Convenience functions for building pandoc documents programmatically.

Example of use (with OverloadedStrings pragma):

 import Text.Pandoc.Builder

 myDoc :: Pandoc
 myDoc = setTitle "My title" $ doc $
   para "This is the first paragraph" <>
   para ("And " <> emph "another" <> ".") <>
   bulletList [ para "item one" <> para "continuation"
              , plain ("item two and a " <>
                  link "/url" "go to url" "link")
              ]

Isn't that nicer than writing the following?

 import Text.Pandoc.Definition
 import Data.Map (fromList)

 myDoc :: Pandoc
 myDoc = Pandoc (Meta {unMeta = fromList [("title",
           MetaInlines [Str "My",Space,Str "title"])]})
         [Para [Str "This",Space,Str "is",Space,Str "the",Space,Str "first",
          Space,Str "paragraph"],Para [Str "And",Space,Emph [Str "another"],
          Str "."]
         ,BulletList [
           [Para [Str "item",Space,Str "one"]
           ,Para [Str "continuation"]]
          ,[Plain [Str "item",Space,Str "two",Space,Str "and",Space,
                   Str "a",Space,Link [Str "link"] ("/url","go to url")]]]]

And of course, you can use Haskell to define your own builders:

 import Text.Pandoc.Builder
 import Text.JSON
 import Control.Arrow ((***))
 import Data.Monoid (mempty)

 -- | Converts a JSON document into 'Blocks'.
 json :: String -> Blocks
 json x =
   case decode x of
        Ok y    -> jsValueToBlocks y
        Error y -> error y
    where jsValueToBlocks x =
           case x of
            JSNull         -> mempty
            JSBool x       -> plain $ text $ show x
            JSRational _ x -> plain $ text $ show x
            JSString x     -> plain $ text $ fromJSString x
            JSArray xs     -> bulletList $ map jsValueToBlocks xs
            JSObject x     -> definitionList $
                               map (text *** (:[]) . jsValueToBlocks) $
                               fromJSObject x