Convenience functions for building pandoc documents programmatically.

Example of use:

 
 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

 myDoc :: Pandoc
 myDoc = Pandoc (Meta {docTitle = [Str "My",Space,Str "title"]
                      , docAuthors = []
                      , docDate = []})
  [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