Text.Pandoc.Builder

pandoc-types-1.16.0.1: Types for representing a structured document

Copyright | Copyright (C) 2010 John MacFarlane
License | GNU GPL, version 2 or above
Maintainer | John MacFarlane <jgm@berkeley.edu>
Stability | alpha
Portability | portable
Safe Haskell | None
Language | Haskell98

Text.Pandoc.Builder

Contents

- Document builders
- Inline list builders
- Block list builders

Description

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 nullAttr [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

Synopsis

- module Text.Pandoc.Definition
- newtype Many a = Many {
  - unMany :: Seq a
  }
- type Inlines = Many Inline
- type Blocks = Many Block
- (<>) :: Monoid m => m -> m -> m
- singleton :: a -> Many a
- toList :: Many a -> [a]
- fromList :: [a] -> Many a
- isNull :: Many a -> Bool
- doc :: Blocks -> Pandoc
- class ToMetaValue a where
  - toMetaValue :: a -> MetaValue
- class HasMeta a where
  - setMeta :: ToMetaValue b => String -> b -> a -> a
  - deleteMeta :: String -> a -> a
- setTitle :: Inlines -> Pandoc -> Pandoc
- setAuthors :: [Inlines] -> Pandoc -> Pandoc
- setDate :: Inlines -> Pandoc -> Pandoc
- text :: String -> Inlines
- str :: String -> Inlines
- emph :: Inlines -> Inlines
- strong :: Inlines -> Inlines
- strikeout :: Inlines -> Inlines
- superscript :: Inlines -> Inlines
- subscript :: Inlines -> Inlines
- smallcaps :: Inlines -> Inlines
- singleQuoted :: Inlines -> Inlines
- doubleQuoted :: Inlines -> Inlines
- cite :: [Citation] -> Inlines -> Inlines
- codeWith :: Attr -> String -> Inlines
- code :: String -> Inlines
- space :: Inlines
- softbreak :: Inlines
- linebreak :: Inlines
- math :: String -> Inlines
- displayMath :: String -> Inlines
- rawInline :: String -> String -> Inlines
- link :: String -> String -> Inlines -> Inlines
- linkWith :: Attr -> String -> String -> Inlines -> Inlines
- image :: String -> String -> Inlines -> Inlines
- imageWith :: Attr -> String -> String -> Inlines -> Inlines
- note :: Blocks -> Inlines
- spanWith :: Attr -> Inlines -> Inlines
- trimInlines :: Inlines -> Inlines
- para :: Inlines -> Blocks
- plain :: Inlines -> Blocks
- codeBlockWith :: Attr -> String -> Blocks
- codeBlock :: String -> Blocks
- rawBlock :: String -> String -> Blocks
- blockQuote :: Blocks -> Blocks
- bulletList :: [Blocks] -> Blocks
- orderedListWith :: ListAttributes -> [Blocks] -> Blocks
- orderedList :: [Blocks] -> Blocks
- definitionList :: [(Inlines, [Blocks])] -> Blocks
- header :: Int -> Inlines -> Blocks
- headerWith :: Attr -> Int -> Inlines -> Blocks
- horizontalRule :: Blocks
- table :: Inlines -> [(Alignment, Double)] -> [Blocks] -> [[Blocks]] -> Blocks
- simpleTable :: [Blocks] -> [[Blocks]] -> Blocks
- divWith :: Attr -> Blocks -> Blocks

# Documentation

module Text.Pandoc.Definition

newtype Many a

Constructors

Many |
Fields unMany :: Seq a

Instances

Functor Many |
IsString Inlines |
Foldable Many |
Traversable Many |
Monoid Inlines |
ToMetaValue Blocks |
ToMetaValue Inlines |
Eq a => Eq (Many a) |
Data a => Data (Many a) |
Ord a => Ord (Many a) |
Read a => Read (Many a) |
Show a => Show (Many a) |
Generic (Many a) |
Monoid (Many Block) |
type Rep (Many a) |

type Inlines = Many Inline

type Blocks = Many Block

(<>) :: Monoid m => m -> m -> m infixr 6

An infix synonym for `mappend`.

Since: 4.5.0.0

singleton :: a -> Many a

toList :: Many a -> [a]

fromList :: [a] -> Many a

isNull :: Many a -> Bool

# Document builders

doc :: Blocks -> Pandoc

class ToMetaValue a where

Methods

toMetaValue :: a -> MetaValue

Instances

ToMetaValue Bool |
ToMetaValue MetaValue |
ToMetaValue Blocks |
ToMetaValue Inlines |
ToMetaValue a => ToMetaValue [a] |
ToMetaValue a => ToMetaValue (Map String a) |

class HasMeta a where

Methods

setMeta :: ToMetaValue b => String -> b -> a -> a

deleteMeta :: String -> a -> a

Instances

HasMeta Meta |
HasMeta Pandoc |

setTitle :: Inlines -> Pandoc -> Pandoc

setAuthors :: [Inlines] -> Pandoc -> Pandoc

setDate :: Inlines -> Pandoc -> Pandoc

# Inline list builders

text :: String -> Inlines

Convert a `String` to `Inlines`, treating interword spaces as `Space`s or `SoftBreak`s. If you want a `Str` with literal spaces, use `str`.

str :: String -> Inlines

emph :: Inlines -> Inlines

strong :: Inlines -> Inlines

strikeout :: Inlines -> Inlines

superscript :: Inlines -> Inlines

subscript :: Inlines -> Inlines

smallcaps :: Inlines -> Inlines

singleQuoted :: Inlines -> Inlines

doubleQuoted :: Inlines -> Inlines

cite :: [Citation] -> Inlines -> Inlines

codeWith :: Attr -> String -> Inlines

Inline code with attributes.

code :: String -> Inlines

Plain inline code.

space :: Inlines

softbreak :: Inlines

linebreak :: Inlines

math :: String -> Inlines

Inline math

displayMath :: String -> Inlines

Display math

rawInline :: String -> String -> Inlines

link

Arguments

:: String | URL
-> String | Title
-> Inlines | Label
-> Inlines |

linkWith

Arguments

:: Attr | Attributes
-> String | URL
-> String | Title
-> Inlines | Label
-> Inlines |

image

Arguments

:: String | URL
-> String | Title
-> Inlines | Alt text
-> Inlines |

imageWith

Arguments

:: Attr | Attributes
-> String | URL
-> String | Title
-> Inlines | Alt text
-> Inlines |

note :: Blocks -> Inlines

spanWith :: Attr -> Inlines -> Inlines

trimInlines :: Inlines -> Inlines

Trim leading and trailing spaces and softbreaks from an Inlines.

# Block list builders

para :: Inlines -> Blocks

plain :: Inlines -> Blocks

codeBlockWith :: Attr -> String -> Blocks

A code block with attributes.

codeBlock :: String -> Blocks

A plain code block.

rawBlock :: String -> String -> Blocks

blockQuote :: Blocks -> Blocks

bulletList :: [Blocks] -> Blocks

orderedListWith :: ListAttributes -> [Blocks] -> Blocks

Ordered list with attributes.

orderedList :: [Blocks] -> Blocks

Ordered list with default attributes.

definitionList :: [(Inlines, [Blocks])] -> Blocks

header

Arguments

:: Int | Level
-> Inlines |
-> Blocks |

headerWith :: Attr -> Int -> Inlines -> Blocks

horizontalRule :: Blocks

table

Arguments

:: Inlines | Caption
-> [(Alignment, Double)] | Column alignments and fractional widths
-> [Blocks] | Headers
-> [[Blocks]] | Rows
-> Blocks |

simpleTable

Arguments

:: [Blocks] | Headers
-> [[Blocks]] | Rows
-> Blocks |

A simple table without a caption.

divWith :: Attr -> Blocks -> Blocks