hlint changes.

3 files changed, 55 insertions, 63 deletions

diff --git a/src/Text/Pandoc/Readers/Docx/Combine.hs b/src/Text/Pandoc/Readers/Docx/Combine.hs
index f516d63d4..003265e6e 100644
--- a/src/Text/Pandoc/Readers/Docx/Combine.hs
+++ b/src/Text/Pandoc/Readers/Docx/Combine.hs
@@ -36,16 +36,16 @@ spaceOutInlines ils =
       right = case viewr contents of
         (_ :> Space) -> space
         _            -> mempty in
-  (left, (stackInlines fs $ trimInlines . Many $ contents), right)
+  (left, stackInlines fs $ trimInlines . Many $ contents, right)
 
 stackInlines :: [Modifier Inlines] -> Inlines -> Inlines
 stackInlines [] ms = ms
 stackInlines (NullModifier : fs) ms = stackInlines fs ms
-stackInlines ((Modifier f) : fs) ms =
+stackInlines (Modifier f : fs) ms =
   if isEmpty ms
   then stackInlines fs ms
   else f $ stackInlines fs ms
-stackInlines ((AttrModifier f attr) : fs) ms = f attr $ stackInlines fs ms
+stackInlines (AttrModifier f attr : fs) ms = f attr $ stackInlines fs ms
 
 unstackInlines :: Inlines -> ([Modifier Inlines], Inlines)
 unstackInlines ms = case ilModifier ms of
@@ -97,7 +97,7 @@ combineInlines x y =
   let (xs', x') = inlinesR x
       (y', ys') = inlinesL y
   in
-   xs' <> (combineSingletonInlines x' y') <> ys'
+   xs' <> combineSingletonInlines x' y' <> ys'
 
 combineSingletonInlines :: Inlines -> Inlines -> Inlines
 combineSingletonInlines x y =
@@ -114,10 +114,10 @@ combineSingletonInlines x y =
             stackInlines (x_rem_attr ++ y_rem_attr) mempty
           | isEmpty xs ->
             let (sp, y') = spaceOutInlinesL y in
-            (stackInlines x_rem_attr mempty) <> sp <> y'
+            stackInlines x_rem_attr mempty <> sp <> y'
           | isEmpty ys ->
             let (x', sp) = spaceOutInlinesR x in
-            x' <> sp <> (stackInlines y_rem_attr mempty)
+            x' <> sp <> stackInlines y_rem_attr mempty
           | otherwise ->
               let (x', xsp) = spaceOutInlinesR x
                   (ysp, y') = spaceOutInlinesL y
@@ -130,15 +130,15 @@ combineSingletonInlines x y =
 
 combineBlocks :: Blocks -> Blocks -> Blocks
 combineBlocks bs cs
-  | bs' :> (BlockQuote bs'') <- viewr (unMany bs)
-  , (BlockQuote cs'') :< cs' <- viewl (unMany cs) =
-      Many $ (bs' |> (BlockQuote (bs'' <> cs''))) >< cs'
+  | bs' :> BlockQuote bs'' <- viewr (unMany bs)
+  , BlockQuote cs'' :< cs' <- viewl (unMany cs) =
+      Many $ (bs' |> BlockQuote (bs'' <> cs'')) >< cs'
 combineBlocks bs cs = bs <> cs
 
 instance (Monoid a, Eq a) => Eq (Modifier a) where
-  (Modifier f) == (Modifier g) = (f mempty == g mempty)
-  (AttrModifier f attr) == (AttrModifier g attr') = (f attr mempty == g attr' mempty)
-  (NullModifier) == (NullModifier) = True
+  (Modifier f) == (Modifier g) = f mempty == g mempty
+  (AttrModifier f attr) == (AttrModifier g attr') = f attr mempty == g attr' mempty
+  NullModifier == NullModifier = True
   _ == _ = False
 
 isEmpty :: (Monoid a, Eq a) => a -> Bool
diff --git a/src/Text/Pandoc/Readers/Docx/Lists.hs b/src/Text/Pandoc/Readers/Docx/Lists.hs
index 8be2e1894..c7f4adc98 100644
--- a/src/Text/Pandoc/Readers/Docx/Lists.hs
+++ b/src/Text/Pandoc/Readers/Docx/Lists.hs
@@ -33,7 +33,6 @@ module Text.Pandoc.Readers.Docx.Lists ( blocksToBullets
                                       , listParagraphDivs
                                       ) where
 
-import Control.Monad
 import Data.List
 import Data.Maybe
 import Text.Pandoc.Generic (bottomUp)
@@ -45,22 +44,18 @@ isListItem (Div (_, classes, _) _) | "list-item" `elem` classes = True
 isListItem _                       = False
 
 getLevel :: Block -> Maybe Integer
-getLevel (Div (_, _, kvs) _) =  liftM read $ lookup "level" kvs
+getLevel (Div (_, _, kvs) _) =  fmap read $ lookup "level" kvs
 getLevel _                   = Nothing
 
 getLevelN :: Block -> Integer
-getLevelN b = case getLevel b of
-  Just n  -> n
-  Nothing -> -1
+getLevelN b = fromMaybe (-1) (getLevel b)
 
 getNumId :: Block -> Maybe Integer
-getNumId (Div (_, _, kvs) _) =  liftM read $ lookup "num-id" kvs
+getNumId (Div (_, _, kvs) _) =  fmap read $ lookup "num-id" kvs
 getNumId _                   = Nothing
 
 getNumIdN :: Block -> Integer
-getNumIdN b = case getNumId b of
-  Just n  -> n
-  Nothing -> -1
+getNumIdN b = fromMaybe (-1) (getNumId b)
 
 getText :: Block -> Maybe String
 getText (Div (_, _, kvs) _) = lookup "text" kvs
@@ -109,27 +104,27 @@ listParagraphDivs = ["ListParagraph"]
 handleListParagraphs :: [Block] -> [Block]
 handleListParagraphs [] = []
 handleListParagraphs (
-  (Div attr1@(_, classes1, _) blks1) :
-  (Div (ident2, classes2, kvs2) blks2) :
+  Div attr1@(_, classes1, _) blks1 :
+  Div (ident2, classes2, kvs2) blks2 :
   blks
   ) | "list-item" `elem` classes1 &&
-    not ("list-item" `elem` classes2) &&
+    notElem "list-item" classes2 &&
     (not . null) (listParagraphDivs `intersect` classes2) =
       -- We don't want to keep this indent.
       let newDiv2 =
-            (Div (ident2, classes2, filter (\kv -> fst kv /= "indent") kvs2) blks2)
+            Div (ident2, classes2, filter (\kv -> fst kv /= "indent") kvs2) blks2
       in
-       handleListParagraphs ((Div attr1 (blks1 ++ [newDiv2])) : blks)
-handleListParagraphs (blk:blks) = blk : (handleListParagraphs blks)
+       handleListParagraphs (Div attr1 (blks1 ++ [newDiv2]) : blks)
+handleListParagraphs (blk:blks) = blk : handleListParagraphs blks
 
 separateBlocks' :: Block -> [[Block]] -> [[Block]]
-separateBlocks' blk ([] : []) = [[blk]]
-separateBlocks' b@(BulletList _) acc = (init acc) ++ [(last acc) ++ [b]]
-separateBlocks' b@(OrderedList _ _) acc = (init acc) ++ [(last acc) ++ [b]]
+separateBlocks' blk [[]] = [[blk]]
+separateBlocks' b@(BulletList _) acc = init acc ++ [last acc ++ [b]]
+separateBlocks' b@(OrderedList _ _) acc = init acc ++ [last acc ++ [b]]
 -- The following is for the invisible bullet lists. This is how
 -- pandoc-generated ooxml does multiparagraph item lists.
-separateBlocks' b acc | liftM trim (getText b) == Just "" =
-  (init acc) ++ [(last acc) ++ [b]]
+separateBlocks' b acc | fmap trim (getText b) == Just "" =
+  init acc ++ [last acc ++ [b]]
 separateBlocks' b acc = acc ++ [[b]]
 
 separateBlocks :: [Block] -> [[Block]]
@@ -138,38 +133,37 @@ separateBlocks blks = foldr separateBlocks' [[]] (reverse blks)
 flatToBullets' :: Integer -> [Block] -> [Block]
 flatToBullets' _ [] = []
 flatToBullets' num xs@(b : elems)
-  | getLevelN b == num = b : (flatToBullets' num elems)
+  | getLevelN b == num = b : flatToBullets' num elems
   | otherwise =
     let bNumId = getNumIdN b
         bLevel = getLevelN b
         (children, remaining) =
           span
           (\b' ->
-            ((getLevelN b') > bLevel ||
-             ((getLevelN b') == bLevel && (getNumIdN b') == bNumId)))
+            (getLevelN b') > bLevel ||
+             ((getLevelN b') == bLevel && (getNumIdN b') == bNumId))
           xs
     in
      case getListType b of
        Just (Enumerated attr) ->
-         (OrderedList attr (separateBlocks $ flatToBullets' bLevel children)) :
-         (flatToBullets' num remaining)
+         OrderedList attr (separateBlocks $ flatToBullets' bLevel children) :
+         flatToBullets' num remaining
        _ ->
-         (BulletList (separateBlocks $ flatToBullets' bLevel children)) :
-         (flatToBullets' num remaining)
+         BulletList (separateBlocks $ flatToBullets' bLevel children) :
+         flatToBullets' num remaining
 
 flatToBullets :: [Block] -> [Block]
 flatToBullets elems = flatToBullets' (-1) elems
 
 singleItemHeaderToHeader :: Block -> Block
-singleItemHeaderToHeader (OrderedList _ [[h@(Header _ _ _)]]) = h
+singleItemHeaderToHeader (OrderedList _ [[h@(Header{})]]) = h
 singleItemHeaderToHeader blk                                  = blk
 
 
 blocksToBullets :: [Block] -> [Block]
 blocksToBullets blks =
   map singleItemHeaderToHeader $
-  bottomUp removeListDivs $
-  flatToBullets $ (handleListParagraphs blks)
+  bottomUp removeListDivs $flatToBullets (handleListParagraphs blks)
 
 plainParaInlines :: Block -> [Inline]
 plainParaInlines (Plain ils) = ils
@@ -179,18 +173,16 @@ plainParaInlines _           = []
 blocksToDefinitions' :: [([Inline], [[Block]])] -> [Block] -> [Block] -> [Block]
 blocksToDefinitions' []     acc [] = reverse acc
 blocksToDefinitions' defAcc acc [] =
-  reverse $ (DefinitionList (reverse defAcc)) : acc
+  reverse $ DefinitionList (reverse defAcc) : acc
 blocksToDefinitions' defAcc acc
-  ((Div (_, classes1, _) blks1) : (Div (ident2, classes2, kvs2) blks2) : blks)
+  (Div (_, classes1, _) blks1 : Div (ident2, classes2, kvs2) blks2 : blks)
   | "DefinitionTerm" `elem` classes1 && "Definition"  `elem` classes2 =
     let remainingAttr2 = (ident2, delete "Definition" classes2, kvs2)
-        pair = case remainingAttr2 == ("", [], []) of
-          True -> (concatMap plainParaInlines blks1, [blks2])
-          False -> (concatMap plainParaInlines blks1, [[Div remainingAttr2 blks2]])
+        pair = if remainingAttr2 == ("", [], []) then (concatMap plainParaInlines blks1, [blks2]) else (concatMap plainParaInlines blks1, [[Div remainingAttr2 blks2]])
     in
      blocksToDefinitions' (pair : defAcc) acc blks
 blocksToDefinitions' defAcc acc
-  ((Div (ident2, classes2, kvs2) blks2) : blks)
+  (Div (ident2, classes2, kvs2) blks2 : blks)
   | (not . null) defAcc && "Definition"  `elem` classes2 =
     let remainingAttr2 = (ident2, delete "Definition" classes2, kvs2)
         defItems2 = case remainingAttr2 == ("", [], []) of
@@ -205,14 +197,14 @@ blocksToDefinitions' defAcc acc
 blocksToDefinitions' [] acc (b:blks) =
   blocksToDefinitions' [] (b:acc) blks
 blocksToDefinitions' defAcc acc (b:blks) =
-  blocksToDefinitions' [] (b : (DefinitionList (reverse defAcc)) : acc) blks
+  blocksToDefinitions' [] (b : DefinitionList (reverse defAcc) : acc) blks
 
 removeListDivs' :: Block -> [Block]
 removeListDivs' (Div (ident, classes, kvs) blks)
   | "list-item" `elem` classes =
     case delete "list-item" classes of
       []       -> blks
-      classes' -> [Div (ident, classes', kvs) $ blks]
+      classes' -> [Div (ident, classes', kvs) blks]
 removeListDivs' (Div (ident, classes, kvs) blks)
   | not $ null $ listParagraphDivs `intersect` classes =
     case classes \\ listParagraphDivs of
diff --git a/src/Text/Pandoc/Readers/Docx/Parse.hs b/src/Text/Pandoc/Readers/Docx/Parse.hs
index 05ce691a6..1aa69f62e 100644
--- a/src/Text/Pandoc/Readers/Docx/Parse.hs
+++ b/src/Text/Pandoc/Readers/Docx/Parse.hs
@@ -106,7 +106,7 @@ eitherToD (Right b) = return b
 eitherToD (Left _)  = throwError DocxError
 
 concatMapM        :: (Monad m) => (a -> m [b]) -> [a] -> m [b]
-concatMapM f xs   =  liftM concat (mapM f xs)
+concatMapM f xs   =  fmap concat (mapM f xs)
 
 
 -- This is similar to `mapMaybe`: it maps a function returning the D
@@ -304,7 +304,7 @@ archiveToDocument zf = do
 elemToBody :: NameSpaces -> Element -> D Body
 elemToBody ns element | isElem ns "w" "body" element =
   mapD (elemToBodyPart ns) (elChildren element) >>=
-  (\bps -> return $ Body bps)
+  (return . Body)
 elemToBody _ _ = throwError WrongElem
 
 archiveToStyles :: Archive -> (CharStyleMap, ParStyleMap)
@@ -329,7 +329,7 @@ isBasedOnStyle ns element parentStyle
   , styleType == cStyleType parentStyle
   , Just basedOnVal <- findChildByName ns "w" "basedOn" element >>=
                        findAttrByName ns "w" "val"
-  , Just ps <- parentStyle = (basedOnVal == getStyleId ps)
+  , Just ps <- parentStyle = basedOnVal == getStyleId ps
   | isElem ns "w" "style" element
   , Just styleType <- findAttrByName ns "w" "type" element
   , styleType == cStyleType parentStyle
@@ -371,10 +371,10 @@ getStyleChildren ns element parentStyle
 
 buildBasedOnList :: (ElemToStyle a) => NameSpaces -> Element -> Maybe a -> [a]
 buildBasedOnList ns element rootStyle =
-  case (getStyleChildren ns element rootStyle) of
+  case getStyleChildren ns element rootStyle of
     [] -> []
     stys -> stys ++
-            (concatMap (\s -> buildBasedOnList ns element (Just s)) stys)
+            concatMap (\s -> buildBasedOnList ns element (Just s)) stys
 
 archiveToNotes :: Archive -> Notes
 archiveToNotes zf =
@@ -389,8 +389,8 @@ archiveToNotes zf =
         Just e  -> elemToNameSpaces e
         Nothing -> []
       ns = unionBy (\x y -> fst x == fst y) fn_namespaces en_namespaces
-      fn = fnElem >>= (elemToNotes ns "footnote")
-      en = enElem >>= (elemToNotes ns "endnote")
+      fn = fnElem >>= elemToNotes ns "footnote"
+      en = enElem >>= elemToNotes ns "endnote"
   in
    Notes ns fn en
 
@@ -401,7 +401,7 @@ archiveToComments zf =
       cmts_namespaces = case cmtsElem of
         Just e  -> elemToNameSpaces e
         Nothing -> []
-      cmts = (elemToComments cmts_namespaces) <$> cmtsElem
+      cmts = elemToComments cmts_namespaces <$> cmtsElem
   in
     case cmts of
       Just c  -> Comments cmts_namespaces c
@@ -442,8 +442,7 @@ lookupLevel :: String -> String -> Numbering -> Maybe Level
 lookupLevel numId ilvl (Numbering _ numbs absNumbs) = do
   absNumId <- lookup numId $ map (\(Numb nid absnumid) -> (nid, absnumid)) numbs
   lvls <- lookup absNumId $ map (\(AbstractNumb aid ls) -> (aid, ls)) absNumbs
-  lvl  <- lookup ilvl $ map (\l@(i, _, _, _) -> (i, l)) lvls
-  return lvl
+  lookup ilvl $ map (\l@(i, _, _, _) -> (i, l)) lvls
 
 
 numElemToNum :: NameSpaces -> Element -> Maybe Numb
@@ -479,7 +478,7 @@ levelElemToLevel ns element
 levelElemToLevel _ _ = Nothing
 
 archiveToNumbering' :: Archive -> Maybe Numbering
-archiveToNumbering' zf = do
+archiveToNumbering' zf =
   case findEntryByPath "word/numbering.xml" zf of
     Nothing -> Just $ Numbering [] [] []
     Just entry -> do
@@ -503,7 +502,8 @@ elemToNotes ns notetype element
                          (\a -> Just (a, e)))
                   (findChildrenByName ns "w" notetype element)
       in
-       Just $ M.fromList $ pairs
+       Just $
+       M.fromList pairs
 elemToNotes _ _ _ = Nothing
 
 elemToComments :: NameSpaces -> Element -> M.Map String Element
@@ -514,7 +514,7 @@ elemToComments ns element
                          (\a -> Just (a, e)))
                   (findChildrenByName ns "w" "comment" element)
       in
-       M.fromList $ pairs
+       M.fromList pairs
 elemToComments _ _ = M.empty