Stylish-haskell automatic formatting changes.

author: John MacFarlane <jgm@berkeley.edu> 2017-03-04 13:03:41 +0100
committer: John MacFarlane <jgm@berkeley.edu> 2017-03-04 13:03:41 +0100
commit: e256c8ce1778ff6fbb2e8d59556d48fb3c53393d (patch)
tree: 3527320cd3fd205a00a733ddbe46917638253034 /src/Text/Pandoc/Writers
parent: 0edfbf1478950d645ece19ced0156771ba16ebb6 (diff)
29 files changed, 805 insertions, 785 deletions
diff --git a/src/Text/Pandoc/Writers/AsciiDoc.hs b/src/Text/Pandoc/Writers/AsciiDoc.hs
index 594a12222..20fa7c209 100644
--- a/src/Text/Pandoc/Writers/AsciiDoc.hs
+++ b/src/Text/Pandoc/Writers/AsciiDoc.hs
@@ -37,25 +37,25 @@ that it has omitted the construct.
 AsciiDoc:  <http://www.methods.co.nz/asciidoc/>
 -}
 module Text.Pandoc.Writers.AsciiDoc (writeAsciiDoc) where
-import Text.Pandoc.Definition
-import Text.Pandoc.Templates (renderTemplate')
-import Text.Pandoc.Shared
-import Text.Pandoc.Writers.Shared
-import Text.Pandoc.Options
-import Text.Pandoc.Parsing hiding (blankline, space)
-import Data.Maybe (fromMaybe)
-import Data.List ( stripPrefix, intersperse, intercalate )
-import Text.Pandoc.Pretty
-import Text.Pandoc.ImageSize
 import Control.Monad.State
+import Data.Aeson (Result (..), Value (String), fromJSON, toJSON)
+import Data.Char (isPunctuation, isSpace)
+import Data.List (intercalate, intersperse, stripPrefix)
 import qualified Data.Map as M
-import Data.Aeson (Value(String), fromJSON, toJSON, Result(..))
+import Data.Maybe (fromMaybe)
 import qualified Data.Text as T
-import Data.Char (isSpace, isPunctuation)
 import Text.Pandoc.Class (PandocMonad, report)
+import Text.Pandoc.Definition
+import Text.Pandoc.ImageSize
 import Text.Pandoc.Logging
+import Text.Pandoc.Options
+import Text.Pandoc.Parsing hiding (blankline, space)
+import Text.Pandoc.Pretty
+import Text.Pandoc.Shared
+import Text.Pandoc.Templates (renderTemplate')
+import Text.Pandoc.Writers.Shared
 
-data WriterState = WriterState { defListMarker :: String
+data WriterState = WriterState { defListMarker    :: String
                                , orderedListLevel :: Int
                                , bulletListLevel  :: Int
                                , intraword        :: Bool
@@ -122,8 +122,8 @@ olMarker = do (start, style', delim) <- anyOrderedListMarker
 beginsWithOrderedListMarker :: String -> Bool
 beginsWithOrderedListMarker str =
   case runParser olMarker defaultParserState "para start" (take 10 str) of
-         Left  _  -> False
-         Right _  -> True
+         Left  _ -> False
+         Right _ -> True
 
 -- | Convert Pandoc block element to asciidoc.
 blockToAsciiDoc :: PandocMonad m
@@ -169,11 +169,11 @@ blockToAsciiDoc opts (Header level (ident,_,_) inlines) = do
             then
               identifier $$ contents $$
               (case level of
-               1  -> text $ replicate len '-'
-               2  -> text $ replicate len '~'
-               3  -> text $ replicate len '^'
-               4  -> text $ replicate len '+'
-               _  -> empty) <> blankline
+               1 -> text $ replicate len '-'
+               2 -> text $ replicate len '~'
+               3 -> text $ replicate len '^'
+               4 -> text $ replicate len '+'
+               _ -> empty) <> blankline
             else
               identifier $$ text (replicate level '=') <> space <> contents <> blankline)
 blockToAsciiDoc _ (CodeBlock (_,classes,_) str) = return $ (flush $
@@ -428,9 +428,9 @@ inlineToAsciiDoc _ LineBreak = return $ " +" <> cr
 inlineToAsciiDoc _ Space = return space
 inlineToAsciiDoc opts SoftBreak =
   case writerWrapText opts of
-       WrapAuto -> return space
+       WrapAuto     -> return space
        WrapPreserve -> return cr
-       WrapNone -> return space
+       WrapNone     -> return space
 inlineToAsciiDoc opts (Cite _ lst) = inlineListToAsciiDoc opts lst
 inlineToAsciiDoc opts (Link _ txt (src, _tit)) = do
 -- relative:  link:downloads/foo.zip[download foo.zip]
@@ -444,7 +444,7 @@ inlineToAsciiDoc opts (Link _ txt (src, _tit)) = do
   let srcSuffix = fromMaybe src (stripPrefix "mailto:" src)
   let useAuto = case txt of
                       [Str s] | escapeURI s == srcSuffix -> True
-                      _                                  -> False
+                      _       -> False
   return $ if useAuto
               then text srcSuffix
               else prefix <> text src <> "[" <> linktext <> "]"
diff --git a/src/Text/Pandoc/Writers/CommonMark.hs b/src/Text/Pandoc/Writers/CommonMark.hs
index b83f6785d..2c844d3a0 100644
--- a/src/Text/Pandoc/Writers/CommonMark.hs
+++ b/src/Text/Pandoc/Writers/CommonMark.hs
@@ -31,18 +31,18 @@ CommonMark:  <http://commonmark.org>
 -}
 module Text.Pandoc.Writers.CommonMark (writeCommonMark) where
 
-import Text.Pandoc.Writers.HTML (writeHtml5String)
+import CMark
+import Control.Monad.State (State, get, modify, runState)
+import Data.Foldable (foldrM)
+import qualified Data.Text as T
+import Text.Pandoc.Class (PandocMonad)
 import Text.Pandoc.Definition
+import Text.Pandoc.Options
 import Text.Pandoc.Shared (isTightList, linesToPara)
 import Text.Pandoc.Templates (renderTemplate')
-import Text.Pandoc.Writers.Shared
-import Text.Pandoc.Options
-import CMark
-import qualified Data.Text as T
-import Control.Monad.State (runState, State, modify, get)
 import Text.Pandoc.Walk (walkM)
-import Text.Pandoc.Class (PandocMonad)
-import Data.Foldable (foldrM)
+import Text.Pandoc.Writers.HTML (writeHtml5String)
+import Text.Pandoc.Writers.Shared
 
 -- | Convert Pandoc to CommonMark.
 writeCommonMark :: PandocMonad m => WriterOptions -> Pandoc -> m String
diff --git a/src/Text/Pandoc/Writers/ConTeXt.hs b/src/Text/Pandoc/Writers/ConTeXt.hs
index ea178db92..353901fa5 100644
--- a/src/Text/Pandoc/Writers/ConTeXt.hs
+++ b/src/Text/Pandoc/Writers/ConTeXt.hs
@@ -29,21 +29,21 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Conversion of 'Pandoc' format into ConTeXt.
 -}
 module Text.Pandoc.Writers.ConTeXt ( writeConTeXt ) where
+import Control.Monad.State
+import Data.Char (ord)
+import Data.List (intercalate, intersperse)
+import Data.Maybe (catMaybes)
+import Network.URI (isURI, unEscapeString)
+import Text.Pandoc.Class (PandocMonad)
 import Text.Pandoc.Definition
-import Text.Pandoc.Shared
-import Text.Pandoc.Writers.Shared
+import Text.Pandoc.ImageSize
 import Text.Pandoc.Options
-import Text.Pandoc.Walk (query)
-import Text.Printf ( printf )
-import Data.List ( intercalate, intersperse )
-import Data.Char ( ord )
-import Data.Maybe ( catMaybes )
-import Control.Monad.State
 import Text.Pandoc.Pretty
-import Text.Pandoc.ImageSize
-import Text.Pandoc.Templates ( renderTemplate' )
-import Network.URI ( isURI, unEscapeString )
-import Text.Pandoc.Class (PandocMonad)
+import Text.Pandoc.Shared
+import Text.Pandoc.Templates (renderTemplate')
+import Text.Pandoc.Walk (query)
+import Text.Pandoc.Writers.Shared
+import Text.Printf (printf)
 
 data WriterState =
   WriterState { stNextRef          :: Int  -- number of next URL reference
@@ -113,22 +113,22 @@ escapeCharForConTeXt :: WriterOptions -> Char -> String
 escapeCharForConTeXt opts ch =
  let ligatures = isEnabled Ext_smart opts in
  case ch of
-    '{'    -> "\\{"
-    '}'    -> "\\}"
-    '\\'   -> "\\letterbackslash{}"
-    '$'    -> "\\$"
-    '|'    -> "\\letterbar{}"
-    '%'    -> "\\letterpercent{}"
-    '~'    -> "\\lettertilde{}"
-    '#'    -> "\\#"
-    '['    -> "{[}"
-    ']'    -> "{]}"
-    '\160' -> "~"
+    '{'      -> "\\{"
+    '}'      -> "\\}"
+    '\\'     -> "\\letterbackslash{}"
+    '$'      -> "\\$"
+    '|'      -> "\\letterbar{}"
+    '%'      -> "\\letterpercent{}"
+    '~'      -> "\\lettertilde{}"
+    '#'      -> "\\#"
+    '['      -> "{[}"
+    ']'      -> "{]}"
+    '\160'   -> "~"
     '\x2014' | ligatures -> "---"
     '\x2013' | ligatures -> "--"
     '\x2019' | ligatures -> "'"
     '\x2026' -> "\\ldots{}"
-    x      -> [x]
+    x        -> [x]
 
 -- | Escape string for ConTeXt
 stringToConTeXt :: WriterOptions -> String -> String
@@ -293,9 +293,9 @@ inlineListToConTeXt lst = liftM hcat $ mapM inlineToConTeXt $ addStruts lst
              addStruts xs
         addStruts (x:xs) = x : addStruts xs
         addStruts [] = []
-        isSpacey Space = True
+        isSpacey Space            = True
         isSpacey (Str ('\160':_)) = True
-        isSpacey _ = False
+        isSpacey _                = False
 
 -- | Convert inline element to ConTeXt
 inlineToConTeXt :: Inline    -- ^ Inline to convert
@@ -398,7 +398,7 @@ inlineToConTeXt (Image attr@(_,cls,_) _ (src, _)) = do
 inlineToConTeXt (Note contents) = do
   contents' <- blockListToConTeXt contents
   let codeBlock x@(CodeBlock _ _) = [x]
-      codeBlock _ = []
+      codeBlock _                 = []
   let codeBlocks = query codeBlock contents
   return $ if null codeBlocks
               then text "\\footnote{" <> nest 2 contents' <> char '}'
diff --git a/src/Text/Pandoc/Writers/Custom.hs b/src/Text/Pandoc/Writers/Custom.hs
index cf641dcd6..d7374b68b 100644
--- a/src/Text/Pandoc/Writers/Custom.hs
+++ b/src/Text/Pandoc/Writers/Custom.hs
@@ -1,6 +1,9 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# LANGUAGE FlexibleInstances, OverloadedStrings,
-    ScopedTypeVariables, DeriveDataTypeable, CPP #-}
+{-# LANGUAGE CPP                  #-}
+{-# LANGUAGE DeriveDataTypeable   #-}
+{-# LANGUAGE FlexibleInstances    #-}
+{-# LANGUAGE OverloadedStrings    #-}
+{-# LANGUAGE ScopedTypeVariables  #-}
 #if MIN_VERSION_base(4,8,0)
 #else
 {-# LANGUAGE OverlappingInstances #-}
@@ -35,20 +38,20 @@ Conversion of 'Pandoc' documents to custom markup using
 a lua writer.
 -}
 module Text.Pandoc.Writers.Custom ( writeCustom ) where
-import Text.Pandoc.Definition
-import Text.Pandoc.Options
-import Data.List ( intersperse )
-import Data.Char ( toLower )
+import Control.Exception
+import Control.Monad (when)
+import Data.Char (toLower)
+import Data.List (intersperse)
+import qualified Data.Map as M
 import Data.Typeable
+import GHC.IO.Encoding (getForeignEncoding, setForeignEncoding, utf8)
 import Scripting.Lua (LuaState, StackValue, callfunc)
-import Text.Pandoc.Writers.Shared
 import qualified Scripting.Lua as Lua
-import qualified Text.Pandoc.UTF8 as UTF8
-import Control.Monad (when)
-import Control.Exception
-import qualified Data.Map as M
+import Text.Pandoc.Definition
+import Text.Pandoc.Options
 import Text.Pandoc.Templates
-import GHC.IO.Encoding (getForeignEncoding,setForeignEncoding, utf8)
+import qualified Text.Pandoc.UTF8 as UTF8
+import Text.Pandoc.Writers.Shared
 
 attrToMap :: Attr -> M.Map String String
 attrToMap (id',classes,keyvals) = M.fromList
@@ -142,19 +145,19 @@ instance StackValue [Block] where
   valuetype _ = Lua.TSTRING
 
 instance StackValue MetaValue where
-  push l (MetaMap m) = Lua.push l m
-  push l (MetaList xs) = Lua.push l xs
-  push l (MetaBool x) = Lua.push l x
-  push l (MetaString s) = Lua.push l s
+  push l (MetaMap m)       = Lua.push l m
+  push l (MetaList xs)     = Lua.push l xs
+  push l (MetaBool x)      = Lua.push l x
+  push l (MetaString s)    = Lua.push l s
   push l (MetaInlines ils) = Lua.push l ils
-  push l (MetaBlocks bs) = Lua.push l bs
+  push l (MetaBlocks bs)   = Lua.push l bs
   peek _ _ = undefined
-  valuetype (MetaMap _) = Lua.TTABLE
-  valuetype (MetaList _) = Lua.TTABLE
-  valuetype (MetaBool _) = Lua.TBOOLEAN
-  valuetype (MetaString _) = Lua.TSTRING
+  valuetype (MetaMap _)     = Lua.TTABLE
+  valuetype (MetaList _)    = Lua.TTABLE
+  valuetype (MetaBool _)    = Lua.TBOOLEAN
+  valuetype (MetaString _)  = Lua.TSTRING
   valuetype (MetaInlines _) = Lua.TSTRING
-  valuetype (MetaBlocks _) = Lua.TSTRING
+  valuetype (MetaBlocks _)  = Lua.TSTRING
 
 instance StackValue Citation where
   push lua cit = do
diff --git a/src/Text/Pandoc/Writers/Docbook.hs b/src/Text/Pandoc/Writers/Docbook.hs
index 597851f65..dce2cbd3e 100644
--- a/src/Text/Pandoc/Writers/Docbook.hs
+++ b/src/Text/Pandoc/Writers/Docbook.hs
@@ -1,4 +1,5 @@
-{-# LANGUAGE OverloadedStrings, PatternGuards #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PatternGuards     #-}
 {-
 Copyright (C) 2006-2015 John MacFarlane <jgm@berkeley.edu>
 
@@ -29,27 +30,27 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Conversion of 'Pandoc' documents to Docbook XML.
 -}
 module Text.Pandoc.Writers.Docbook ( writeDocbook4, writeDocbook5 ) where
+import Control.Monad.Reader
+import Data.Char (toLower)
+import Data.Generics (everywhere, mkT)
+import Data.List (intercalate, isPrefixOf, isSuffixOf, stripPrefix)
+import Data.Monoid (Any (..))
+import qualified Text.Pandoc.Builder as B
+import Text.Pandoc.Class (PandocMonad, report)
 import Text.Pandoc.Definition
-import Text.Pandoc.XML
-import Text.Pandoc.Shared
-import Text.Pandoc.Walk
-import Text.Pandoc.Writers.Shared
+import Text.Pandoc.Highlighting (languages, languagesByExtension)
+import Text.Pandoc.ImageSize
+import Text.Pandoc.Logging
 import Text.Pandoc.Options
+import Text.Pandoc.Pretty
+import Text.Pandoc.Shared
 import Text.Pandoc.Templates (renderTemplate')
+import Text.Pandoc.Walk
 import Text.Pandoc.Writers.Math
-import Data.List ( stripPrefix, isPrefixOf, intercalate, isSuffixOf )
-import Data.Char ( toLower )
-import Data.Monoid ( Any(..) )
-import Text.Pandoc.Highlighting ( languages, languagesByExtension )
-import Text.Pandoc.Pretty
-import Text.Pandoc.ImageSize
-import qualified Text.Pandoc.Builder as B
+import Text.Pandoc.Writers.Shared
+import Text.Pandoc.XML
 import Text.TeXMath
 import qualified Text.XML.Light as Xml
-import Data.Generics (everywhere, mkT)
-import Text.Pandoc.Class (PandocMonad, report)
-import Text.Pandoc.Logging
-import Control.Monad.Reader
 
 data DocBookVersion = DocBook4 | DocBook5
      deriving (Eq, Show)
@@ -122,8 +123,8 @@ writeDocbook opts (Pandoc meta blocks) = do
                                         _      -> False)
               $ metadata
   return $ case writerTemplate opts of
-           Nothing   -> main
-           Just tpl  -> renderTemplate' tpl context
+           Nothing  -> main
+           Just tpl -> renderTemplate' tpl context
 
 -- | Convert an Element to Docbook.
 elementToDocbook :: PandocMonad m => WriterOptions -> Int -> Element -> DB m Doc
@@ -311,16 +312,16 @@ hasLineBreaks = getAny . query isLineBreak . walk removeNote
   where
     removeNote :: Inline -> Inline
     removeNote (Note _) = Str ""
-    removeNote x = x
+    removeNote x        = x
     isLineBreak :: Inline -> Any
     isLineBreak LineBreak = Any True
-    isLineBreak _ = Any False
+    isLineBreak _         = Any False
 
 alignmentToString :: Alignment -> [Char]
 alignmentToString alignment = case alignment of
-                                 AlignLeft -> "left"
-                                 AlignRight -> "right"
-                                 AlignCenter -> "center"
+                                 AlignLeft    -> "left"
+                                 AlignRight   -> "right"
+                                 AlignCenter  -> "center"
                                  AlignDefault -> "left"
 
 tableRowToDocbook :: PandocMonad m
diff --git a/src/Text/Pandoc/Writers/Docx.hs b/src/Text/Pandoc/Writers/Docx.hs
index 26b1cfdf6..c182d42a3 100644
--- a/src/Text/Pandoc/Writers/Docx.hs
+++ b/src/Text/Pandoc/Writers/Docx.hs
@@ -1,5 +1,8 @@
-{-# LANGUAGE ScopedTypeVariables, PatternGuards, ViewPatterns, DeriveFunctor,
-   ScopedTypeVariables, RankNTypes #-}
+{-# LANGUAGE DeriveFunctor       #-}
+{-# LANGUAGE PatternGuards       #-}
+{-# LANGUAGE RankNTypes          #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE ViewPatterns        #-}
 {-
 Copyright (C) 2012-2015 John MacFarlane <jgm@berkeley.edu>
 
@@ -30,45 +33,45 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Conversion of 'Pandoc' documents to docx.
 -}
 module Text.Pandoc.Writers.Docx ( writeDocx ) where
-import Data.List ( intercalate, isPrefixOf, isSuffixOf )
+import Codec.Archive.Zip
+import Control.Applicative ((<|>))
+import Control.Monad.Except (catchError)
+import Control.Monad.Reader
+import Control.Monad.State
 import qualified Data.ByteString as B
 import qualified Data.ByteString.Lazy as BL
 import qualified Data.ByteString.Lazy.Char8 as BL8
+import Data.Char (isSpace, ord, toLower)
+import Data.List (intercalate, isPrefixOf, isSuffixOf)
 import qualified Data.Map as M
+import Data.Maybe (fromMaybe, isNothing, mapMaybe, maybeToList)
+import Data.Monoid ((<>))
 import qualified Data.Set as Set
-import qualified Text.Pandoc.UTF8 as UTF8
-import Codec.Archive.Zip
+import qualified Data.Text as T
 import Data.Time.Clock.POSIX
+import Skylighting
+import System.Random (randomR)
+import Text.Pandoc.Class (PandocMonad, report)
+import qualified Text.Pandoc.Class as P
 import Text.Pandoc.Compat.Time
 import Text.Pandoc.Definition
+import Text.Pandoc.Error
 import Text.Pandoc.Generic
+import Text.Pandoc.Highlighting (highlight)
 import Text.Pandoc.ImageSize
-import Text.Pandoc.Shared hiding (Element)
-import Text.Pandoc.Writers.Shared (fixDisplayMath)
+import Text.Pandoc.Logging
+import Text.Pandoc.MIME (MimeType, extensionFromMimeType, getMimeType,
+                         getMimeTypeDef)
 import Text.Pandoc.Options
-import Text.Pandoc.Writers.Math
-import Text.Pandoc.Highlighting ( highlight )
-import Text.Pandoc.Walk
-import Text.XML.Light as XML
-import Text.TeXMath
 import Text.Pandoc.Readers.Docx.StyleMap
-import Control.Monad.Reader
-import Control.Monad.State
-import Skylighting
-import Control.Monad.Except (catchError)
-import System.Random (randomR)
+import Text.Pandoc.Shared hiding (Element)
+import qualified Text.Pandoc.UTF8 as UTF8
+import Text.Pandoc.Walk
+import Text.Pandoc.Writers.Math
+import Text.Pandoc.Writers.Shared (fixDisplayMath)
 import Text.Printf (printf)
-import Data.Monoid ((<>))
-import qualified Data.Text as T
-import Text.Pandoc.MIME (MimeType, getMimeType, getMimeTypeDef,
-                         extensionFromMimeType)
-import Control.Applicative ((<|>))
-import Data.Maybe (fromMaybe, mapMaybe, maybeToList, isNothing)
-import Data.Char (ord, isSpace, toLower)
-import Text.Pandoc.Class (PandocMonad, report)
-import qualified Text.Pandoc.Class as P
-import Text.Pandoc.Logging
-import Text.Pandoc.Error
+import Text.TeXMath
+import Text.XML.Light as XML
 
 data ListMarker = NoMarker
                 | BulletMarker
@@ -81,28 +84,28 @@ listMarkerToId BulletMarker = "991"
 listMarkerToId (NumberMarker sty delim n) =
   '9' : '9' : styNum : delimNum : show n
   where styNum = case sty of
-                      DefaultStyle   -> '2'
-                      Example        -> '3'
-                      Decimal        -> '4'
-                      LowerRoman     -> '5'
-                      UpperRoman     -> '6'
-                      LowerAlpha     -> '7'
-                      UpperAlpha     -> '8'
+                      DefaultStyle -> '2'
+                      Example      -> '3'
+                      Decimal      -> '4'
+                      LowerRoman   -> '5'
+                      UpperRoman   -> '6'
+                      LowerAlpha   -> '7'
+                      UpperAlpha   -> '8'
         delimNum = case delim of
-                      DefaultDelim   -> '0'
-                      Period         -> '1'
-                      OneParen       -> '2'
-                      TwoParens      -> '3'
+                      DefaultDelim -> '0'
+                      Period       -> '1'
+                      OneParen     -> '2'
+                      TwoParens    -> '3'
 
 data WriterEnv = WriterEnv{ envTextProperties :: [Element]
                           , envParaProperties :: [Element]
-                          , envRTL :: Bool
-                          , envListLevel :: Int
-                          , envListNumId :: Int
-                          , envInDel :: Bool
-                          , envChangesAuthor :: String
-                          , envChangesDate :: String
-                          , envPrintWidth :: Integer
+                          , envRTL            :: Bool
+                          , envListLevel      :: Int
+                          , envListNumId      :: Int
+                          , envInDel          :: Bool
+                          , envChangesAuthor  :: String
+                          , envChangesDate    :: String
+                          , envPrintWidth     :: Integer
                           }
 
 defaultWriterEnv :: WriterEnv
@@ -209,11 +212,11 @@ isValidChar (ord -> c)
   | otherwise                     = False
 
 metaValueToInlines :: MetaValue -> [Inline]
-metaValueToInlines (MetaString s) = [Str s]
+metaValueToInlines (MetaString s)    = [Str s]
 metaValueToInlines (MetaInlines ils) = ils
-metaValueToInlines (MetaBlocks bs) = query return bs
-metaValueToInlines (MetaBool b) = [Str $ show b]
-metaValueToInlines _ = []
+metaValueToInlines (MetaBlocks bs)   = query return bs
+metaValueToInlines (MetaBool b)      = [Str $ show b]
+metaValueToInlines _                 = []
 
 
 
@@ -452,8 +455,8 @@ writeDocx opts doc@(Pandoc meta _) = do
   let newstyles = map newParaPropToOpenXml newDynamicParaProps ++
                   map newTextPropToOpenXml newDynamicTextProps ++
                   (case writerHighlightStyle opts of
-                        Nothing   -> []
-                        Just sty  -> (styleToOpenXml styleMaps sty))
+                        Nothing  -> []
+                        Just sty -> (styleToOpenXml styleMaps sty))
   let styledoc' = styledoc{ elContent = elContent styledoc ++
                                            map Elem newstyles }
   let styleEntry = toEntry stylepath epochtime $ renderXml styledoc'
@@ -675,21 +678,21 @@ mkLvl marker lvl =
           bulletFor 4 = "\x2022"
           bulletFor 5 = "\x2013"
           bulletFor _ = "\x2022"
-          styleFor UpperAlpha _ = "upperLetter"
-          styleFor LowerAlpha _ = "lowerLetter"
-          styleFor UpperRoman _ = "upperRoman"
-          styleFor LowerRoman _ = "lowerRoman"
-          styleFor Decimal _ = "decimal"
+          styleFor UpperAlpha _   = "upperLetter"
+          styleFor LowerAlpha _   = "lowerLetter"
+          styleFor UpperRoman _   = "upperRoman"
+          styleFor LowerRoman _   = "lowerRoman"
+          styleFor Decimal _      = "decimal"
           styleFor DefaultStyle 1 = "decimal"
           styleFor DefaultStyle 2 = "lowerLetter"
           styleFor DefaultStyle 3 = "lowerRoman"
           styleFor DefaultStyle 4 = "decimal"
           styleFor DefaultStyle 5 = "lowerLetter"
           styleFor DefaultStyle 6 = "lowerRoman"
-          styleFor _ _ = "decimal"
-          patternFor OneParen s = s ++ ")"
+          styleFor _ _            = "decimal"
+          patternFor OneParen s  = s ++ ")"
           patternFor TwoParens s = "(" ++ s ++ ")"
-          patternFor _ s = s ++ "."
+          patternFor _ s         = s ++ "."
 
 getNumId :: (PandocMonad m) => WS m Int
 getNumId = (((baseListId - 1) +) . length) `fmap` gets stLists
@@ -733,14 +736,14 @@ writeOpenXML opts (Pandoc meta blocks) = do
   let auths = docAuthors meta
   let dat = docDate meta
   let abstract' = case lookupMeta "abstract" meta of
-                       Just (MetaBlocks bs) -> bs
+                       Just (MetaBlocks bs)   -> bs
                        Just (MetaInlines ils) -> [Plain ils]
-                       _ -> []
+                       _                      -> []
   let subtitle' = case lookupMeta "subtitle" meta of
                        Just (MetaBlocks [Plain xs]) -> xs
                        Just (MetaBlocks [Para  xs]) -> xs
                        Just (MetaInlines xs)        -> xs
-                       _ -> []
+                       _                            -> []
   title <- withParaPropM (pStyleM "Title") $ blocksToOpenXML opts [Para tit | not (null tit)]
   subtitle <- withParaPropM (pStyleM "Subtitle") $ blocksToOpenXML opts [Para subtitle' | not (null subtitle')]
   authors <- withParaProp (pCustomStyle "Author") $ blocksToOpenXML opts $
@@ -750,8 +753,8 @@ writeOpenXML opts (Pandoc meta blocks) = do
                  then return []
                  else withParaProp (pCustomStyle "Abstract") $ blocksToOpenXML opts abstract'
   let convertSpace (Str x : Space : Str y : xs) = Str (x ++ " " ++ y) : xs
-      convertSpace (Str x : Str y : xs) = Str (x ++ y) : xs
-      convertSpace xs = xs
+      convertSpace (Str x : Str y : xs)         = Str (x ++ y) : xs
+      convertSpace xs                           = xs
   let blocks' = bottomUp convertSpace blocks
   doc' <- (setFirstPara >> blocksToOpenXML opts blocks')
   notes' <- reverse `fmap` gets stFootnotes
@@ -981,9 +984,9 @@ listItemToOpenXML opts numid (first:rest) = do
 
 alignmentToString :: Alignment -> [Char]
 alignmentToString alignment = case alignment of
-                                 AlignLeft -> "left"
-                                 AlignRight -> "right"
-                                 AlignCenter -> "center"
+                                 AlignLeft    -> "left"
+                                 AlignRight   -> "right"
+                                 AlignCenter  -> "center"
                                  AlignDefault -> "left"
 
 -- | Convert a list of inline elements to OpenXML.
@@ -1063,7 +1066,7 @@ inlineToOpenXML' opts (Span (ident,classes,kvs) ils) = do
   let dirmod = case lookup "dir" kvs of
                  Just "rtl" -> local (\env -> env { envRTL = True })
                  Just "ltr" -> local (\env -> env { envRTL = False })
-                 _ -> id
+                 _          -> id
   let off x = withTextProp (mknode x [("w:val","0")] ())
   let pmod =  (if "csl-no-emph" `elem` classes then off "w:i" else id) .
               (if "csl-no-strong" `elem` classes then off "w:b" else id) .
@@ -1154,8 +1157,8 @@ inlineToOpenXML' opts (Code attrs str) = do
                                , mknode "w:t" [("xml:space","preserve")] (T.unpack tok) ]
   withTextProp (rCustomStyle "VerbatimChar")
     $ case writerHighlightStyle opts >> highlight formatOpenXML attrs str of
-           Just h   -> return h
-           Nothing  -> unhighlighted
+           Just h  -> return h
+           Nothing -> unhighlighted
 inlineToOpenXML' opts (Note bs) = do
   notes <- gets stFootnotes
   notenum <- (lift . lift) getUniqueId
diff --git a/src/Text/Pandoc/Writers/DokuWiki.hs b/src/Text/Pandoc/Writers/DokuWiki.hs
index 9fd6c699c..215d0b2fb 100644
--- a/src/Text/Pandoc/Writers/DokuWiki.hs
+++ b/src/Text/Pandoc/Writers/DokuWiki.hs
@@ -39,31 +39,28 @@ DokuWiki:  <https://www.dokuwiki.org/dokuwiki>
 -}
 
 module Text.Pandoc.Writers.DokuWiki ( writeDokuWiki ) where
+import Control.Monad (zipWithM)
+import Control.Monad.Reader (ReaderT, ask, local, runReaderT)
+import Control.Monad.State (State, evalState, gets, modify)
+import Data.Default (Default (..))
+import Data.List (intercalate, intersect, isPrefixOf, transpose)
+import Network.URI (isURI)
+import Text.Pandoc.Class (PandocMonad)
 import Text.Pandoc.Definition
-import Text.Pandoc.Options ( WriterOptions(
-                                writerTableOfContents
-                              , writerTemplate
-                              , writerWrapText), WrapOption(..) )
-import Text.Pandoc.Shared ( escapeURI, linesToPara, removeFormatting
-                          , camelCaseToHyphenated, trimr, substitute )
-import Text.Pandoc.Writers.Shared ( defField, metaToJSON )
 import Text.Pandoc.ImageSize
-import Text.Pandoc.Templates ( renderTemplate' )
-import Data.List ( intersect, intercalate, isPrefixOf, transpose )
-import Data.Default (Default(..))
-import Network.URI ( isURI )
-import Control.Monad ( zipWithM )
-import Control.Monad.State ( modify, State, gets, evalState )
-import Control.Monad.Reader ( ReaderT, runReaderT, ask, local )
-import Text.Pandoc.Class (PandocMonad)
+import Text.Pandoc.Options (WrapOption (..), WriterOptions (writerTableOfContents, writerTemplate, writerWrapText))
+import Text.Pandoc.Shared (camelCaseToHyphenated, escapeURI, linesToPara,
+                           removeFormatting, substitute, trimr)
+import Text.Pandoc.Templates (renderTemplate')
+import Text.Pandoc.Writers.Shared (defField, metaToJSON)
 
 data WriterState = WriterState {
     stNotes     :: Bool            -- True if there are notes
   }
 
 data WriterEnvironment = WriterEnvironment {
-    stIndent    :: String          -- Indent after the marker at the beginning of list items
-  , stUseTags   :: Bool            -- True if we should use HTML tags because we're in a complex list
+    stIndent      :: String          -- Indent after the marker at the beginning of list items
+  , stUseTags     :: Bool            -- True if we should use HTML tags because we're in a complex list
   , stBackSlashLB :: Bool     -- True if we should produce formatted strings with newlines (as in a table cell)
   }
 
@@ -178,7 +175,7 @@ blockToDokuWiki _ (CodeBlock (_,classes,_) str) = do
                        "visualfoxpro", "winbatch", "xml", "xpp", "z80"]
   return $ "<code" ++
                 (case at of
-                      [] -> ">\n"
+                      []    -> ">\n"
                       (x:_) -> " " ++ x ++ ">\n") ++ str ++ "\n</code>"
 
 blockToDokuWiki opts (BlockQuote blocks) = do
@@ -338,18 +335,18 @@ isSimpleListItem :: [Block] -> Bool
 isSimpleListItem []  = True
 isSimpleListItem [x] =
   case x of
-       Plain _           -> True
-       Para  _           -> True
-       BulletList _      -> isSimpleList x
-       OrderedList _ _   -> isSimpleList x
-       DefinitionList _  -> isSimpleList x
-       _                 -> False
+       Plain _          -> True
+       Para  _          -> True
+       BulletList _     -> isSimpleList x
+       OrderedList _ _  -> isSimpleList x
+       DefinitionList _ -> isSimpleList x
+       _                -> False
 isSimpleListItem [x, y] | isPlainOrPara x =
   case y of
-       BulletList _      -> isSimpleList y
-       OrderedList _ _   -> isSimpleList y
-       DefinitionList _  -> isSimpleList y
-       _                 -> False
+       BulletList _     -> isSimpleList y
+       OrderedList _ _  -> isSimpleList y
+       DefinitionList _ -> isSimpleList y
+       _                -> False
 isSimpleListItem _ = False
 
 isPlainOrPara :: Block -> Bool
@@ -369,7 +366,7 @@ backSlashLineBreaks cs = reverse $ g $ reverse $ concatMap f cs
   where f '\n' = "\\\\ "
         f c    = [c]
         g (' ' : '\\':'\\': xs) = xs
-        g s = s
+        g s                     = s
 
 -- Auxiliary functions for tables:
 
@@ -515,7 +512,7 @@ imageDims opts attr = go (toPx $ dimension Width attr) (toPx $ dimension Height
   where
     toPx = fmap (showInPixel opts) . checkPct
     checkPct (Just (Percent _)) = Nothing
-    checkPct maybeDim = maybeDim
+    checkPct maybeDim           = maybeDim
     go (Just w) Nothing  = "?" ++ w
     go (Just w) (Just h) = "?" ++ w ++ "x" ++ h
     go Nothing  (Just h) = "?0x" ++ h
diff --git a/src/Text/Pandoc/Writers/EPUB.hs b/src/Text/Pandoc/Writers/EPUB.hs
index 17fa0bf3e..5b64564ce 100644
--- a/src/Text/Pandoc/Writers/EPUB.hs
+++ b/src/Text/Pandoc/Writers/EPUB.hs
@@ -1,4 +1,7 @@
-{-# LANGUAGE PatternGuards, CPP, ScopedTypeVariables, ViewPatterns, FlexibleContexts #-}
+{-# LANGUAGE CPP                 #-}
+{-# LANGUAGE FlexibleContexts    #-}
+{-# LANGUAGE PatternGuards       #-}
+{-# LANGUAGE ScopedTypeVariables #-}
 {-
 Copyright (C) 2010-2015 John MacFarlane <jgm@berkeley.edu>
 
@@ -29,45 +32,44 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Conversion of 'Pandoc' documents to EPUB.
 -}
 module Text.Pandoc.Writers.EPUB ( writeEPUB2, writeEPUB3 ) where
-import Text.Pandoc.Logging
-import qualified Data.Map as M
-import qualified Data.Set as Set
-import Data.Maybe ( fromMaybe, catMaybes )
-import Data.List ( isPrefixOf, isInfixOf, intercalate )
-import Text.Printf (printf)
-import System.FilePath ( takeExtension, takeFileName )
-import Network.HTTP ( urlEncode )
+import Codec.Archive.Zip (Entry, addEntryToArchive, eRelativePath, emptyArchive,
+                          fromArchive, fromEntry, toEntry)
+import Control.Monad (mplus, when, zipWithM)
+import Control.Monad.Except (catchError, throwError)
+import Control.Monad.State (State, StateT, evalState, evalStateT, get, gets,
+                            lift, modify, put)
 import qualified Data.ByteString.Lazy as B
 import qualified Data.ByteString.Lazy.Char8 as B8
-import qualified Text.Pandoc.UTF8 as UTF8
-import Codec.Archive.Zip ( emptyArchive, addEntryToArchive, eRelativePath, fromEntry                         , Entry, toEntry, fromArchive)
-import Text.Pandoc.Compat.Time
-import Text.Pandoc.Shared ( renderTags', safeRead, uniqueIdent, trim
-                          , normalizeDate, stringify
-                          , hierarchicalize )
-import qualified Text.Pandoc.Shared as S (Element(..))
+import Data.Char (isAlphaNum, isDigit, toLower)
+import Data.List (intercalate, isInfixOf, isPrefixOf)
+import qualified Data.Map as M
+import Data.Maybe (catMaybes, fromMaybe)
+import qualified Data.Set as Set
+import Network.HTTP (urlEncode)
+import System.FilePath (takeExtension, takeFileName)
+import Text.HTML.TagSoup (Tag (TagOpen), fromAttrib, parseTags)
 import Text.Pandoc.Builder (fromList, setMeta)
-import Text.Pandoc.Options ( WriterOptions(..)
-                           , WrapOption(..)
-                           , HTMLMathMethod(..)
-                           , EPUBVersion(..)
-                           , ObfuscationMethod(NoObfuscation) )
-import Text.Pandoc.Definition
-import Text.Pandoc.Walk (walk, walkM, query)
-import Text.Pandoc.UUID (getUUID)
-import Control.Monad.State (modify, get, gets, State, StateT, put, evalState, evalStateT, lift)
-import Control.Monad (mplus, when, zipWithM)
-import Text.XML.Light ( unode, Element(..), unqual, Attr(..), add_attrs
-                      , strContent, lookupAttr, Node(..), QName(..), parseXML
-                      , onlyElems, node, ppElement)
-import Text.Pandoc.Writers.HTML ( writeHtmlStringForEPUB )
-import Data.Char ( toLower, isDigit, isAlphaNum )
-import Text.Pandoc.MIME (MimeType, getMimeType, extensionFromMimeType)
-import Text.HTML.TagSoup (Tag(TagOpen), fromAttrib, parseTags)
-import Control.Monad.Except (throwError, catchError)
-import Text.Pandoc.Error
 import Text.Pandoc.Class (PandocMonad, report)
 import qualified Text.Pandoc.Class as P
+import Text.Pandoc.Compat.Time
+import Text.Pandoc.Definition
+import Text.Pandoc.Error
+import Text.Pandoc.Logging
+import Text.Pandoc.MIME (MimeType, extensionFromMimeType, getMimeType)
+import Text.Pandoc.Options (EPUBVersion (..), HTMLMathMethod (..),
+                            ObfuscationMethod (NoObfuscation), WrapOption (..),
+                            WriterOptions (..))
+import Text.Pandoc.Shared (hierarchicalize, normalizeDate, renderTags',
+                           safeRead, stringify, trim, uniqueIdent)
+import qualified Text.Pandoc.Shared as S (Element (..))
+import qualified Text.Pandoc.UTF8 as UTF8
+import Text.Pandoc.UUID (getUUID)
+import Text.Pandoc.Walk (query, walk, walkM)
+import Text.Pandoc.Writers.HTML (writeHtmlStringForEPUB)
+import Text.Printf (printf)
+import Text.XML.Light (Attr (..), Element (..), Node (..), QName (..),
+                       add_attrs, lookupAttr, node, onlyElems, parseXML,
+                       ppElement, strContent, unode, unqual)
 
 -- A Chapter includes a list of blocks and maybe a section
 -- number offset.  Note, some chapters are unnumbered. The section
@@ -82,46 +84,46 @@ data EPUBState = EPUBState {
 type E m = StateT EPUBState m
 
 data EPUBMetadata = EPUBMetadata{
-    epubIdentifier         :: [Identifier]
-  , epubTitle              :: [Title]
-  , epubDate               :: [Date]
-  , epubLanguage           :: String
-  , epubCreator            :: [Creator]
-  , epubContributor        :: [Creator]
-  , epubSubject            :: [String]
-  , epubDescription        :: Maybe String
-  , epubType               :: Maybe String
-  , epubFormat             :: Maybe String
-  , epubPublisher          :: Maybe String
-  , epubSource             :: Maybe String
-  , epubRelation           :: Maybe String
-  , epubCoverage           :: Maybe String
-  , epubRights             :: Maybe String
-  , epubCoverImage         :: Maybe String
-  , epubStylesheets        :: [FilePath]
-  , epubPageDirection      :: Maybe ProgressionDirection
+    epubIdentifier    :: [Identifier]
+  , epubTitle         :: [Title]
+  , epubDate          :: [Date]
+  , epubLanguage      :: String
+  , epubCreator       :: [Creator]
+  , epubContributor   :: [Creator]
+  , epubSubject       :: [String]
+  , epubDescription   :: Maybe String
+  , epubType          :: Maybe String
+  , epubFormat        :: Maybe String
+  , epubPublisher     :: Maybe String
+  , epubSource        :: Maybe String
+  , epubRelation      :: Maybe String
+  , epubCoverage      :: Maybe String
+  , epubRights        :: Maybe String
+  , epubCoverImage    :: Maybe String
+  , epubStylesheets   :: [FilePath]
+  , epubPageDirection :: Maybe ProgressionDirection
   } deriving Show
 
 data Date = Date{
-    dateText               :: String
-  , dateEvent              :: Maybe String
+    dateText  :: String
+  , dateEvent :: Maybe String
   } deriving Show
 
 data Creator = Creator{
-    creatorText            :: String
-  , creatorRole            :: Maybe String
-  , creatorFileAs          :: Maybe String
+    creatorText   :: String
+  , creatorRole   :: Maybe String
+  , creatorFileAs :: Maybe String
   } deriving Show
 
 data Identifier = Identifier{
-    identifierText         :: String
-  , identifierScheme       :: Maybe String
+    identifierText   :: String
+  , identifierScheme :: Maybe String
   } deriving Show
 
 data Title = Title{
-    titleText              :: String
-  , titleFileAs            :: Maybe String
-  , titleType              :: Maybe String
+    titleText   :: String
+  , titleFileAs :: Maybe String
+  , titleType   :: Maybe String
   } deriving Show
 
 data ProgressionDirection = LTR | RTL deriving Show
@@ -229,16 +231,16 @@ addMetadataFromXML e@(Element (QName name _ (Just "dc")) attrs _ _) md
 addMetadataFromXML _ md = md
 
 metaValueToString :: MetaValue -> String
-metaValueToString (MetaString s) = s
+metaValueToString (MetaString s)    = s
 metaValueToString (MetaInlines ils) = stringify ils
-metaValueToString (MetaBlocks bs) = stringify bs
-metaValueToString (MetaBool True) = "true"
-metaValueToString (MetaBool False) = "false"
-metaValueToString _ = ""
+metaValueToString (MetaBlocks bs)   = stringify bs
+metaValueToString (MetaBool True)   = "true"
+metaValueToString (MetaBool False)  = "false"
+metaValueToString _                 = ""
 
 metaValueToPaths:: MetaValue -> [FilePath]
 metaValueToPaths (MetaList xs) = map metaValueToString xs
-metaValueToPaths x = [metaValueToString x]
+metaValueToPaths x             = [metaValueToString x]
 
 getList :: String -> Meta -> (MetaValue -> a) -> [a]
 getList s meta handleMetaValue =
@@ -286,8 +288,8 @@ simpleList :: String -> Meta -> [String]
 simpleList s meta =
   case lookupMeta s meta of
        Just (MetaList xs) -> map metaValueToString xs
-       Just x -> [metaValueToString x]
-       Nothing -> []
+       Just x             -> [metaValueToString x]
+       Nothing            -> []
 
 metadataFromMeta :: WriterOptions -> Meta -> EPUBMetadata
 metadataFromMeta opts meta = EPUBMetadata{
@@ -538,8 +540,8 @@ pandocToEPUB version opts doc@(Pandoc meta _) = do
                              ("href", eRelativePath ent),
                              ("media-type", "application/xhtml+xml")]
                             ++ case props ent of
-                                    []   -> []
-                                    xs   -> [("properties", unwords xs)])
+                                    [] -> []
+                                    xs -> [("properties", unwords xs)])
                         $ ()
   let chapterRefNode ent = unode "itemref" !
                              [("idref", toId $ eRelativePath ent)] $ ()
@@ -554,7 +556,7 @@ pandocToEPUB version opts doc@(Pandoc meta _) = do
                             ("media-type", fromMaybe "" $ getMimeType $ eRelativePath ent)] $ ()
   let plainTitle = case docTitle' meta of
                         [] -> case epubTitle metadata of
-                                   []   -> "UNTITLED"
+                                   []    -> "UNTITLED"
                                    (x:_) -> titleText x
                         x  -> stringify x
 
@@ -635,7 +637,7 @@ pandocToEPUB version opts doc@(Pandoc meta _) = do
                  Just x  -> return x
                  Nothing -> throwError $ PandocSomeError $ ident ++ " not found in reftable"
         let isSec (S.Sec lev _ _ _ _) = lev <= tocLevel
-            isSec _                 = False
+            isSec _                   = False
         let subsecs = filter isSec children
         subs <- mapM (navPointNode formatter) subsecs
         return $ formatter n tit src subs
@@ -830,22 +832,22 @@ metadataElement version md currentTime =
              (("id",id') :
                 maybe [] (\x -> [("opf:event",x)]) (dateEvent date)) $
                  dateText date]
-        schemeToOnix "ISBN-10" = "02"
-        schemeToOnix "GTIN-13" = "03"
-        schemeToOnix "UPC"     = "04"
-        schemeToOnix "ISMN-10" = "05"
-        schemeToOnix "DOI"     = "06"
-        schemeToOnix "LCCN"    = "13"
-        schemeToOnix "GTIN-14" = "14"
-        schemeToOnix "ISBN-13" = "15"
+        schemeToOnix "ISBN-10"              = "02"
+        schemeToOnix "GTIN-13"              = "03"
+        schemeToOnix "UPC"                  = "04"
+        schemeToOnix "ISMN-10"              = "05"
+        schemeToOnix "DOI"                  = "06"
+        schemeToOnix "LCCN"                 = "13"
+        schemeToOnix "GTIN-14"              = "14"
+        schemeToOnix "ISBN-13"              = "15"
         schemeToOnix "Legal deposit number" = "17"
-        schemeToOnix "URN"     = "22"
-        schemeToOnix "OCLC"    = "23"
-        schemeToOnix "ISMN-13" = "25"
-        schemeToOnix "ISBN-A"  = "26"
-        schemeToOnix "JP"      = "27"
-        schemeToOnix "OLCC"    = "28"
-        schemeToOnix _         = "01"
+        schemeToOnix "URN"                  = "22"
+        schemeToOnix "OCLC"                 = "23"
+        schemeToOnix "ISMN-13"              = "25"
+        schemeToOnix "ISBN-A"               = "26"
+        schemeToOnix "JP"                   = "27"
+        schemeToOnix "OLCC"                 = "28"
+        schemeToOnix _                      = "01"
 
 showDateTimeISO8601 :: UTCTime -> String
 showDateTimeISO8601 = formatTime defaultTimeLocale "%FT%TZ"
@@ -936,8 +938,8 @@ ppTopElement = ("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" ++) . unEntity .
                    let (ds,ys) = break (==';') xs
                        rest = drop 1 ys
                    in  case safeRead ('\'':'\\':ds ++ "'") of
-                          Just x   -> x : unEntity rest
-                          Nothing  -> '&':'#':unEntity xs
+                          Just x  -> x : unEntity rest
+                          Nothing -> '&':'#':unEntity xs
         unEntity (x:xs) = x : unEntity xs
 
 mediaTypeOf :: FilePath -> Maybe MimeType
@@ -945,7 +947,7 @@ mediaTypeOf x =
   let mediaPrefixes = ["image", "video", "audio"] in
   case getMimeType x of
     Just y | any (`isPrefixOf` y) mediaPrefixes -> Just y
-    _                                           -> Nothing
+    _      -> Nothing
 
 -- Returns filename for chapter number.
 showChapter :: Int -> String
diff --git a/src/Text/Pandoc/Writers/FB2.hs b/src/Text/Pandoc/Writers/FB2.hs
index 967fe6a4c..238bd397b 100644
--- a/src/Text/Pandoc/Writers/FB2.hs
+++ b/src/Text/Pandoc/Writers/FB2.hs
@@ -27,37 +27,37 @@ FictionBook is an XML-based e-book format. For more information see:
 -}
 module Text.Pandoc.Writers.FB2 (writeFB2)  where
 
-import Control.Monad.State (StateT, evalStateT, get, modify, lift)
+import Control.Monad.Except (catchError, throwError)
+import Control.Monad.State (StateT, evalStateT, get, lift, modify)
 import Control.Monad.State (liftM)
 import Data.ByteString.Base64 (encode)
-import Data.Char (toLower, isSpace, isAscii, isControl)
-import Data.List (intersperse, intercalate, isPrefixOf, stripPrefix)
+import qualified Data.ByteString.Char8 as B8
+import Data.Char (isAscii, isControl, isSpace, toLower)
 import Data.Either (lefts, rights)
+import Data.List (intercalate, intersperse, isPrefixOf, stripPrefix)
 import Network.HTTP (urlEncode)
 import Network.URI (isURI)
 import Text.XML.Light
 import qualified Text.XML.Light as X
 import qualified Text.XML.Light.Cursor as XC
-import qualified Data.ByteString.Char8 as B8
-import Control.Monad.Except (throwError, catchError)
 
-import Text.Pandoc.Logging
-import Text.Pandoc.Definition
-import Text.Pandoc.Options (WriterOptions(..), HTMLMathMethod(..), def)
-import Text.Pandoc.Shared (orderedListMarkers, isHeaderBlock, capitalize,
-                           linesToPara)
-import Text.Pandoc.Error
 import Text.Pandoc.Class (PandocMonad, report)
 import qualified Text.Pandoc.Class as P
+import Text.Pandoc.Definition
+import Text.Pandoc.Error
+import Text.Pandoc.Logging
+import Text.Pandoc.Options (HTMLMathMethod (..), WriterOptions (..), def)
+import Text.Pandoc.Shared (capitalize, isHeaderBlock, linesToPara,
+                           orderedListMarkers)
 
 -- | Data to be written at the end of the document:
 -- (foot)notes, URLs, references, images.
 data FbRenderState = FbRenderState
-    { footnotes :: [ (Int, String, [Content]) ]  -- ^ #, ID, text
-    , imagesToFetch :: [ (String, String) ]  -- ^ filename, URL or path
-    , parentListMarker :: String  -- ^ list marker of the parent ordered list
+    { footnotes         :: [ (Int, String, [Content]) ]  -- ^ #, ID, text
+    , imagesToFetch     :: [ (String, String) ]  -- ^ filename, URL or path
+    , parentListMarker  :: String  -- ^ list marker of the parent ordered list
     , parentBulletLevel :: Int  -- ^ nesting level of the unordered list
-    , writerOptions :: WriterOptions
+    , writerOptions     :: WriterOptions
     } deriving (Show)
 
 -- | FictionBook building monad.
@@ -188,7 +188,7 @@ split cond xs = let (b,a) = break cond xs
 
 isLineBreak :: Inline -> Bool
 isLineBreak LineBreak = True
-isLineBreak _ = False
+isLineBreak _         = False
 
 -- | Divide the stream of block elements into sections: [(title, blocks)].
 splitSections :: Int -> [Block] -> [([Inline], [Block])]
@@ -206,7 +206,7 @@ splitSections level blocks = reverse $ revSplit (reverse blocks)
               _ -> ([], before)
     in (header, reverse lastsec) : revSplit prevblocks
   sameLevel (Header n _ _) = n == level
-  sameLevel _ = False
+  sameLevel _              = False
 
 -- | Make another FictionBook body with footnotes.
 renderFootnotes :: PandocMonad m => FBM m [Content]
@@ -353,9 +353,9 @@ blockToXml (DefinitionList defs) =
               blocks ++ [Plain [LineBreak]]
           else
               blocks
-      needsBreak (Para _) = False
+      needsBreak (Para _)    = False
       needsBreak (Plain ins) = LineBreak `notElem` ins
-      needsBreak _ = True
+      needsBreak _           = True
 blockToXml (Header _ _ _) = -- should never happen, see renderSections
                           throwError $ PandocShouldNeverHappenError "unexpected header in section text"
 blockToXml HorizontalRule = return
@@ -378,9 +378,9 @@ blockToXml (Table caption aligns _ headers rows) = do
         return $ el tag ([align_attr align], cblocks)
       --
       align_attr a = Attr (QName "align" Nothing Nothing) (align_str a)
-      align_str AlignLeft = "left"
-      align_str AlignCenter = "center"
-      align_str AlignRight = "right"
+      align_str AlignLeft    = "left"
+      align_str AlignCenter  = "center"
+      align_str AlignRight   = "right"
       align_str AlignDefault = "left"
 blockToXml Null = return []
 
@@ -488,7 +488,7 @@ insertImage immode (Image _ alt (url,ttl)) = do
   modify (\s -> s { imagesToFetch = (fname, url) : images })
   let ttlattr = case (immode, null ttl) of
                   (NormalImage, False) -> [ uattr "title" ttl ]
-                  _ -> []
+                  _                    -> []
   return . list $
          el "image" $
             [ attr ("l","href") ('#':fname)
@@ -512,11 +512,11 @@ replaceImagesWithAlt missingHrefs body =
                  else c
         in  case XC.nextDF c' of
               (Just cnext) -> replaceAll cnext
-              Nothing -> c'  -- end of document
+              Nothing      -> c'  -- end of document
   --
     isImage :: Content -> Bool
     isImage (Elem e) = (elName e) == (uname "image")
-    isImage _ = False
+    isImage _        = False
   --
     isMissing (Elem img@(Element _ _ _ _)) =
         let imgAttrs = elAttribs img
@@ -555,25 +555,25 @@ list = (:[])
 
 -- | Convert an 'Inline' to plaintext.
 plain :: Inline -> String
-plain (Str s) = s
-plain (Emph ss) = concat (map plain ss)
-plain (Span _ ss) = concat (map plain ss)
-plain (Strong ss) = concat (map plain ss)
-plain (Strikeout ss) = concat (map plain ss)
-plain (Superscript ss) = concat (map plain ss)
-plain (Subscript ss) = concat (map plain ss)
-plain (SmallCaps ss) = concat (map plain ss)
-plain (Quoted _ ss) = concat (map plain ss)
-plain (Cite _ ss) = concat (map plain ss)  -- FIXME
-plain (Code _ s) = s
-plain Space = " "
-plain SoftBreak = " "
-plain LineBreak = "\n"
-plain (Math _ s) = s
-plain (RawInline _ _) = ""
+plain (Str s)               = s
+plain (Emph ss)             = concat (map plain ss)
+plain (Span _ ss)           = concat (map plain ss)
+plain (Strong ss)           = concat (map plain ss)
+plain (Strikeout ss)        = concat (map plain ss)
+plain (Superscript ss)      = concat (map plain ss)
+plain (Subscript ss)        = concat (map plain ss)
+plain (SmallCaps ss)        = concat (map plain ss)
+plain (Quoted _ ss)         = concat (map plain ss)
+plain (Cite _ ss)           = concat (map plain ss)  -- FIXME
+plain (Code _ s)            = s
+plain Space                 = " "
+plain SoftBreak             = " "
+plain LineBreak             = "\n"
+plain (Math _ s)            = s
+plain (RawInline _ _)       = ""
 plain (Link _ text (url,_)) = concat (map plain text ++ [" <", url, ">"])
-plain (Image _ alt _) = concat (map plain alt)
-plain (Note _) = ""  -- FIXME
+plain (Image _ alt _)       = concat (map plain alt)
+plain (Note _)              = ""  -- FIXME
 
 -- | Create an XML element.
 el :: (Node t)
diff --git a/src/Text/Pandoc/Writers/HTML.hs b/src/Text/Pandoc/Writers/HTML.hs
index 332536492..6a5c4e43a 100644
--- a/src/Text/Pandoc/Writers/HTML.hs
+++ b/src/Text/Pandoc/Writers/HTML.hs
@@ -1,4 +1,7 @@
-{-# LANGUAGE OverloadedStrings, CPP, ViewPatterns, ScopedTypeVariables #-}
+{-# LANGUAGE CPP                 #-}
+{-# LANGUAGE OverloadedStrings   #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE ViewPatterns        #-}
 {-
 Copyright (C) 2006-2015 John MacFarlane <jgm@berkeley.edu>
 
@@ -40,61 +43,61 @@ module Text.Pandoc.Writers.HTML (
   writeDZSlides,
   writeRevealJs
   ) where
-import Text.Pandoc.Definition
-import Text.Pandoc.Walk
+import Control.Monad.State
+import Data.Char (ord, toLower)
+import Data.List (intersperse, isPrefixOf)
+import Data.Maybe (catMaybes, fromMaybe, isJust)
 import Data.Monoid ((<>))
-import Text.Pandoc.Shared
-import Text.Pandoc.Writers.Shared
-import Text.Pandoc.Options
+import Data.String (fromString)
+import Network.HTTP (urlEncode)
+import Network.URI (URI (..), parseURIReference, unEscapeString)
+import Numeric (showHex)
+import Text.Blaze.Html hiding (contents)
+import Text.Pandoc.Definition
+import Text.Pandoc.Highlighting (formatHtmlBlock, formatHtmlInline, highlight,
+                                 styleToCss)
 import Text.Pandoc.ImageSize
+import Text.Pandoc.Options
+import Text.Pandoc.Shared
+import Text.Pandoc.Slides
 import Text.Pandoc.Templates
+import Text.Pandoc.Walk
 import Text.Pandoc.Writers.Math
-import Text.Pandoc.Slides
-import Text.Pandoc.Highlighting ( highlight, styleToCss,
-                                  formatHtmlInline, formatHtmlBlock )
-import Text.Pandoc.XML (fromEntities, escapeStringForXML)
-import Network.URI ( parseURIReference, URI(..), unEscapeString )
-import Network.HTTP ( urlEncode )
-import Numeric ( showHex )
-import Data.Char ( ord, toLower )
-import Data.List ( isPrefixOf, intersperse )
-import Data.String ( fromString )
-import Data.Maybe ( catMaybes, fromMaybe, isJust )
-import Control.Monad.State
-import Text.Blaze.Html hiding(contents)
+import Text.Pandoc.Writers.Shared
+import Text.Pandoc.XML (escapeStringForXML, fromEntities)
 #if MIN_VERSION_blaze_markup(0,6,3)
 #else
-import Text.Blaze.Internal(preEscapedString)
+import Text.Blaze.Internal (preEscapedString)
 #endif
 #if MIN_VERSION_blaze_html(0,5,1)
 import qualified Text.Blaze.XHtml5 as H5
 #else
 import qualified Text.Blaze.Html5 as H5
 #endif
+import Control.Monad.Except (throwError)
+import Data.Aeson (Value)
+import System.FilePath (takeExtension)
+import Text.Blaze.Html.Renderer.String (renderHtml)
 import qualified Text.Blaze.XHtml1.Transitional as H
 import qualified Text.Blaze.XHtml1.Transitional.Attributes as A
-import Text.Blaze.Html.Renderer.String (renderHtml)
-import Text.TeXMath
-import Text.XML.Light.Output
-import Text.XML.Light (unode, elChildren, unqual)
-import qualified Text.XML.Light as XML
-import System.FilePath (takeExtension)
-import Data.Aeson (Value)
-import Control.Monad.Except (throwError)
-import Text.Pandoc.Error
 import Text.Pandoc.Class (PandocMonad, report)
+import Text.Pandoc.Error
 import Text.Pandoc.Logging
+import Text.TeXMath
+import Text.XML.Light (elChildren, unode, unqual)
+import qualified Text.XML.Light as XML
+import Text.XML.Light.Output
 
 data WriterState = WriterState
-    { stNotes            :: [Html]  -- ^ List of notes
-    , stMath             :: Bool    -- ^ Math is used in document
-    , stQuotes           :: Bool    -- ^ <q> tag is used
-    , stHighlighting     :: Bool    -- ^ Syntax highlighting is used
-    , stSecNum           :: [Int]   -- ^ Number of current section
-    , stElement          :: Bool    -- ^ Processing an Element
-    , stHtml5            :: Bool    -- ^ Use HTML5
-    , stEPUBVersion      :: Maybe EPUBVersion -- ^ EPUB version if for epub
-    , stSlideVariant     :: HTMLSlideVariant
+    { stNotes        :: [Html]  -- ^ List of notes
+    , stMath         :: Bool    -- ^ Math is used in document
+    , stQuotes       :: Bool    -- ^ <q> tag is used
+    , stHighlighting :: Bool    -- ^ Syntax highlighting is used
+    , stSecNum       :: [Int]   -- ^ Number of current section
+    , stElement      :: Bool    -- ^ Processing an Element
+    , stHtml5        :: Bool    -- ^ Use HTML5
+    , stEPUBVersion  :: Maybe EPUBVersion -- ^ EPUB version if for epub
+    , stSlideVariant :: HTMLSlideVariant
     }
 
 defaultWriterState :: WriterState
@@ -290,8 +293,8 @@ pandocToHtml opts (Pandoc meta blocks) = do
 prefixedId :: WriterOptions -> String -> Attribute
 prefixedId opts s =
   case s of
-    ""       -> mempty
-    _        -> A.id $ toValue $ writerIdentifierPrefix opts ++ s
+    "" -> mempty
+    _  -> A.id $ toValue $ writerIdentifierPrefix opts ++ s
 
 toList :: PandocMonad m
        => (Html -> Html)
@@ -387,8 +390,8 @@ elementToHtml slideLevel opts (Sec level num (id',classes,keyvals) title' elemen
   let isPause (Blk x) = x == Para [Str ".",Space,Str ".",Space,Str "."]
       isPause _       = False
   let fragmentClass = case slideVariant of
-                           RevealJsSlides  -> "fragment"
-                           _               -> "incremental"
+                           RevealJsSlides -> "fragment"
+                           _              -> "incremental"
   let inDiv xs = Blk (RawBlock (Format "html") ("<div class=\""
                        ++ fragmentClass ++ "\">")) :
                    (xs ++ [Blk (RawBlock (Format "html") "</div>")])
@@ -515,7 +518,7 @@ imgAttrsToHtml opts attr =
     kvs' = filter isNotDim kvs
     isNotDim ("width", _)  = False
     isNotDim ("height", _) = False
-    isNotDim _ = True
+    isNotDim _             = True
 
 dimensionsToAttrList :: WriterOptions -> Attr -> [(String, String)]
 dimensionsToAttrList opts attr = (go Width) ++ (go Height)
@@ -581,7 +584,7 @@ blockToHtml opts (Para lst)
       return $ H.p contents
   where
     isEmptyRaw [RawInline f _] = f /= (Format "html")
-    isEmptyRaw _                 = False
+    isEmptyRaw _               = False
 blockToHtml opts (LineBlock lns) =
   if writerWrapText opts == WrapNone
   then blockToHtml opts $ linesToPara lns
@@ -767,9 +770,9 @@ tableRowToHtml :: PandocMonad m
 tableRowToHtml opts aligns rownum cols' = do
   let mkcell = if rownum == 0 then H.th else H.td
   let rowclass = case rownum of
-                      0                  -> "header"
+                      0 -> "header"
                       x | x `rem` 2 == 1 -> "odd"
-                      _                  -> "even"
+                      _ -> "even"
   cols'' <- sequence $ zipWith
             (\alignment item -> tableItemToHtml opts mkcell alignment item)
             aligns cols'
@@ -821,9 +824,9 @@ annotateMML :: XML.Element -> String -> XML.Element
 annotateMML e tex = math (unode "semantics" [cs, unode "annotation" (annotAttrs, tex)])
   where
     cs = case elChildren e of
-          [] -> unode "mrow" ()
+          []  -> unode "mrow" ()
           [x] -> x
-          xs -> unode "mrow" xs
+          xs  -> unode "mrow" xs
     math childs = XML.Element q as [XML.Elem childs] l
       where
         (XML.Element q as _ l) = e
@@ -908,7 +911,7 @@ inlineToHtml opts inline = do
            JsMath _ -> do
               let m = preEscapedString str
               return $ case t of
-                       InlineMath -> H.span ! A.class_ mathClass $ m
+                       InlineMath  -> H.span ! A.class_ mathClass $ m
                        DisplayMath -> H.div ! A.class_ mathClass $ m
            WebTeX url -> do
               let imtag = if html5 then H5.img else H.img
@@ -939,7 +942,7 @@ inlineToHtml opts inline = do
                 DisplayMath -> "\\[" ++ str ++ "\\]"
            KaTeX _ _ -> return $ H.span ! A.class_ mathClass $
               toHtml (case t of
-                        InlineMath -> str
+                        InlineMath  -> str
                         DisplayMath -> "\\displaystyle " ++ str)
            PlainMath -> do
               x <- lift (texMathToInlines t str) >>= inlineListToHtml opts
diff --git a/src/Text/Pandoc/Writers/Haddock.hs b/src/Text/Pandoc/Writers/Haddock.hs
index 945e4a0f1..7f7d89a43 100644
--- a/src/Text/Pandoc/Writers/Haddock.hs
+++ b/src/Text/Pandoc/Writers/Haddock.hs
@@ -1,4 +1,6 @@
-{-# LANGUAGE OverloadedStrings, TupleSections, ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings   #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TupleSections       #-}
 {-
 Copyright (C) 2014 John MacFarlane <jgm@berkeley.edu>
 
@@ -31,19 +33,19 @@ Conversion of 'Pandoc' documents to haddock markup.
 Haddock:  <http://www.haskell.org/haddock/doc/html/>
 -}
 module Text.Pandoc.Writers.Haddock (writeHaddock) where
-import Text.Pandoc.Definition
-import Text.Pandoc.Templates (renderTemplate')
-import Text.Pandoc.Shared
-import Text.Pandoc.Writers.Shared
-import Text.Pandoc.Options
-import Data.List ( intersperse, transpose )
-import Text.Pandoc.Pretty
 import Control.Monad.State
-import Text.Pandoc.Writers.Math (texMathToInlines)
-import Network.URI (isURI)
 import Data.Default
+import Data.List (intersperse, transpose)
+import Network.URI (isURI)
 import Text.Pandoc.Class (PandocMonad, report)
+import Text.Pandoc.Definition
 import Text.Pandoc.Logging
+import Text.Pandoc.Options
+import Text.Pandoc.Pretty
+import Text.Pandoc.Shared
+import Text.Pandoc.Templates (renderTemplate')
+import Text.Pandoc.Writers.Math (texMathToInlines)
+import Text.Pandoc.Writers.Shared
 
 type Notes = [[Block]]
 data WriterState = WriterState { stNotes :: Notes }
@@ -269,7 +271,7 @@ orderedListItemToHaddock opts marker items = do
   contents <- blockListToHaddock opts items
   let sps = case length marker - writerTabStop opts of
                    n | n > 0 -> text $ replicate n ' '
-                   _         -> text " "
+                   _ -> text " "
   let start = text marker <> sps
   return $ hang (writerTabStop opts) start $ contents <> cr
 
@@ -356,7 +358,7 @@ inlineToHaddock _ (Link _ txt (src, _)) = do
   let useAuto = isURI src &&
                 case txt of
                       [Str s] | escapeURI s == src -> True
-                      _                            -> False
+                      _       -> False
   return $ nowrap $ "<" <> text src <>
            (if useAuto then empty else space <> linktext) <> ">"
 inlineToHaddock opts (Image attr alternate (source, tit)) = do
diff --git a/src/Text/Pandoc/Writers/ICML.hs b/src/Text/Pandoc/Writers/ICML.hs
index 59f9db26a..cd3cac5a7 100644
--- a/src/Text/Pandoc/Writers/ICML.hs
+++ b/src/Text/Pandoc/Writers/ICML.hs
@@ -1,4 +1,6 @@
-{-# LANGUAGE OverloadedStrings, FlexibleContexts, ScopedTypeVariables #-}
+{-# LANGUAGE FlexibleContexts    #-}
+{-# LANGUAGE OverloadedStrings   #-}
+{-# LANGUAGE ScopedTypeVariables #-}
 
 {- |
    Module      : Text.Pandoc.Writers.ICML
@@ -14,25 +16,25 @@ InCopy is the companion word-processor to Adobe InDesign and ICML documents can
 into InDesign with File -> Place.
 -}
 module Text.Pandoc.Writers.ICML (writeICML) where
-import Text.Pandoc.Definition
-import Text.Pandoc.Error (PandocError(..))
-import Text.Pandoc.XML
-import Text.Pandoc.Writers.Math (texMathToInlines)
-import Text.Pandoc.Writers.Shared
-import Text.Pandoc.Shared (linesToPara, splitBy)
-import Text.Pandoc.Options
-import Text.Pandoc.Templates (renderTemplate')
-import Text.Pandoc.Pretty
-import Text.Pandoc.ImageSize
-import Data.List (isPrefixOf, isInfixOf, stripPrefix, intersperse)
-import Data.Text as Text (breakOnAll, pack)
-import Control.Monad.State
 import Control.Monad.Except (catchError)
-import Network.URI (isURI)
+import Control.Monad.State
+import Data.List (intersperse, isInfixOf, isPrefixOf, stripPrefix)
 import qualified Data.Set as Set
+import Data.Text as Text (breakOnAll, pack)
+import Network.URI (isURI)
 import Text.Pandoc.Class (PandocMonad, report)
-import Text.Pandoc.Logging
 import qualified Text.Pandoc.Class as P
+import Text.Pandoc.Definition
+import Text.Pandoc.Error (PandocError (..))
+import Text.Pandoc.ImageSize
+import Text.Pandoc.Logging
+import Text.Pandoc.Options
+import Text.Pandoc.Pretty
+import Text.Pandoc.Shared (linesToPara, splitBy)
+import Text.Pandoc.Templates (renderTemplate')
+import Text.Pandoc.Writers.Math (texMathToInlines)
+import Text.Pandoc.Writers.Shared
+import Text.Pandoc.XML
 
 type Style = [String]
 type Hyperlink = [(Int, String)]
@@ -384,11 +386,11 @@ listItemToICML :: PandocMonad m => WriterOptions -> Style -> Bool-> Maybe ListAt
 listItemToICML opts style isFirst attribs item =
   let makeNumbStart (Just (beginsWith, numbStl, _)) =
         let doN DefaultStyle = []
-            doN LowerRoman = [lowerRomanName]
-            doN UpperRoman = [upperRomanName]
-            doN LowerAlpha = [lowerAlphaName]
-            doN UpperAlpha = [upperAlphaName]
-            doN _ = []
+            doN LowerRoman   = [lowerRomanName]
+            doN UpperRoman   = [upperRomanName]
+            doN LowerAlpha   = [lowerAlphaName]
+            doN UpperAlpha   = [upperAlphaName]
+            doN _            = []
             bw = if beginsWith > 1
                     then [beginsWithName ++ show beginsWith]
                     else []
@@ -483,9 +485,9 @@ mergeSpaces (x:xs) = x : (mergeSpaces xs)
 mergeSpaces []     = []
 
 isSp :: Inline -> Bool
-isSp Space = True
+isSp Space     = True
 isSp SoftBreak = True
-isSp _ = False
+isSp _         = False
 
 -- | Intersperse line breaks
 intersperseBrs :: [Doc] -> Doc
diff --git a/src/Text/Pandoc/Writers/LaTeX.hs b/src/Text/Pandoc/Writers/LaTeX.hs
index 11cd0479d..578c7017f 100644
--- a/src/Text/Pandoc/Writers/LaTeX.hs
+++ b/src/Text/Pandoc/Writers/LaTeX.hs
@@ -1,5 +1,6 @@
-{-# LANGUAGE OverloadedStrings, ScopedTypeVariables,
-             PatternGuards #-}
+{-# LANGUAGE OverloadedStrings   #-}
+{-# LANGUAGE PatternGuards       #-}
+{-# LANGUAGE ScopedTypeVariables #-}
 {-
 Copyright (C) 2006-2015 John MacFarlane <jgm@berkeley.edu>
 
@@ -33,32 +34,31 @@ module Text.Pandoc.Writers.LaTeX (
     writeLaTeX
   , writeBeamer
   ) where
-import Text.Pandoc.Definition
-import Text.Pandoc.Walk
-import Text.Pandoc.Shared
-import Text.Pandoc.Writers.Shared
-import Text.Pandoc.Options
-import Text.Pandoc.Templates
-import Text.Pandoc.Logging
-import Text.Printf ( printf )
-import Network.URI ( isURI, unEscapeString )
-import Data.Aeson (object, (.=), FromJSON)
-import Data.List ( (\\), isInfixOf, stripPrefix, intercalate, intersperse,
-                   nub, nubBy, foldl' )
-import Data.Char ( toLower, isPunctuation, isAscii, isLetter, isDigit,
-                   ord, isAlphaNum )
-import Data.Maybe ( fromMaybe, isJust, catMaybes )
-import qualified Data.Text as T
 import Control.Applicative ((<|>))
 import Control.Monad.State
-import qualified Text.Parsec as P
-import Text.Pandoc.Pretty
+import Data.Aeson (FromJSON, object, (.=))
+import Data.Char (isAlphaNum, isAscii, isDigit, isLetter, isPunctuation, ord,
+                  toLower)
+import Data.List (foldl', intercalate, intersperse, isInfixOf, nub, nubBy,
+                  stripPrefix, (\\))
+import Data.Maybe (catMaybes, fromMaybe, isJust)
+import qualified Data.Text as T
+import Network.URI (isURI, unEscapeString)
+import Text.Pandoc.Class (PandocMonad, report)
+import Text.Pandoc.Definition
+import Text.Pandoc.Highlighting (formatLaTeXBlock, formatLaTeXInline, highlight,
+                                 styleToLaTeX, toListingsLanguage)
 import Text.Pandoc.ImageSize
+import Text.Pandoc.Logging
+import Text.Pandoc.Options
+import Text.Pandoc.Pretty
+import Text.Pandoc.Shared
 import Text.Pandoc.Slides
-import Text.Pandoc.Highlighting (highlight, styleToLaTeX,
-                                 formatLaTeXInline, formatLaTeXBlock,
-                                 toListingsLanguage)
-import Text.Pandoc.Class (PandocMonad, report)
+import Text.Pandoc.Templates
+import Text.Pandoc.Walk
+import Text.Pandoc.Writers.Shared
+import qualified Text.Parsec as P
+import Text.Printf (printf)
 
 data WriterState =
   WriterState { stInNote        :: Bool          -- true if we're in a note
@@ -131,11 +131,11 @@ pandocToLaTeX options (Pandoc meta blocks) = do
   let blocks' = if method == Biblatex || method == Natbib
                    then case reverse blocks of
                              (Div (_,["references"],_) _):xs -> reverse xs
-                             _ -> blocks
+                             _                               -> blocks
                    else blocks
   -- see if there are internal links
-  let isInternalLink (Link _ _ ('#':xs,_))  = [xs]
-      isInternalLink _                      = []
+  let isInternalLink (Link _ _ ('#':xs,_)) = [xs]
+      isInternalLink _                     = []
   modify $ \s -> s{ stInternalLinks = query isInternalLink blocks' }
   let template = maybe "" id $ writerTemplate options
   -- set stBook depending on documentclass
@@ -408,8 +408,8 @@ isListBlock _                  = False
 isLineBreakOrSpace :: Inline -> Bool
 isLineBreakOrSpace LineBreak = True
 isLineBreakOrSpace SoftBreak = True
-isLineBreakOrSpace Space = True
-isLineBreakOrSpace _ = False
+isLineBreakOrSpace Space     = True
+isLineBreakOrSpace _         = False
 
 -- | Convert Pandoc block element to LaTeX.
 blockToLaTeX :: PandocMonad m
@@ -584,10 +584,10 @@ blockToLaTeX (OrderedList (start, numstyle, numdelim) lst) = do
                        Example      -> "\\arabic" <> braces x
                        DefaultStyle -> "\\arabic" <> braces x
   let todelim x = case numdelim of
-                       OneParen    -> x <> ")"
-                       TwoParens   -> parens x
-                       Period      -> x <> "."
-                       _           -> x <> "."
+                       OneParen  -> x <> ")"
+                       TwoParens -> parens x
+                       Period    -> x <> "."
+                       _         -> x <> "."
   let enum = text $ "enum" ++ map toLower (toRomanNumeral oldlevel)
   let stylecommand = if numstyle == DefaultStyle && numdelim == DefaultDelim
                         then empty
@@ -710,7 +710,7 @@ fixLineBreaks' ils = case splitBy (== LineBreak) ils of
 -- math breaks in simple tables.
 displayMathToInline :: Inline -> Inline
 displayMathToInline (Math DisplayMath x) = Math InlineMath x
-displayMathToInline x = x
+displayMathToInline x                    = x
 
 tableCellToLaTeX :: PandocMonad m => Bool -> (Double, Alignment, [Block])
                  -> LW m Doc
@@ -783,10 +783,10 @@ sectionHeader :: PandocMonad m
 sectionHeader unnumbered ident level lst = do
   txt <- inlineListToLaTeX lst
   plain <- stringToLaTeX TextString $ concatMap stringify lst
-  let removeInvalidInline (Note _)      = []
+  let removeInvalidInline (Note _)             = []
       removeInvalidInline (Span (id', _, _) _) | not (null id') = []
-      removeInvalidInline (Image _ _ _) = []
-      removeInvalidInline x             = [x]
+      removeInvalidInline (Image _ _ _)        = []
+      removeInvalidInline x                    = [x]
   let lstNoNotes = foldr (mappend . (\x -> walkM removeInvalidInline x)) mempty lst
   txtNoNotes <- inlineListToLaTeX lstNoNotes
   -- footnotes in sections don't work (except for starred variants)
@@ -889,7 +889,7 @@ inlineListToLaTeX lst =
 
 isQuoted :: Inline -> Bool
 isQuoted (Quoted _ _) = True
-isQuoted _ = False
+isQuoted _            = False
 
 -- | Convert inline element to LaTeX
 inlineToLaTeX :: PandocMonad m
@@ -1092,8 +1092,8 @@ citationsToNatbib (one:[])
              }
       = one
     c = case m of
-             AuthorInText     -> "citet"
-             SuppressAuthor  -> "citeyearpar"
+             AuthorInText   -> "citet"
+             SuppressAuthor -> "citeyearpar"
              NormalCitation -> "citep"
 
 citationsToNatbib cits
@@ -1140,7 +1140,7 @@ citeArguments p s k = do
   let s' = case s of
         (Str (x:[]) : r) | isPunctuation x -> dropWhile (== Space) r
         (Str (x:xs) : r) | isPunctuation x -> Str xs : r
-        _                                  -> s
+        _                -> s
   pdoc <- inlineListToLaTeX p
   sdoc <- inlineListToLaTeX s'
   let optargs = case (isEmpty pdoc, isEmpty sdoc) of
@@ -1181,7 +1181,7 @@ citationsToBiblatex _ = return empty
 
 -- Determine listings language from list of class attributes.
 getListingsLanguage :: [String] -> Maybe String
-getListingsLanguage [] = Nothing
+getListingsLanguage []     = Nothing
 getListingsLanguage (x:xs) = toListingsLanguage x <|> getListingsLanguage xs
 
 mbBraced :: String -> String
@@ -1253,27 +1253,27 @@ toPolyglossia x                    = (commonFromBcp47 x, "")
 -- List of supported languages (slightly outdated):
 -- http://tug.ctan.org/language/hyph-utf8/doc/generic/hyph-utf8/hyphenation.pdf
 toBabel :: [String] -> String
-toBabel ("de":"1901":_)      = "german"
-toBabel ("de":"AT":"1901":_) = "austrian"
-toBabel ("de":"AT":_)        = "naustrian"
-toBabel ("de":"CH":"1901":_) = "swissgerman"
-toBabel ("de":"CH":_)        = "nswissgerman"
-toBabel ("de":_)             = "ngerman"
-toBabel ("dsb":_)            = "lowersorbian"
-toBabel ("el":"polyton":_)   = "polutonikogreek"
-toBabel ("en":"AU":_)        = "australian"
-toBabel ("en":"CA":_)        = "canadian"
-toBabel ("en":"GB":_)        = "british"
-toBabel ("en":"NZ":_)        = "newzealand"
-toBabel ("en":"UK":_)        = "british"
-toBabel ("en":"US":_)        = "american"
-toBabel ("fr":"CA":_)        = "canadien"
-toBabel ("fra":"aca":_)      = "acadian"
-toBabel ("grc":_)            = "polutonikogreek"
-toBabel ("hsb":_)            = "uppersorbian"
+toBabel ("de":"1901":_)        = "german"
+toBabel ("de":"AT":"1901":_)   = "austrian"
+toBabel ("de":"AT":_)          = "naustrian"
+toBabel ("de":"CH":"1901":_)   = "swissgerman"
+toBabel ("de":"CH":_)          = "nswissgerman"
+toBabel ("de":_)               = "ngerman"
+toBabel ("dsb":_)              = "lowersorbian"
+toBabel ("el":"polyton":_)     = "polutonikogreek"
+toBabel ("en":"AU":_)          = "australian"
+toBabel ("en":"CA":_)          = "canadian"
+toBabel ("en":"GB":_)          = "british"
+toBabel ("en":"NZ":_)          = "newzealand"
+toBabel ("en":"UK":_)          = "british"
+toBabel ("en":"US":_)          = "american"
+toBabel ("fr":"CA":_)          = "canadien"
+toBabel ("fra":"aca":_)        = "acadian"
+toBabel ("grc":_)              = "polutonikogreek"
+toBabel ("hsb":_)              = "uppersorbian"
 toBabel ("la":"x":"classic":_) = "classiclatin"
-toBabel ("sl":_)             = "slovene"
-toBabel x                    = commonFromBcp47 x
+toBabel ("sl":_)               = "slovene"
+toBabel x                      = commonFromBcp47 x
 
 -- Takes a list of the constituents of a BCP 47 language code
 -- and converts it to a string shared by Babel and Polyglossia.
diff --git a/src/Text/Pandoc/Writers/Man.hs b/src/Text/Pandoc/Writers/Man.hs
index 9b46796af..6d7a4f84b 100644
--- a/src/Text/Pandoc/Writers/Man.hs
+++ b/src/Text/Pandoc/Writers/Man.hs
@@ -29,25 +29,25 @@ Conversion of 'Pandoc' documents to groff man page format.
 
 -}
 module Text.Pandoc.Writers.Man ( writeMan) where
-import Text.Pandoc.Definition
-import Text.Pandoc.Templates
-import Text.Pandoc.Shared
-import Text.Pandoc.Writers.Shared
-import Text.Pandoc.Options
-import Text.Pandoc.Writers.Math
-import Text.Printf ( printf )
-import Data.List ( stripPrefix, intersperse, intercalate )
+import Control.Monad.Except (throwError)
+import Control.Monad.State
+import Data.List (intercalate, intersperse, stripPrefix)
 import Data.Maybe (fromMaybe)
-import Text.Pandoc.Pretty
 import Text.Pandoc.Builder (deleteMeta)
-import Control.Monad.State
-import Text.Pandoc.Error
-import Control.Monad.Except (throwError)
 import Text.Pandoc.Class (PandocMonad, report)
+import Text.Pandoc.Definition
+import Text.Pandoc.Error
 import Text.Pandoc.Logging
+import Text.Pandoc.Options
+import Text.Pandoc.Pretty
+import Text.Pandoc.Shared
+import Text.Pandoc.Templates
+import Text.Pandoc.Writers.Math
+import Text.Pandoc.Writers.Shared
+import Text.Printf (printf)
 
 type Notes = [[Block]]
-data WriterState = WriterState { stNotes  :: Notes
+data WriterState = WriterState { stNotes     :: Notes
                                , stHasTables :: Bool }
 
 -- | Convert Pandoc to Man.
@@ -131,7 +131,7 @@ escapeCode = concat . intersperse "\n" . map escapeLine . lines  where
   escapeLine codeline =
     case escapeStringUsing (manEscapes ++ backslashEscapes "\t ") codeline of
       a@('.':_) -> "\\&" ++ a
-      b       -> b
+      b         -> b
 
 -- We split inline lists into sentences, and print one sentence per
 -- line.  groff/troff treats the line-ending period differently.
@@ -143,8 +143,8 @@ breakSentence [] = ([],[])
 breakSentence xs =
   let isSentenceEndInline (Str ys@(_:_)) | last ys == '.' = True
       isSentenceEndInline (Str ys@(_:_)) | last ys == '?' = True
-      isSentenceEndInline (LineBreak) = True
-      isSentenceEndInline _         = False
+      isSentenceEndInline (LineBreak)    = True
+      isSentenceEndInline _              = False
       (as, bs) = break isSentenceEndInline xs
   in  case bs of
            []             -> (as, [])
diff --git a/src/Text/Pandoc/Writers/Markdown.hs b/src/Text/Pandoc/Writers/Markdown.hs
index e3b400780..e5b3b5001 100644
--- a/src/Text/Pandoc/Writers/Markdown.hs
+++ b/src/Text/Pandoc/Writers/Markdown.hs
@@ -1,4 +1,7 @@
-{-# LANGUAGE OverloadedStrings, TupleSections, ScopedTypeVariables, MultiWayIf #-}
+{-# LANGUAGE MultiWayIf          #-}
+{-# LANGUAGE OverloadedStrings   #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TupleSections       #-}
 {-
 Copyright (C) 2006-2015 John MacFarlane <jgm@berkeley.edu>
 
@@ -31,36 +34,36 @@ Conversion of 'Pandoc' documents to markdown-formatted plain text.
 Markdown:  <http://daringfireball.net/projects/markdown/>
 -}
 module Text.Pandoc.Writers.Markdown (writeMarkdown, writePlain) where
-import Text.Pandoc.Definition
-import Text.Pandoc.Walk
-import Text.Pandoc.Templates (renderTemplate')
-import Text.Pandoc.Shared
-import Text.Pandoc.Writers.Shared
-import Text.Pandoc.Options
-import Text.Pandoc.Parsing hiding (blankline, blanklines, char, space)
-import Data.Maybe (fromMaybe)
-import Data.Monoid (Any(..))
-import Data.List ( group, stripPrefix, find, intersperse, transpose, sortBy )
-import Data.Char ( isSpace, isPunctuation, ord, chr )
-import Data.Ord ( comparing )
-import Text.Pandoc.Pretty
+import Control.Monad.Except (throwError)
 import Control.Monad.Reader
 import Control.Monad.State
-import Control.Monad.Except (throwError)
-import Text.Pandoc.Writers.HTML (writeHtml5String)
-import Text.Pandoc.Writers.Math (texMathToInlines)
-import Text.HTML.TagSoup (parseTags, isTagText, Tag(..))
-import Network.URI (isURI)
+import Data.Char (chr, isPunctuation, isSpace, ord)
 import Data.Default
-import Data.Yaml (Value(Object,String,Array,Bool,Number))
 import qualified Data.HashMap.Strict as H
-import qualified Data.Vector as V
-import qualified Data.Text as T
+import Data.List (find, group, intersperse, sortBy, stripPrefix, transpose)
+import Data.Maybe (fromMaybe)
+import Data.Monoid (Any (..))
+import Data.Ord (comparing)
 import qualified Data.Set as Set
-import Network.HTTP ( urlEncode )
-import Text.Pandoc.Error
+import qualified Data.Text as T
+import qualified Data.Vector as V
+import Data.Yaml (Value (Array, Bool, Number, Object, String))
+import Network.HTTP (urlEncode)
+import Network.URI (isURI)
+import Text.HTML.TagSoup (Tag (..), isTagText, parseTags)
 import Text.Pandoc.Class (PandocMonad, report)
+import Text.Pandoc.Definition
+import Text.Pandoc.Error
 import Text.Pandoc.Logging
+import Text.Pandoc.Options
+import Text.Pandoc.Parsing hiding (blankline, blanklines, char, space)
+import Text.Pandoc.Pretty
+import Text.Pandoc.Shared
+import Text.Pandoc.Templates (renderTemplate')
+import Text.Pandoc.Walk
+import Text.Pandoc.Writers.HTML (writeHtml5String)
+import Text.Pandoc.Writers.Math (texMathToInlines)
+import Text.Pandoc.Writers.Shared
 
 type Notes = [[Block]]
 type Ref   = ([Inline], Target, Attr)
@@ -71,11 +74,11 @@ type MD m = ReaderT WriterEnv (StateT WriterState m)
 evalMD :: PandocMonad m => MD m a -> WriterEnv -> WriterState -> m a
 evalMD md env st = evalStateT (runReaderT md env) st
 
-data WriterEnv = WriterEnv { envInList         :: Bool
-                           , envPlain          :: Bool
+data WriterEnv = WriterEnv { envInList          :: Bool
+                           , envPlain           :: Bool
                            , envRefShortcutable :: Bool
                            , envBlockLevel      :: Int
-                           , envEscapeSpaces   :: Bool
+                           , envEscapeSpaces    :: Bool
                            }
 
 instance Default WriterEnv
@@ -86,9 +89,9 @@ instance Default WriterEnv
                         , envEscapeSpaces    = False
                         }
 
-data WriterState = WriterState { stNotes :: Notes
-                               , stRefs  :: Refs
-                               , stIds   :: Set.Set String
+data WriterState = WriterState { stNotes   :: Notes
+                               , stRefs    :: Refs
+                               , stIds     :: Set.Set String
                                , stNoteNum :: Int
                                }
 
@@ -206,7 +209,7 @@ pandocToMarkdown opts (Pandoc meta blocks) = do
   let blocks' = if isEnabled Ext_citations opts
                    then case reverse blocks of
                              (Div (_,["references"],_) _):xs -> reverse xs
-                             _ -> blocks
+                             _                               -> blocks
                    else blocks
   body <- blockListToMarkdown opts blocks'
   notesAndRefs' <- notesAndRefs opts
@@ -260,7 +263,7 @@ noteToMarkdown opts num blocks = do
   let markerSize = 4 + offset num'
   let spacer = case writerTabStop opts - markerSize of
                      n | n > 0  -> text $ replicate n ' '
-                     _          -> text " "
+                     _ -> text " "
   return $ if isEnabled Ext_footnotes opts
               then hang (writerTabStop opts) (marker <> spacer) contents
               else marker <> spacer <> contents
@@ -282,11 +285,11 @@ escapeString opts (c:cs) =
        '-' | isEnabled Ext_smart opts ->
               case cs of
                    '-':_ -> '\\':'-':escapeString opts cs
-                   _ -> '-':escapeString opts cs
+                   _     -> '-':escapeString opts cs
        '.' | isEnabled Ext_smart opts ->
               case cs of
                    '.':'.':rest -> '\\':'.':'.':'.':escapeString opts rest
-                   _ -> '.':escapeString opts cs
+                   _            -> '.':escapeString opts cs
        _ -> c : escapeString opts cs
 
 -- | Construct table of contents from list of header blocks.
@@ -342,8 +345,8 @@ olMarker = do (start, style', delim) <- anyOrderedListMarker
 beginsWithOrderedListMarker :: String -> Bool
 beginsWithOrderedListMarker str =
   case runParser olMarker defaultParserState "para start" (take 10 str) of
-         Left  _  -> False
-         Right _  -> True
+         Left  _ -> False
+         Right _ -> True
 
 notesAndRefs :: PandocMonad m => WriterOptions -> MD m Doc
 notesAndRefs opts = do
@@ -727,7 +730,7 @@ itemEndsWithTightList bs =
   case bs of
         [Plain _, BulletList xs]    -> isTightList xs
         [Plain _, OrderedList _ xs] -> isTightList xs
-        _ -> False
+        _                           -> False
 
 -- | Convert bullet list item (list of blocks) to markdown.
 bulletListItemToMarkdown :: PandocMonad m => WriterOptions -> [Block] -> MD m Doc
@@ -751,7 +754,7 @@ orderedListItemToMarkdown opts marker bs = do
   contents <- blockListToMarkdown opts bs
   let sps = case length marker - writerTabStop opts of
                    n | n > 0 -> text $ replicate n ' '
-                   _         -> text " "
+                   _ -> text " "
   let start = text marker <> sps
   -- remove trailing blank line if item ends with a tight list
   let contents' = if itemEndsWithTightList bs
@@ -774,7 +777,7 @@ definitionListItemToMarkdown opts (label, defs) = do
        let leader  = if isPlain then "   " else ":  "
        let sps = case writerTabStop opts - 3 of
                       n | n > 0   -> text $ replicate n ' '
-                      _           -> text " "
+                      _ -> text " "
        if isEnabled Ext_compact_definition_lists opts
           then do
             let contents = vcat $ map (\d -> hang tabStop (leader <> sps)
@@ -785,7 +788,7 @@ definitionListItemToMarkdown opts (label, defs) = do
                                 $ vcat d <> cr) defs'
             let isTight = case defs of
                                ((Plain _ : _): _) -> True
-                               _ -> False
+                               _                  -> False
             return $ blankline <> nowrap labelText <>
                      (if isTight then cr else blankline) <> contents <> blankline
      else do
@@ -849,20 +852,20 @@ inlineListToMarkdown opts lst = do
         go (i:is) = case i of
             (Link _ _ _) -> case is of
                 -- If a link is followed by another link or '[' we don't shortcut
-                (Link _ _ _):_                -> unshortcutable
-                Space:(Link _ _ _):_          -> unshortcutable
-                Space:(Str('[':_)):_          -> unshortcutable
-                Space:(RawInline _ ('[':_)):_ -> unshortcutable
-                Space:(Cite _ _):_            -> unshortcutable
-                SoftBreak:(Link _ _ _):_      -> unshortcutable
-                SoftBreak:(Str('[':_)):_      -> unshortcutable
+                (Link _ _ _):_                    -> unshortcutable
+                Space:(Link _ _ _):_              -> unshortcutable
+                Space:(Str('[':_)):_              -> unshortcutable
+                Space:(RawInline _ ('[':_)):_     -> unshortcutable
+                Space:(Cite _ _):_                -> unshortcutable
+                SoftBreak:(Link _ _ _):_          -> unshortcutable
+                SoftBreak:(Str('[':_)):_          -> unshortcutable
                 SoftBreak:(RawInline _ ('[':_)):_ -> unshortcutable
-                SoftBreak:(Cite _ _):_        -> unshortcutable
-                (Cite _ _):_                  -> unshortcutable
-                Str ('[':_):_                 -> unshortcutable
-                (RawInline _ ('[':_)):_       -> unshortcutable
-                (RawInline _ (' ':'[':_)):_   -> unshortcutable
-                _                             -> shortcutable
+                SoftBreak:(Cite _ _):_            -> unshortcutable
+                (Cite _ _):_                      -> unshortcutable
+                Str ('[':_):_                     -> unshortcutable
+                (RawInline _ ('[':_)):_           -> unshortcutable
+                (RawInline _ (' ':'[':_)):_       -> unshortcutable
+                _                                 -> shortcutable
             _ -> shortcutable
           where shortcutable = liftM2 (<>) (inlineToMarkdown opts i) (go is)
                 unshortcutable = do
@@ -872,9 +875,9 @@ inlineListToMarkdown opts lst = do
                     fmap (iMark <>) (go is)
 
 isSp :: Inline -> Bool
-isSp Space = True
+isSp Space     = True
 isSp SoftBreak = True
-isSp _ = False
+isSp _         = False
 
 avoidBadWrapsInList :: [Inline] -> [Inline]
 avoidBadWrapsInList [] = []
@@ -1109,7 +1112,7 @@ inlineToMarkdown opts lnk@(Link attr txt (src, tit))
   let useAuto = isURI src &&
                 case txt of
                       [Str s] | escapeURI s == srcSuffix -> True
-                      _                                  -> False
+                      _       -> False
   let useRefLinks = writerReferenceLinks opts && not useAuto
   shortcutable <- asks envRefShortcutable
   let useShortcutRefLinks = shortcutable &&
@@ -1160,5 +1163,5 @@ makeMathPlainer :: [Inline] -> [Inline]
 makeMathPlainer = walk go
   where
   go (Emph xs) = Span nullAttr xs
-  go x = x
+  go x         = x
 
diff --git a/src/Text/Pandoc/Writers/Math.hs b/src/Text/Pandoc/Writers/Math.hs
index b7419ddf9..104d3c20b 100644
--- a/src/Text/Pandoc/Writers/Math.hs
+++ b/src/Text/Pandoc/Writers/Math.hs
@@ -7,7 +7,7 @@ where
 import Text.Pandoc.Class
 import Text.Pandoc.Definition
 import Text.Pandoc.Logging
-import Text.TeXMath (Exp, writePandoc, DisplayType(..), readTeX)
+import Text.TeXMath (DisplayType (..), Exp, readTeX, writePandoc)
 
 -- | Converts a raw TeX math formula to a list of 'Pandoc' inlines.
 -- Defaults to raw formula between @$@ or @$$@ characters if entire formula
diff --git a/src/Text/Pandoc/Writers/MediaWiki.hs b/src/Text/Pandoc/Writers/MediaWiki.hs
index 22f56d4a8..cb36df5f5 100644
--- a/src/Text/Pandoc/Writers/MediaWiki.hs
+++ b/src/Text/Pandoc/Writers/MediaWiki.hs
@@ -30,30 +30,30 @@ Conversion of 'Pandoc' documents to MediaWiki markup.
 MediaWiki:  <http://www.mediawiki.org/wiki/MediaWiki>
 -}
 module Text.Pandoc.Writers.MediaWiki ( writeMediaWiki ) where
+import Control.Monad.Reader
+import Control.Monad.State
+import Data.List (intercalate)
+import qualified Data.Set as Set
+import Network.URI (isURI)
+import Text.Pandoc.Class (PandocMonad)
 import Text.Pandoc.Definition
+import Text.Pandoc.ImageSize
 import Text.Pandoc.Options
-import Text.Pandoc.Shared
-import Text.Pandoc.Writers.Shared
 import Text.Pandoc.Pretty (render)
-import Text.Pandoc.ImageSize
+import Text.Pandoc.Shared
 import Text.Pandoc.Templates (renderTemplate')
-import Text.Pandoc.XML ( escapeStringForXML )
-import Data.List ( intercalate )
-import qualified Data.Set as Set
-import Network.URI ( isURI )
-import Control.Monad.Reader
-import Control.Monad.State
-import Text.Pandoc.Class (PandocMonad)
+import Text.Pandoc.Writers.Shared
+import Text.Pandoc.XML (escapeStringForXML)
 
 data WriterState = WriterState {
-    stNotes     :: Bool            -- True if there are notes
-  , stOptions   :: WriterOptions   -- writer options
+    stNotes   :: Bool            -- True if there are notes
+  , stOptions :: WriterOptions   -- writer options
   }
 
 data WriterReader = WriterReader {
-    options     :: WriterOptions -- Writer options
-  , listLevel   :: String        -- String at beginning of list items, e.g. "**"
-  , useTags     :: Bool          -- True if we should use HTML tags because we're in a complex list
+    options   :: WriterOptions -- Writer options
+  , listLevel :: String        -- String at beginning of list items, e.g. "**"
+  , useTags   :: Bool          -- True if we should use HTML tags because we're in a complex list
   }
 
 type MediaWikiWriter = ReaderT WriterReader (State WriterState)
@@ -253,18 +253,18 @@ isSimpleListItem :: [Block] -> Bool
 isSimpleListItem []  = True
 isSimpleListItem [x] =
   case x of
-       Plain _           -> True
-       Para  _           -> True
-       BulletList _      -> isSimpleList x
-       OrderedList _ _   -> isSimpleList x
-       DefinitionList _  -> isSimpleList x
-       _                 -> False
+       Plain _          -> True
+       Para  _          -> True
+       BulletList _     -> isSimpleList x
+       OrderedList _ _  -> isSimpleList x
+       DefinitionList _ -> isSimpleList x
+       _                -> False
 isSimpleListItem [x, y] | isPlainOrPara x =
   case y of
-       BulletList _      -> isSimpleList y
-       OrderedList _ _   -> isSimpleList y
-       DefinitionList _  -> isSimpleList y
-       _                 -> False
+       BulletList _     -> isSimpleList y
+       OrderedList _ _  -> isSimpleList y
+       DefinitionList _ -> isSimpleList y
+       _                -> False
 isSimpleListItem _ = False
 
 isPlainOrPara :: Block -> Bool
@@ -322,7 +322,7 @@ imageToMediaWiki attr = do
   let (_, cls, _) = attr
       toPx = fmap (showInPixel opts) . checkPct
       checkPct (Just (Percent _)) = Nothing
-      checkPct maybeDim = maybeDim
+      checkPct maybeDim           = maybeDim
       go (Just w) Nothing  = '|':w ++ "px"
       go (Just w) (Just h) = '|':w ++ "x" ++ h ++ "px"
       go Nothing  (Just h) = "|x" ++ h ++ "px"
diff --git a/src/Text/Pandoc/Writers/Native.hs b/src/Text/Pandoc/Writers/Native.hs
index 2421fd94d..b031a0231 100644
--- a/src/Text/Pandoc/Writers/Native.hs
+++ b/src/Text/Pandoc/Writers/Native.hs
@@ -30,11 +30,11 @@ Conversion of a 'Pandoc' document to a string representation.
 -}
 module Text.Pandoc.Writers.Native ( writeNative )
 where
-import Text.Pandoc.Options ( WriterOptions(..), WrapOption(..) )
-import Data.List ( intersperse )
+import Data.List (intersperse)
+import Text.Pandoc.Class (PandocMonad)
 import Text.Pandoc.Definition
+import Text.Pandoc.Options (WrapOption (..), WriterOptions (..))
 import Text.Pandoc.Pretty
-import Text.Pandoc.Class (PandocMonad)
 
 prettyList :: [Doc] -> Doc
 prettyList ds =
diff --git a/src/Text/Pandoc/Writers/ODT.hs b/src/Text/Pandoc/Writers/ODT.hs
index b37739435..395ef0a96 100644
--- a/src/Text/Pandoc/Writers/ODT.hs
+++ b/src/Text/Pandoc/Writers/ODT.hs
@@ -29,30 +29,30 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Conversion of 'Pandoc' documents to ODT.
 -}
 module Text.Pandoc.Writers.ODT ( writeODT ) where
-import Data.List ( isPrefixOf )
-import Data.Maybe ( fromMaybe )
-import Text.XML.Light.Output
-import Text.TeXMath
-import qualified Data.ByteString.Lazy as B
-import Text.Pandoc.UTF8 ( fromStringLazy )
 import Codec.Archive.Zip
-import Text.Pandoc.Options ( WriterOptions(..), WrapOption(..) )
-import Text.Pandoc.Shared ( stringify )
-import Text.Pandoc.ImageSize
-import Text.Pandoc.MIME ( getMimeType, extensionFromMimeType )
-import Text.Pandoc.Definition
-import Text.Pandoc.Walk
-import Text.Pandoc.Writers.Shared ( fixDisplayMath )
-import Text.Pandoc.Writers.OpenDocument ( writeOpenDocument )
-import Control.Monad.State
 import Control.Monad.Except (catchError)
-import Text.Pandoc.Error (PandocError(..))
-import Text.Pandoc.XML
-import Text.Pandoc.Pretty
-import System.FilePath ( takeExtension, takeDirectory, (<.>))
-import Text.Pandoc.Class ( PandocMonad, report )
+import Control.Monad.State
+import qualified Data.ByteString.Lazy as B
+import Data.List (isPrefixOf)
+import Data.Maybe (fromMaybe)
+import System.FilePath (takeDirectory, takeExtension, (<.>))
+import Text.Pandoc.Class (PandocMonad, report)
 import qualified Text.Pandoc.Class as P
+import Text.Pandoc.Definition
+import Text.Pandoc.Error (PandocError (..))
+import Text.Pandoc.ImageSize
 import Text.Pandoc.Logging
+import Text.Pandoc.MIME (extensionFromMimeType, getMimeType)
+import Text.Pandoc.Options (WrapOption (..), WriterOptions (..))
+import Text.Pandoc.Pretty
+import Text.Pandoc.Shared (stringify)
+import Text.Pandoc.UTF8 (fromStringLazy)
+import Text.Pandoc.Walk
+import Text.Pandoc.Writers.OpenDocument (writeOpenDocument)
+import Text.Pandoc.Writers.Shared (fixDisplayMath)
+import Text.Pandoc.XML
+import Text.TeXMath
+import Text.XML.Light.Output
 
 data ODTState = ODTState { stEntries :: [Entry]
                          }
diff --git a/src/Text/Pandoc/Writers/OPML.hs b/src/Text/Pandoc/Writers/OPML.hs
index bc0cfc300..98510c40f 100644
--- a/src/Text/Pandoc/Writers/OPML.hs
+++ b/src/Text/Pandoc/Writers/OPML.hs
@@ -29,20 +29,20 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Conversion of 'Pandoc' documents to OPML XML.
 -}
 module Text.Pandoc.Writers.OPML ( writeOPML) where
+import Control.Monad.Except (throwError)
+import qualified Text.Pandoc.Builder as B
+import Text.Pandoc.Class (PandocMonad)
+import Text.Pandoc.Compat.Time
 import Text.Pandoc.Definition
-import Text.Pandoc.XML
-import Text.Pandoc.Writers.Shared
-import Text.Pandoc.Shared
+import Text.Pandoc.Error
 import Text.Pandoc.Options
+import Text.Pandoc.Pretty
+import Text.Pandoc.Shared
 import Text.Pandoc.Templates (renderTemplate')
 import Text.Pandoc.Writers.HTML (writeHtml5String)
 import Text.Pandoc.Writers.Markdown (writeMarkdown)
-import Text.Pandoc.Pretty
-import Text.Pandoc.Compat.Time
-import qualified Text.Pandoc.Builder as B
-import Text.Pandoc.Error
-import Control.Monad.Except (throwError)
-import Text.Pandoc.Class (PandocMonad)
+import Text.Pandoc.Writers.Shared
+import Text.Pandoc.XML
 
 -- | Convert Pandoc document to string in OPML format.
 writeOPML :: PandocMonad m => WriterOptions -> Pandoc -> m String
@@ -86,7 +86,7 @@ elementToOPML _ (Blk _) = return empty
 elementToOPML opts (Sec _ _num _ title elements) = do
   let isBlk :: Element -> Bool
       isBlk (Blk _) = True
-      isBlk _     = False
+      isBlk _       = False
 
       fromBlk :: PandocMonad m => Element -> m Block
       fromBlk (Blk x) = return x
diff --git a/src/Text/Pandoc/Writers/OpenDocument.hs b/src/Text/Pandoc/Writers/OpenDocument.hs
index 865faf37c..961bb981a 100644
--- a/src/Text/Pandoc/Writers/OpenDocument.hs
+++ b/src/Text/Pandoc/Writers/OpenDocument.hs
@@ -1,4 +1,6 @@
-{-# LANGUAGE PatternGuards, OverloadedStrings, FlexibleContexts #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PatternGuards     #-}
 {-
 Copyright (C) 2008-2015 Andrea Rossato <andrea.rossato@ing.unitn.it>
                         and John MacFarlane.
@@ -30,29 +32,29 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Conversion of 'Pandoc' documents to OpenDocument XML.
 -}
 module Text.Pandoc.Writers.OpenDocument ( writeOpenDocument ) where
+import Control.Arrow ((***), (>>>))
+import Control.Monad.State hiding (when)
+import Data.Char (chr)
+import Data.List (sortBy)
+import qualified Data.Map as Map
+import Data.Ord (comparing)
+import qualified Data.Set as Set
+import Text.Pandoc.Class (PandocMonad, report)
 import Text.Pandoc.Definition
+import Text.Pandoc.Logging
 import Text.Pandoc.Options
-import Text.Pandoc.XML
+import Text.Pandoc.Pretty
 import Text.Pandoc.Shared (linesToPara)
 import Text.Pandoc.Templates (renderTemplate')
 import Text.Pandoc.Writers.Math
-import Text.Pandoc.Pretty
-import Text.Printf ( printf )
-import Control.Arrow ( (***), (>>>) )
-import Control.Monad.State hiding ( when )
-import Data.Char (chr)
-import qualified Data.Set as Set
-import qualified Data.Map as Map
 import Text.Pandoc.Writers.Shared
-import Data.List (sortBy)
-import Data.Ord (comparing)
-import Text.Pandoc.Class (PandocMonad, report)
-import Text.Pandoc.Logging
+import Text.Pandoc.XML
+import Text.Printf (printf)
 
 -- | Auxiliary function to convert Plain block to Para.
 plainToPara :: Block -> Block
 plainToPara (Plain x) = Para x
-plainToPara x = x
+plainToPara x         = x
 
 --
 -- OpenDocument writer
@@ -426,10 +428,10 @@ toChunks o (x : xs)
   where (ys, zs) = span isChunkable xs
 
 isChunkable :: Inline -> Bool
-isChunkable (Str _) = True
-isChunkable Space   = True
+isChunkable (Str _)   = True
+isChunkable Space     = True
 isChunkable SoftBreak = True
-isChunkable _ = False
+isChunkable _         = False
 
 -- | Convert an inline element to OpenDocument.
 inlineToOpenDocument :: PandocMonad m => WriterOptions -> Inline -> OD m Doc
@@ -514,11 +516,11 @@ orderedListLevelStyle (s,n, d) (l,ls) =
                                    ,("style:num-suffix", ")")]
                       _         -> [("style:num-suffix", ".")]
         format    = case n of
-                      UpperAlpha   -> "A"
-                      LowerAlpha   -> "a"
-                      UpperRoman   -> "I"
-                      LowerRoman   -> "i"
-                      _            -> "1"
+                      UpperAlpha -> "A"
+                      LowerAlpha -> "a"
+                      UpperRoman -> "I"
+                      LowerRoman -> "i"
+                      _          -> "1"
         listStyle = inTags True "text:list-level-style-number"
                     ([ ("text:level"      , show $ 1 + length ls  )
                      , ("text:style-name" , "Numbering_20_Symbols")
diff --git a/src/Text/Pandoc/Writers/Org.hs b/src/Text/Pandoc/Writers/Org.hs
index 848b273c3..50eeec09a 100644
--- a/src/Text/Pandoc/Writers/Org.hs
+++ b/src/Text/Pandoc/Writers/Org.hs
@@ -33,21 +33,21 @@ Conversion of 'Pandoc' documents to Emacs Org-Mode.
 Org-Mode:  <http://orgmode.org>
 -}
 module Text.Pandoc.Writers.Org ( writeOrg) where
+import Control.Monad.State
+import Data.Char (isAlphaNum, toLower)
+import Data.List (intersect, intersperse, isPrefixOf, partition, transpose)
+import Text.Pandoc.Class (PandocMonad)
 import Text.Pandoc.Definition
 import Text.Pandoc.Options
-import Text.Pandoc.Shared
-import Text.Pandoc.Writers.Shared
 import Text.Pandoc.Pretty
+import Text.Pandoc.Shared
 import Text.Pandoc.Templates (renderTemplate')
-import Data.Char ( isAlphaNum, toLower )
-import Data.List ( isPrefixOf, intersect, intersperse, partition, transpose )
-import Control.Monad.State
-import Text.Pandoc.Class (PandocMonad)
+import Text.Pandoc.Writers.Shared
 
 data WriterState =
-  WriterState { stNotes     :: [[Block]]
-              , stHasMath   :: Bool
-              , stOptions   :: WriterOptions
+  WriterState { stNotes   :: [[Block]]
+              , stHasMath :: Bool
+              , stOptions :: WriterOptions
               }
 
 -- | Convert Pandoc to Org.
@@ -352,9 +352,9 @@ inlineToOrg Space = return space
 inlineToOrg SoftBreak = do
   wrapText <- gets (writerWrapText . stOptions)
   case wrapText of
-       WrapPreserve   -> return cr
-       WrapAuto       -> return space
-       WrapNone       -> return space
+       WrapPreserve -> return cr
+       WrapAuto     -> return space
+       WrapNone     -> return space
 inlineToOrg (Link _ txt (src, _)) = do
   case txt of
         [Str x] | escapeURI x == src ->  -- autolink
@@ -373,11 +373,11 @@ inlineToOrg (Note contents) = do
 orgPath :: String -> String
 orgPath src =
   case src of
-    []                 -> mempty         -- wiki link
-    ('#':_)            -> src            -- internal link
-    _ | isUrl src      -> src
-    _ | isFilePath src -> src
-    _                  -> "file:" <> src
+    []      -> mempty         -- wiki link
+    ('#':_) -> src            -- internal link
+    _       | isUrl src      -> src
+    _       | isFilePath src -> src
+    _       -> "file:" <> src
  where
    isFilePath :: String -> Bool
    isFilePath cs = any (`isPrefixOf` cs) ["/", "./", "../", "file:"]
diff --git a/src/Text/Pandoc/Writers/RST.hs b/src/Text/Pandoc/Writers/RST.hs
index 745ab7ce9..f1de2ab0e 100644
--- a/src/Text/Pandoc/Writers/RST.hs
+++ b/src/Text/Pandoc/Writers/RST.hs
@@ -31,20 +31,20 @@ Conversion of 'Pandoc' documents to reStructuredText.
 reStructuredText:  <http://docutils.sourceforge.net/rst.html>
 -}
 module Text.Pandoc.Writers.RST ( writeRST ) where
+import Control.Monad.State
+import Data.Char (isSpace, toLower)
+import Data.List (intersperse, isPrefixOf, stripPrefix, transpose)
+import Data.Maybe (fromMaybe)
+import Network.URI (isURI)
+import Text.Pandoc.Builder (deleteMeta)
+import Text.Pandoc.Class (PandocMonad)
 import Text.Pandoc.Definition
+import Text.Pandoc.ImageSize
 import Text.Pandoc.Options
+import Text.Pandoc.Pretty
 import Text.Pandoc.Shared
-import Text.Pandoc.Writers.Shared
-import Text.Pandoc.ImageSize
 import Text.Pandoc.Templates (renderTemplate')
-import Text.Pandoc.Builder (deleteMeta)
-import Data.Maybe (fromMaybe)
-import Data.List ( isPrefixOf, stripPrefix, intersperse, transpose )
-import Network.URI (isURI)
-import Text.Pandoc.Pretty
-import Control.Monad.State
-import Data.Char (isSpace, toLower)
-import Text.Pandoc.Class (PandocMonad)
+import Text.Pandoc.Writers.Shared
 
 type Refs = [([Inline], Target)]
 
@@ -76,7 +76,7 @@ pandocToRST (Pandoc meta blocks) = do
                     else Nothing
   let subtit = case lookupMeta "subtitle" meta of
                     Just (MetaBlocks [Plain xs]) -> xs
-                    _ -> []
+                    _                            -> []
   title <- titleToRST (docTitle meta) subtit
   metadata <- metaToJSON opts
                 (fmap (render colwidth) . blockListToRST)
@@ -108,7 +108,7 @@ pandocToRST (Pandoc meta blocks) = do
       Header lev a i:normalizeHeadings (lev+1) cont ++ normalizeHeadings lev bs'
       where (cont,bs') = break (headerLtEq l) bs
             headerLtEq level (Header l' _ _) = l' <= level
-            headerLtEq _ _ = False
+            headerLtEq _ _                   = False
     normalizeHeadings lev (b:bs) = b:normalizeHeadings lev bs
     normalizeHeadings _   []     = []
 
@@ -171,11 +171,11 @@ escapeString opts (c:cs) =
        '-' | isEnabled Ext_smart opts ->
               case cs of
                    '-':_ -> '\\':'-':escapeString opts cs
-                   _ -> '-':escapeString opts cs
+                   _     -> '-':escapeString opts cs
        '.' | isEnabled Ext_smart opts ->
               case cs of
                    '.':'.':rest -> '\\':'.':'.':'.':escapeString opts rest
-                   _ -> '.':escapeString opts cs
+                   _            -> '.':escapeString opts cs
        _ -> c : escapeString opts cs
 
 titleToRST :: [Inline] -> [Inline] -> State WriterState Doc
@@ -412,19 +412,19 @@ inlineListToRST lst =
         okBeforeComplex (Str (c:_)) = isSpace c || c `elem` ("-:/'\"<([{–—" :: String)
         okBeforeComplex _ = False
         isComplex :: Inline -> Bool
-        isComplex (Emph _) = True
-        isComplex (Strong _) = True
-        isComplex (SmallCaps _) = True
-        isComplex (Strikeout _) = True
+        isComplex (Emph _)        = True
+        isComplex (Strong _)      = True
+        isComplex (SmallCaps _)   = True
+        isComplex (Strikeout _)   = True
         isComplex (Superscript _) = True
-        isComplex (Subscript _) = True
-        isComplex (Link _ _ _) = True
-        isComplex (Image _ _ _) = True
-        isComplex (Code _ _) = True
-        isComplex (Math _ _) = True
-        isComplex (Cite _ (x:_)) = isComplex x
-        isComplex (Span _ (x:_)) = isComplex x
-        isComplex _ = False
+        isComplex (Subscript _)   = True
+        isComplex (Link _ _ _)    = True
+        isComplex (Image _ _ _)   = True
+        isComplex (Code _ _)      = True
+        isComplex (Math _ _)      = True
+        isComplex (Cite _ (x:_))  = isComplex x
+        isComplex (Span _ (x:_))  = isComplex x
+        isComplex _               = False
 
 -- | Convert Pandoc inline element to RST.
 inlineToRST :: Inline -> State WriterState Doc
@@ -485,9 +485,9 @@ inlineToRST Space = return space
 inlineToRST SoftBreak = do
   wrapText <- gets $ writerWrapText . stOptions
   case wrapText of
-        WrapPreserve  -> return cr
-        WrapAuto      -> return space
-        WrapNone      -> return space
+        WrapPreserve -> return cr
+        WrapAuto     -> return space
+        WrapNone     -> return space
 -- autolink
 inlineToRST (Link _ [Str str] (src, _))
   | isURI src &&
diff --git a/src/Text/Pandoc/Writers/RTF.hs b/src/Text/Pandoc/Writers/RTF.hs
index 56d72afcb..67f0fc2e0 100644
--- a/src/Text/Pandoc/Writers/RTF.hs
+++ b/src/Text/Pandoc/Writers/RTF.hs
@@ -30,24 +30,24 @@ Conversion of 'Pandoc' documents to RTF (rich text format).
 -}
 module Text.Pandoc.Writers.RTF ( writeRTF
                                ) where
+import Control.Monad.Except (catchError, throwError)
+import qualified Data.ByteString as B
+import Data.Char (chr, isDigit, ord)
+import Data.List (intercalate, isSuffixOf)
+import qualified Data.Map as M
+import Text.Pandoc.Class (PandocMonad, report)
+import qualified Text.Pandoc.Class as P
 import Text.Pandoc.Definition
+import Text.Pandoc.Error
+import Text.Pandoc.ImageSize
+import Text.Pandoc.Logging
 import Text.Pandoc.Options
 import Text.Pandoc.Shared
-import Text.Pandoc.Writers.Shared
-import Text.Pandoc.Writers.Math
 import Text.Pandoc.Templates (renderTemplate')
 import Text.Pandoc.Walk
-import Text.Pandoc.Logging
-import Data.List ( isSuffixOf, intercalate )
-import Data.Char ( ord, chr, isDigit )
-import qualified Data.ByteString as B
-import qualified Data.Map as M
-import Text.Printf ( printf )
-import Text.Pandoc.ImageSize
-import Control.Monad.Except (throwError, catchError)
-import Text.Pandoc.Error
-import Text.Pandoc.Class (PandocMonad, report)
-import qualified Text.Pandoc.Class as P
+import Text.Pandoc.Writers.Math
+import Text.Pandoc.Writers.Shared
+import Text.Printf (printf)
 
 -- | Convert Image inlines into a raw RTF embedded image, read from a file,
 -- or a MediaBag, or the internet.
@@ -106,7 +106,7 @@ writeRTF options doc = do
   Pandoc meta@(Meta metamap) blocks <- walkM (rtfEmbedImage options) doc
   let spacer = not $ all null $ docTitle meta : docDate meta : docAuthors meta
   let toPlain (MetaBlocks [Para ils]) = MetaInlines ils
-      toPlain x = x
+      toPlain x                       = x
   -- adjust title, author, date so we don't get para inside para
   let meta'  = Meta $ M.adjust toPlain "title"
                     . M.adjust toPlain "author"
@@ -118,7 +118,7 @@ writeRTF options doc = do
               meta'
   body <- blocksToRTF 0 AlignDefault blocks
   let isTOCHeader (Header lev _ _) = lev <= writerTOCDepth options
-      isTOCHeader _ = False
+      isTOCHeader _                = False
   toc <- tableOfContents $ filter isTOCHeader blocks
   let context = defField "body" body
               $ defField "spacer" spacer
@@ -193,9 +193,9 @@ rtfParSpaced :: Int       -- ^ space after (in twips)
              -> String
 rtfParSpaced spaceAfter indent firstLineIndent alignment content =
   let alignString = case alignment of
-                           AlignLeft -> "\\ql "
-                           AlignRight -> "\\qr "
-                           AlignCenter -> "\\qc "
+                           AlignLeft    -> "\\ql "
+                           AlignRight   -> "\\qr "
+                           AlignCenter  -> "\\qc "
                            AlignDefault -> "\\ql "
   in  "{\\pard " ++ alignString ++
       "\\f0 \\sa" ++ (show spaceAfter) ++ " \\li" ++ (show indent) ++
diff --git a/src/Text/Pandoc/Writers/Shared.hs b/src/Text/Pandoc/Writers/Shared.hs
index 3ff7d47b2..34bfa0b64 100644
--- a/src/Text/Pandoc/Writers/Shared.hs
+++ b/src/Text/Pandoc/Writers/Shared.hs
@@ -41,19 +41,20 @@ module Text.Pandoc.Writers.Shared (
                      , unsmartify
                      )
 where
-import Text.Pandoc.Definition
-import Text.Pandoc.Pretty
-import Text.Pandoc.Options
-import Text.Pandoc.XML (escapeStringForXML)
 import Control.Monad (liftM)
+import Data.Aeson (FromJSON (..), Result (..), ToJSON (..), Value (Object),
+                   encode, fromJSON)
 import qualified Data.HashMap.Strict as H
+import Data.List (groupBy)
 import qualified Data.Map as M
+import Data.Maybe (isJust)
 import qualified Data.Text as T
-import Data.Aeson (FromJSON(..), fromJSON, ToJSON (..), Value(Object), Result(..), encode)
-import Text.Pandoc.UTF8 (toStringLazy)
 import qualified Data.Traversable as Traversable
-import Data.List ( groupBy )
-import Data.Maybe ( isJust )
+import Text.Pandoc.Definition
+import Text.Pandoc.Options
+import Text.Pandoc.Pretty
+import Text.Pandoc.UTF8 (toStringLazy)
+import Text.Pandoc.XML (escapeStringForXML)
 
 -- | Create JSON value for template from a 'Meta' and an association list
 -- of variables, specified at the command line or in the writer.
@@ -94,7 +95,7 @@ addVariablesToJSON opts metadata =
        (writerVariables opts)
     `combineMetadata` metadata
   where combineMetadata (Object o1) (Object o2) = Object $ H.union o1 o2
-        combineMetadata x _           = x
+        combineMetadata x _                     = x
 
 metaValueToJSON :: Monad m
                 => ([Block] -> m String)
@@ -134,8 +135,8 @@ setField field val (Object hashmap) =
   Object $ H.insertWith combine (T.pack field) (toJSON val) hashmap
   where combine newval oldval =
           case fromJSON oldval of
-                Success xs  -> toJSON $ xs ++ [newval]
-                _           -> toJSON [oldval, newval]
+                Success xs -> toJSON $ xs ++ [newval]
+                _          -> toJSON [oldval, newval]
 setField _ _  x = x
 
 resetField :: ToJSON a
@@ -183,9 +184,9 @@ isDisplayMath _                    = False
 
 stripLeadingTrailingSpace :: [Inline] -> [Inline]
 stripLeadingTrailingSpace = go . reverse . go . reverse
-  where go (Space:xs) = xs
+  where go (Space:xs)     = xs
         go (SoftBreak:xs) = xs
-        go xs         = xs
+        go xs             = xs
 
 -- Put display math in its own block (for ODT/DOCX).
 fixDisplayMath :: Block -> Block
diff --git a/src/Text/Pandoc/Writers/TEI.hs b/src/Text/Pandoc/Writers/TEI.hs
index a54d42c53..0ef283ad3 100644
--- a/src/Text/Pandoc/Writers/TEI.hs
+++ b/src/Text/Pandoc/Writers/TEI.hs
@@ -1,4 +1,5 @@
-{-# LANGUAGE OverloadedStrings, PatternGuards #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PatternGuards     #-}
 {-
 Copyright (C) 2006-2015 John MacFarlane <jgm@berkeley.edu>
 
@@ -29,19 +30,19 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Conversion of 'Pandoc' documents to Docbook XML.
 -}
 module Text.Pandoc.Writers.TEI (writeTEI) where
+import Data.Char (toLower)
+import Data.List (isPrefixOf, stripPrefix)
+import qualified Text.Pandoc.Builder as B
+import Text.Pandoc.Class (PandocMonad)
 import Text.Pandoc.Definition
-import Text.Pandoc.XML
-import Text.Pandoc.Shared
-import Text.Pandoc.Writers.Shared
+import Text.Pandoc.Highlighting (languages, languagesByExtension)
+import Text.Pandoc.ImageSize
 import Text.Pandoc.Options
-import Text.Pandoc.Templates (renderTemplate')
-import Data.List ( stripPrefix, isPrefixOf )
-import Data.Char ( toLower )
-import Text.Pandoc.Highlighting ( languages, languagesByExtension )
 import Text.Pandoc.Pretty
-import Text.Pandoc.ImageSize
-import qualified Text.Pandoc.Builder as B
-import Text.Pandoc.Class ( PandocMonad )
+import Text.Pandoc.Shared
+import Text.Pandoc.Templates (renderTemplate')
+import Text.Pandoc.Writers.Shared
+import Text.Pandoc.XML
 
 -- | Convert list of authors to a docbook <author> section
 authorToTEI :: WriterOptions -> [Inline] -> B.Inlines
diff --git a/src/Text/Pandoc/Writers/Texinfo.hs b/src/Text/Pandoc/Writers/Texinfo.hs
index fe6024351..da4f43ee5 100644
--- a/src/Text/Pandoc/Writers/Texinfo.hs
+++ b/src/Text/Pandoc/Writers/Texinfo.hs
@@ -29,25 +29,25 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Conversion of 'Pandoc' format into Texinfo.
 -}
 module Text.Pandoc.Writers.Texinfo ( writeTexinfo ) where
-import Text.Pandoc.Definition
-import Text.Pandoc.Options
-import Text.Pandoc.Shared
-import Text.Pandoc.Writers.Shared
-import Text.Pandoc.Templates (renderTemplate')
-import Text.Printf ( printf )
-import Data.List ( transpose, maximumBy )
-import Data.Ord ( comparing )
-import Data.Char ( chr, ord )
+import Control.Monad.Except (throwError)
 import Control.Monad.State
-import Text.Pandoc.Pretty
-import Text.Pandoc.ImageSize
-import Network.URI ( isURI, unEscapeString )
-import System.FilePath
+import Data.Char (chr, ord)
+import Data.List (maximumBy, transpose)
+import Data.Ord (comparing)
 import qualified Data.Set as Set
-import Control.Monad.Except (throwError)
-import Text.Pandoc.Error
+import Network.URI (isURI, unEscapeString)
+import System.FilePath
 import Text.Pandoc.Class (PandocMonad, report)
+import Text.Pandoc.Definition
+import Text.Pandoc.Error
+import Text.Pandoc.ImageSize
 import Text.Pandoc.Logging
+import Text.Pandoc.Options
+import Text.Pandoc.Pretty
+import Text.Pandoc.Shared
+import Text.Pandoc.Templates (renderTemplate')
+import Text.Pandoc.Writers.Shared
+import Text.Printf (printf)
 
 data WriterState =
   WriterState { stStrikeout   :: Bool  -- document contains strikeout
diff --git a/src/Text/Pandoc/Writers/Textile.hs b/src/Text/Pandoc/Writers/Textile.hs
index 6ec9e0b2f..625e8031b 100644
--- a/src/Text/Pandoc/Writers/Textile.hs
+++ b/src/Text/Pandoc/Writers/Textile.hs
@@ -30,18 +30,18 @@ Conversion of 'Pandoc' documents to Textile markup.
 Textile:  <http://thresholdstate.com/articles/4312/the-textile-reference-manual>
 -}
 module Text.Pandoc.Writers.Textile ( writeTextile ) where
+import Control.Monad.State
+import Data.Char (isSpace)
+import Data.List (intercalate)
+import Text.Pandoc.Class (PandocMonad)
 import Text.Pandoc.Definition
+import Text.Pandoc.ImageSize
 import Text.Pandoc.Options
-import Text.Pandoc.Shared
 import Text.Pandoc.Pretty (render)
-import Text.Pandoc.ImageSize
-import Text.Pandoc.Writers.Shared
+import Text.Pandoc.Shared
 import Text.Pandoc.Templates (renderTemplate')
-import Text.Pandoc.XML ( escapeStringForXML )
-import Data.List ( intercalate )
-import Control.Monad.State
-import Data.Char ( isSpace )
-import Text.Pandoc.Class ( PandocMonad )
+import Text.Pandoc.Writers.Shared
+import Text.Pandoc.XML (escapeStringForXML)
 
 data WriterState = WriterState {
     stNotes     :: [String]        -- Footnotes
@@ -302,16 +302,16 @@ isSimpleListItem :: [Block] -> Bool
 isSimpleListItem []  = True
 isSimpleListItem [x] =
   case x of
-       Plain _           -> True
-       Para  _           -> True
-       BulletList _      -> isSimpleList x
-       OrderedList _ _   -> isSimpleList x
-       _                 -> False
+       Plain _         -> True
+       Para  _         -> True
+       BulletList _    -> isSimpleList x
+       OrderedList _ _ -> isSimpleList x
+       _               -> False
 isSimpleListItem [x, y] | isPlainOrPara x =
   case y of
-       BulletList _      -> isSimpleList y
-       OrderedList _ _   -> isSimpleList y
-       _                 -> False
+       BulletList _    -> isSimpleList y
+       OrderedList _ _ -> isSimpleList y
+       _               -> False
 isSimpleListItem _ = False
 
 isPlainOrPara :: Block -> Bool
@@ -334,9 +334,9 @@ tableRowToTextile :: WriterOptions
 tableRowToTextile opts alignStrings rownum cols' = do
   let celltype = if rownum == 0 then "th" else "td"
   let rowclass = case rownum of
-                      0                  -> "header"
+                      0 -> "header"
                       x | x `rem` 2 == 1 -> "odd"
-                      _                  -> "even"
+                      _ -> "even"
   cols'' <- sequence $ zipWith
             (\alignment item -> tableItemToTextile opts celltype alignment item)
             alignStrings cols'
diff --git a/src/Text/Pandoc/Writers/ZimWiki.hs b/src/Text/Pandoc/Writers/ZimWiki.hs
index a7d30fec6..19f476a17 100644
--- a/src/Text/Pandoc/Writers/ZimWiki.hs
+++ b/src/Text/Pandoc/Writers/ZimWiki.hs
@@ -31,27 +31,27 @@ http://zim-wiki.org/manual/Help/Wiki_Syntax.html
 -}
 
 module Text.Pandoc.Writers.ZimWiki ( writeZimWiki ) where
+import Control.Monad (zipWithM)
+import Control.Monad.State (State, evalState, gets, modify)
+import Data.Default (Default (..))
+import Data.List (intercalate, isInfixOf, isPrefixOf, transpose)
+import qualified Data.Map as Map
+import Data.Text (breakOnAll, pack)
+import Network.URI (isURI)
+import Text.Pandoc.Class (PandocMonad)
 import Text.Pandoc.Definition
-import Text.Pandoc.Options ( WriterOptions(writerTableOfContents, writerTemplate, writerWrapText), WrapOption(..) )
-import Text.Pandoc.Shared ( escapeURI, linesToPara, removeFormatting, trimr
-                          , substitute )
-import Text.Pandoc.Writers.Shared ( defField, metaToJSON )
 import Text.Pandoc.ImageSize
-import Text.Pandoc.Templates ( renderTemplate' )
-import Data.List ( intercalate, isPrefixOf, transpose, isInfixOf )
-import Data.Text ( breakOnAll, pack )
-import Data.Default (Default(..))
-import Network.URI ( isURI )
-import Control.Monad ( zipWithM )
-import Control.Monad.State ( modify, State, gets, evalState )
-import Text.Pandoc.Class ( PandocMonad )
-import qualified Data.Map as Map
+import Text.Pandoc.Options (WrapOption (..), WriterOptions (writerTableOfContents, writerTemplate, writerWrapText))
+import Text.Pandoc.Shared (escapeURI, linesToPara, removeFormatting, substitute,
+                           trimr)
+import Text.Pandoc.Templates (renderTemplate')
+import Text.Pandoc.Writers.Shared (defField, metaToJSON)
 
 data WriterState = WriterState {
-    stItemNum   :: Int,
-    stIndent    :: String,         -- Indent after the marker at the beginning of list items
-    stInTable   :: Bool,           -- Inside a table
-    stInLink    :: Bool            -- Inside a link description
+    stItemNum :: Int,
+    stIndent  :: String,         -- Indent after the marker at the beginning of list items
+    stInTable :: Bool,           -- Inside a table
+    stInLink  :: Bool            -- Inside a link description
   }
 
 instance Default WriterState where
@@ -139,7 +139,7 @@ blockToZimWiki _ (CodeBlock (_,classes,_) str) = do
                 (x:_)   -> "{{{code: lang=\"" ++
                         (case Map.lookup x langmap of
                                 Nothing -> x
-                                Just y -> y) ++ "\" linenumbers=\"True\"\n" ++ str ++ "\n}}}\n"  -- for zim's code plugin, go verbatim on the lang spec
+                                Just y  -> y) ++ "\" linenumbers=\"True\"\n" ++ str ++ "\n}}}\n"  -- for zim's code plugin, go verbatim on the lang spec
 
 blockToZimWiki opts (BlockQuote blocks) = do
   contents <- blockListToZimWiki opts blocks
@@ -319,7 +319,7 @@ inlineToZimWiki _ (Str str) = do
   inTable <- gets stInTable
   inLink  <- gets stInLink
   if inTable
-      then return $ substitute "|" "\\|" . escapeString $ str 
+      then return $ substitute "|" "\\|" . escapeString $ str
       else
           if inLink
           then return $ str
@@ -371,10 +371,10 @@ inlineToZimWiki opts (Image attr alt (source, tit)) = do
   alt' <- inlineListToZimWiki opts alt
   inTable <- gets stInTable
   let txt = case (tit, alt, inTable) of
-              ("",[], _) -> ""
+              ("",[], _)      -> ""
               ("", _, False ) -> "|" ++ alt'
               (_ , _, False ) -> "|" ++ tit
-              (_ , _, True ) -> ""
+              (_ , _, True )  -> ""
       -- Relative links fail isURI and receive a colon
       prefix = if isURI source then "" else ":"
   return $ "{{" ++ prefix ++ source ++ imageDims opts attr ++ txt ++ "}}"
@@ -389,7 +389,7 @@ imageDims opts attr = go (toPx $ dimension Width attr) (toPx $ dimension Height
   where
     toPx = fmap (showInPixel opts) . checkPct
     checkPct (Just (Percent _)) = Nothing
-    checkPct maybeDim = maybeDim
+    checkPct maybeDim           = maybeDim
     go (Just w) Nothing  = "?" ++ w
     go (Just w) (Just h) = "?" ++ w ++ "x" ++ h
     go Nothing  (Just h) = "?0x" ++ h
author	John MacFarlane <jgm@berkeley.edu>	2017-03-04 13:03:41 +0100
committer	John MacFarlane <jgm@berkeley.edu>	2017-03-04 13:03:41 +0100
commit	e256c8ce1778ff6fbb2e8d59556d48fb3c53393d (patch)
tree	3527320cd3fd205a00a733ddbe46917638253034 /src/Text/Pandoc/Writers
parent	0edfbf1478950d645ece19ced0156771ba16ebb6 (diff)