@@ -1,5 +1,6 @@
11{-# LANGUAGE RelaxedPolyRec #-} -- needed for inlinesBetween on GHC < 7
22{-# LANGUAGE ScopedTypeVariables #-}
3+
34{-
45Copyright (C) 2006-2015 John MacFarlane <jgm@berkeley.edu>
56
@@ -29,8 +30,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
2930
3031Conversion of markdown-formatted plain text to 'Pandoc' document.
3132-}
32−module Text.Pandoc.Readers.Markdown ( readMarkdown,
33− readMarkdownWithWarnings ) where
33+module Text.Pandoc.Readers.Markdown ( readMarkdown ) where
3434
3535import Data.List ( transpose, sortBy, findIndex, intercalate )
3636import qualified Data.Map as M
@@ -61,28 +61,25 @@ import Text.Pandoc.Readers.HTML ( htmlTag, htmlInBalanced, isInlineTag, isBlockT
6161import Control.Monad
6262import System.FilePath (takeExtension, addExtension)
6363import Text.HTML.TagSoup
64−import qualified Data.Set as Set
6564import Text.Printf (printf)
66−import Debug.Trace (trace)
6765import Data.Monoid ((<>))
68−import Text.Pandoc.Error
66+import Control.Monad.Trans (lift)
67+import Control.Monad.Except (throwError, catchError)
68+import Text.Pandoc.Class (PandocMonad, report)
69+import qualified Text.Pandoc.Class as P
6970
70−type MarkdownParser = Parser [Char] ParserState
71+type MarkdownParser m = ParserT [Char] ParserState m
7172
7273-- | Read markdown from an input string and return a Pandoc document.
73−readMarkdown :: ReaderOptions -- ^ Reader options
74+readMarkdown :: PandocMonad m
75+ => ReaderOptions -- ^ Reader options
7476 -> String -- ^ String to parse (assuming @'\n'@ line endings)
75− -> Either PandocError Pandoc
76−readMarkdown opts s =
77− (readWith parseMarkdown) def{ stateOptions = opts } (s ++ "\n\n")
78−
79−-- | Read markdown from an input string and return a pair of a Pandoc document
80−-- and a list of warnings.
81−readMarkdownWithWarnings :: ReaderOptions -- ^ Reader options
82− -> String -- ^ String to parse (assuming @'\n'@ line endings)
83− -> Either PandocError (Pandoc, [String])
84−readMarkdownWithWarnings opts s =
85− (readWithWarnings parseMarkdown) def{ stateOptions = opts } (s ++ "\n\n")
77+ -> m Pandoc
78+readMarkdown opts s = do
79+ parsed <- (readWithM parseMarkdown) def{ stateOptions = opts } (s ++ "\n\n")
80+ case parsed of
81+ Right result -> return result
82+ Left e -> throwError e
8683
8784trimInlinesF :: F Inlines -> F Inlines
8885trimInlinesF = liftM trimInlines
@@ -117,25 +114,25 @@ isBlank _ = False
117114--
118115
119116-- | Succeeds when we're in list context.
120−inList :: MarkdownParser ()
117+inList :: PandocMonad m => MarkdownParser m ()
121118inList = do
122119 ctx <- stateParserContext <$> getState
123120 guard (ctx == ListItemState)
124121
125−spnl :: Parser [Char] st ()
122+spnl :: PandocMonad m => ParserT [Char] st m ()
126123spnl = try $ do
127124 skipSpaces
128125 optional newline
129126 skipSpaces
130127 notFollowedBy (char '\n')
131128
132−indentSpaces :: MarkdownParser String
129+indentSpaces :: PandocMonad m => MarkdownParser m String
133130indentSpaces = try $ do
134131 tabStop <- getOption readerTabStop
135132 count tabStop (char ' ') <|>
136133 string "\t" <?> "indentation"
137134
138−nonindentSpaces :: MarkdownParser String
135+nonindentSpaces :: PandocMonad m => MarkdownParser m String
139136nonindentSpaces = do
140137 tabStop <- getOption readerTabStop
141138 sps <- many (char ' ')
@@ -144,17 +141,17 @@ nonindentSpaces = do
144141 else unexpected "indented line"
145142
146143-- returns number of spaces parsed
147−skipNonindentSpaces :: MarkdownParser Int
144+skipNonindentSpaces :: PandocMonad m => MarkdownParser m Int
148145skipNonindentSpaces = do
149146 tabStop <- getOption readerTabStop
150147 atMostSpaces (tabStop - 1) <* notFollowedBy (char ' ')
151148
152−atMostSpaces :: Int -> MarkdownParser Int
149+atMostSpaces :: PandocMonad m => Int -> MarkdownParser m Int
153150atMostSpaces n
154151 | n > 0 = (char ' ' >> (+1) <$> atMostSpaces (n-1)) <|> return 0
155152 | otherwise = return 0
156153
157−litChar :: MarkdownParser Char
154+litChar :: PandocMonad m => MarkdownParser m Char
158155litChar = escapedChar'
159156 <|> characterReference
160157 <|> noneOf "\n"
@@ -162,14 +159,14 @@ litChar = escapedChar'
162159
163160-- | Parse a sequence of inline elements between square brackets,
164161-- including inlines between balanced pairs of square brackets.
165−inlinesInBalancedBrackets :: MarkdownParser (F Inlines)
162+inlinesInBalancedBrackets :: PandocMonad m => MarkdownParser m (F Inlines)
166163inlinesInBalancedBrackets = do
167164 char '['
168165 (_, raw) <- withRaw $ charsInBalancedBrackets 1
169166 guard $ not $ null raw
170167 parseFromString (trimInlinesF . mconcat <$> many inline) (init raw)
171168
172−charsInBalancedBrackets :: Int -> MarkdownParser ()
169+charsInBalancedBrackets :: PandocMonad m => Int -> MarkdownParser m ()
173170charsInBalancedBrackets 0 = return ()
174171charsInBalancedBrackets openBrackets =
175172 (char '[' >> charsInBalancedBrackets (openBrackets + 1))
@@ -185,7 +182,7 @@ charsInBalancedBrackets openBrackets =
185182-- document structure
186183--
187184
188−rawTitleBlockLine :: MarkdownParser String
185+rawTitleBlockLine :: PandocMonad m => MarkdownParser m String
189186rawTitleBlockLine = do
190187 char '%'
191188 skipSpaces
@@ -196,13 +193,13 @@ rawTitleBlockLine = do
196193 anyLine
197194 return $ trim $ unlines (first:rest)
198195
199−titleLine :: MarkdownParser (F Inlines)
196+titleLine :: PandocMonad m => MarkdownParser m (F Inlines)
200197titleLine = try $ do
201198 raw <- rawTitleBlockLine
202199 res <- parseFromString (many inline) raw
203200 return $ trimInlinesF $ mconcat res
204201
205−authorsLine :: MarkdownParser (F [Inlines])
202+authorsLine :: PandocMonad m => MarkdownParser m (F [Inlines])
206203authorsLine = try $ do
207204 raw <- rawTitleBlockLine
208205 let sep = (char ';' <* spaces) <|> newline
@@ -212,16 +209,16 @@ authorsLine = try $ do
212209 sep
213210 sequence <$> parseFromString pAuthors raw
214211
215−dateLine :: MarkdownParser (F Inlines)
212+dateLine :: PandocMonad m => MarkdownParser m (F Inlines)
216213dateLine = try $ do
217214 raw <- rawTitleBlockLine
218215 res <- parseFromString (many inline) raw
219216 return $ trimInlinesF $ mconcat res
220217
221−titleBlock :: MarkdownParser ()
218+titleBlock :: PandocMonad m => MarkdownParser m ()
222219titleBlock = pandocTitleBlock <|> mmdTitleBlock
223220
224−pandocTitleBlock :: MarkdownParser ()
221+pandocTitleBlock :: PandocMonad m => MarkdownParser m ()
225222pandocTitleBlock = try $ do
226223 guardEnabled Ext_pandoc_title_block
227224 lookAhead (char '%')
@@ -239,7 +236,15 @@ pandocTitleBlock = try $ do
239236 $ nullMeta
240237 updateState $ \st -> st{ stateMeta' = stateMeta' st <> meta' }
241238
242−yamlMetaBlock :: MarkdownParser (F Blocks)
239+
240+-- Adapted from solution at
241+-- http://stackoverflow.com/a/29448764/1901888
242+foldrWithKeyM :: Monad m => (k -> b -> a -> m a) -> a -> H.HashMap k b -> m a
243+foldrWithKeyM f acc = H.foldrWithKey f' (return acc)
244+ where
245+ f' k b ma = ma >>= \a -> f k b a
246+
247+yamlMetaBlock :: PandocMonad m => MarkdownParser m (F Blocks)
243248yamlMetaBlock = try $ do
244249 guardEnabled Ext_yaml_metadata_block
245250 pos <- getPosition
@@ -252,18 +257,20 @@ yamlMetaBlock = try $ do
252257 optional blanklines
253258 opts <- stateOptions <$> getState
254259 meta' <- case Yaml.decodeEither' $ UTF8.fromString rawYaml of
255− Right (Yaml.Object hashmap) -> return $ return $
256− H.foldrWithKey (\k v m ->
257− if ignorable k
258− then m
259− else case yamlToMeta opts v of
260− Left _ -> m
261− Right v' -> B.setMeta (T.unpack k) v' m)
262− nullMeta hashmap
263− Right Yaml.Null -> return $ return nullMeta
260+ Right (Yaml.Object hashmap) ->
261+ foldrWithKeyM
262+ (\k v m -> do
263+ if ignorable k
264+ then return m
265+ else (do v' <- lift $ yamlToMeta opts v
266+ return $ B.setMeta (T.unpack k) v' m)
267+ `catchError`
268+ (\_ -> return m)
269+ ) nullMeta hashmap
270+ Right Yaml.Null -> return nullMeta
264271 Right _ -> do
265− addWarning (Just pos) "YAML header is not an object"
266− return $ return nullMeta
272+ P.warningWithPos pos "YAML header is not an object"
273+ return nullMeta
267274 Left err' -> do
268275 case err' of
269276 InvalidYaml (Just YamlParseException{
@@ -273,24 +280,24 @@ yamlMetaBlock = try $ do
273280 yamlLine = yline
274281 , yamlColumn = ycol
275282 }}) ->
276− addWarning (Just $ setSourceLine
283+ P.warningWithPos (setSourceLine
277284 (setSourceColumn pos
278285 (sourceColumn pos + ycol))
279286 (sourceLine pos + 1 + yline))
280287 $ "Could not parse YAML header: " ++
281288 problem
282− _ -> addWarning (Just pos)
289+ _ -> P.warningWithPos pos
283290 $ "Could not parse YAML header: " ++
284291 show err'
285− return $ return nullMeta
286− updateState $ \st -> st{ stateMeta' = stateMeta' st <> meta' }
292+ return nullMeta
293+ updateState $ \st -> st{ stateMeta' = stateMeta' st <> (return meta') }
287294 return mempty
288295
289296-- ignore fields ending with _
290297ignorable :: Text -> Bool
291298ignorable t = (T.pack "_") `T.isSuffixOf` t
292299
293−toMetaValue :: ReaderOptions -> Text -> Either PandocError MetaValue
300+toMetaValue :: PandocMonad m => ReaderOptions -> Text -> m MetaValue
294301toMetaValue opts x = toMeta <$> readMarkdown opts' (T.unpack x)
295302 where
296303 toMeta p =
@@ -301,13 +308,13 @@ toMetaValue opts x = toMeta <$> readMarkdown opts' (T.unpack x)
301308 | otherwise -> MetaInlines xs
302309 Pandoc _ bs -> MetaBlocks bs
303310 endsWithNewline t = T.pack "\n" `T.isSuffixOf` t
304− opts' = opts{readerExtensions=readerExtensions opts `Set.difference` meta_exts}
305− meta_exts = Set.fromList [ Ext_pandoc_title_block
306− , Ext_mmd_title_block
307− , Ext_yaml_metadata_block
308− ]
311+ opts' = opts{readerExtensions =
312+ disableExtension Ext_pandoc_title_block $
313+ disableExtension Ext_mmd_title_block $
314+ disableExtension Ext_yaml_metadata_block $
315+ readerExtensions opts }
309316
310−yamlToMeta :: ReaderOptions -> Yaml.Value -> Either PandocError MetaValue
317+yamlToMeta :: PandocMonad m => ReaderOptions -> Yaml.Value -> m MetaValue
311318yamlToMeta opts (Yaml.String t) = toMetaValue opts t
312319yamlToMeta _ (Yaml.Number n)
313320 -- avoid decimal points for numbers that don't need them:
@@ -327,10 +334,10 @@ yamlToMeta opts (Yaml.Object o) = MetaMap <$> H.foldrWithKey (\k v m ->
327334 (return M.empty) o
328335yamlToMeta _ _ = return $ MetaString ""
329336
330−stopLine :: MarkdownParser ()
337+stopLine :: PandocMonad m => MarkdownParser m ()
331338stopLine = try $ (string "---" <|> string "...") >> blankline >> return ()
332339
333−mmdTitleBlock :: MarkdownParser ()
340+mmdTitleBlock :: PandocMonad m => MarkdownParser m ()
334341mmdTitleBlock = try $ do
335342 guardEnabled Ext_mmd_title_block
336343 firstPair <- kvPair False
@@ -340,7 +347,7 @@ mmdTitleBlock = try $ do
340347 updateState $ \st -> st{ stateMeta' = stateMeta' st <>
341348 return (Meta $ M.fromList kvPairs) }
342349
343−kvPair :: Bool -> MarkdownParser (String, MetaValue)
350+kvPair :: PandocMonad m => Bool -> MarkdownParser m (String, MetaValue)
344351kvPair allowEmpty = try $ do
345352 key <- many1Till (alphaNum <|> oneOf "_- ") (char ':')
346353 val <- trim <$> manyTill anyChar
@@ -350,7 +357,7 @@ kvPair allowEmpty = try $ do
350357 let val' = MetaBlocks $ B.toList $ B.plain $ B.text $ val
351358 return (key',val')
352359
353−parseMarkdown :: MarkdownParser Pandoc
360+parseMarkdown :: PandocMonad m => MarkdownParser m Pandoc
354361parseMarkdown = do
355362 -- markdown allows raw HTML
356363 updateState $ \state -> state { stateOptions =
@@ -375,7 +382,7 @@ softBreakFilter (x:SoftBreak:y:zs) =
375382 _ -> x:SoftBreak:y:zs
376383softBreakFilter xs = xs
377384
378−referenceKey :: MarkdownParser (F Blocks)
385+referenceKey :: PandocMonad m => MarkdownParser m (F Blocks)
379386referenceKey = try $ do
380387 pos <- getPosition
381388 skipNonindentSpaces
@@ -402,18 +409,18 @@ referenceKey = try $ do
402409 let oldkeys = stateKeys st
403410 let key = toKey raw
404411 case M.lookup key oldkeys of
405− Just _ -> addWarning (Just pos) $ "Duplicate link reference `" ++ raw ++ "'"
412+ Just _ -> P.warningWithPos pos $ "Duplicate link reference `" ++ raw ++ "'"
406413 Nothing -> return ()
407414 updateState $ \s -> s { stateKeys = M.insert key (target, attr') oldkeys }
408415 return $ return mempty
409416
410−referenceTitle :: MarkdownParser String
417+referenceTitle :: PandocMonad m => MarkdownParser m String
411418referenceTitle = try $ do
412419 skipSpaces >> optional newline >> skipSpaces
413420 quotedTitle '"' <|> quotedTitle '\'' <|> charsInBalanced '(' ')' litChar
414421
415422-- A link title in quotes
416−quotedTitle :: Char -> MarkdownParser String
423+quotedTitle :: PandocMonad m => Char -> MarkdownParser m String
417424quotedTitle c = try $ do
418425 char c
419426 notFollowedBy spaces
@@ -425,7 +432,7 @@ quotedTitle c = try $ do
425432-- | PHP Markdown Extra style abbreviation key. Currently
426433-- we just skip them, since Pandoc doesn't have an element for
427434-- an abbreviation.
428−abbrevKey :: MarkdownParser (F Blocks)
435+abbrevKey :: PandocMonad m => MarkdownParser m (F Blocks)
429436abbrevKey = do
430437 guardEnabled Ext_abbreviations
431438 try $ do
@@ -436,23 +443,23 @@ abbrevKey = do
436443 blanklines
437444 return $ return mempty
438445
439−noteMarker :: MarkdownParser String
446+noteMarker :: PandocMonad m => MarkdownParser m String
440447noteMarker = string "[^" >> many1Till (satisfy $ not . isBlank) (char ']')
441448
442−rawLine :: MarkdownParser String
449+rawLine :: PandocMonad m => MarkdownParser m String
443450rawLine = try $ do
444451 notFollowedBy blankline
445452 notFollowedBy' $ try $ skipNonindentSpaces >> noteMarker
446453 optional indentSpaces
447454 anyLine
448455
449−rawLines :: MarkdownParser String
456+rawLines :: PandocMonad m => MarkdownParser m String
450457rawLines = do
451458 first <- anyLine
452459 rest <- many rawLine
453460 return $ unlines (first:rest)
454461
455−noteBlock :: MarkdownParser (F Blocks)
462+noteBlock :: PandocMonad m => MarkdownParser m (F Blocks)
456463noteBlock = try $ do
457464 pos <- getPosition
458465 skipNonindentSpaces
@@ -468,7 +475,7 @@ noteBlock = try $ do
468475 let newnote = (ref, parsed)
469476 oldnotes <- stateNotes' <$> getState
470477 case lookup ref oldnotes of
471− Just _ -> addWarning (Just pos) $ "Duplicate note reference `" ++ ref ++ "'"
478+ Just _ -> P.warningWithPos pos $ "Duplicate note reference `" ++ ref ++ "'"
472479 Nothing -> return ()
473480 updateState $ \s -> s { stateNotes' = newnote : oldnotes }
474481 return mempty
@@ -477,12 +484,11 @@ noteBlock = try $ do
477484-- parsing blocks
478485--
479486
480−parseBlocks :: MarkdownParser (F Blocks)
487+parseBlocks :: PandocMonad m => MarkdownParser m (F Blocks)
481488parseBlocks = mconcat <$> manyTill block eof
482489
483−block :: MarkdownParser (F Blocks)
490+block :: PandocMonad m => MarkdownParser m (F Blocks)
484491block = do
485− tr <- getOption readerTrace
486492 pos <- getPosition
487493 res <- choice [ mempty <$ blanklines
488494 , codeBlockFenced
@@ -509,26 +515,25 @@ block = do
509515 , para
510516 , plain
511517 ] <?> "block"
512− when tr $ do
513− st <- getState
514− trace (printf "line %d: %s" (sourceLine pos)
515− (take 60 $ show $ B.toList $ runF res st)) (return ())
518+ report DEBUG $ printf "line %d: %s" (sourceLine pos)
519+ (take 60 $ show $ B.toList $ runF res defaultParserState)
516520 return res
517521
518522--
519523-- header blocks
520524--
521525
522−header :: MarkdownParser (F Blocks)
526+header :: PandocMonad m => MarkdownParser m (F Blocks)
523527header = setextHeader <|> atxHeader <?> "header"
524528
525−atxChar :: MarkdownParser Char
529+atxChar :: PandocMonad m => MarkdownParser m Char
526530atxChar = do
527531 exts <- getOption readerExtensions
528− return $ if Set.member Ext_literate_haskell exts
529− then '=' else '#'
532+ return $ if extensionEnabled Ext_literate_haskell exts
533+ then '='
534+ else '#'
530535
531−atxHeader :: MarkdownParser (F Blocks)
536+atxHeader :: PandocMonad m => MarkdownParser m (F Blocks)
532537atxHeader = try $ do
533538 level <- atxChar >>= many1 . char >>= return . length
534539 notFollowedBy $ guardEnabled Ext_fancy_lists >>
@@ -542,7 +547,7 @@ atxHeader = try $ do
542547 <|> registerImplicitHeader raw attr'
543548 return $ B.headerWith attr' level <$> text
544549
545−atxClosing :: MarkdownParser Attr
550+atxClosing :: PandocMonad m => MarkdownParser m Attr
546551atxClosing = try $ do
547552 attr' <- option nullAttr
548553 (guardEnabled Ext_mmd_header_identifiers >> mmdHeaderIdentifier)
@@ -553,7 +558,7 @@ atxClosing = try $ do
553558 blanklines
554559 return attr
555560
556−setextHeaderEnd :: MarkdownParser Attr
561+setextHeaderEnd :: PandocMonad m => MarkdownParser m Attr
557562setextHeaderEnd = try $ do
558563 attr <- option nullAttr
559564 $ (guardEnabled Ext_mmd_header_identifiers >> mmdHeaderIdentifier)
@@ -561,13 +566,13 @@ setextHeaderEnd = try $ do
561566 blanklines
562567 return attr
563568
564−mmdHeaderIdentifier :: MarkdownParser Attr
569+mmdHeaderIdentifier :: PandocMonad m => MarkdownParser m Attr
565570mmdHeaderIdentifier = do
566571 ident <- stripFirstAndLast . snd <$> reference
567572 skipSpaces
568573 return (ident,[],[])
569574
570−setextHeader :: MarkdownParser (F Blocks)
575+setextHeader :: PandocMonad m => MarkdownParser m (F Blocks)
571576setextHeader = try $ do
572577 -- This lookahead prevents us from wasting time parsing Inlines
573578 -- unless necessary -- it gives a significant performance boost.
@@ -585,7 +590,7 @@ setextHeader = try $ do
585590 <|> registerImplicitHeader raw attr'
586591 return $ B.headerWith attr' level <$> text
587592
588−registerImplicitHeader :: String -> Attr -> MarkdownParser ()
593+registerImplicitHeader :: PandocMonad m => String -> Attr -> MarkdownParser m ()
589594registerImplicitHeader raw attr@(ident, _, _) = do
590595 let key = toKey $ "[" ++ raw ++ "]"
591596 updateState (\s -> s { stateHeaderKeys =
@@ -595,7 +600,7 @@ registerImplicitHeader raw attr@(ident, _, _) = do
595600-- hrule block
596601--
597602
598−hrule :: Parser [Char] st (F Blocks)
603+hrule :: PandocMonad m => ParserT [Char] st m (F Blocks)
599604hrule = try $ do
600605 skipSpaces
601606 start <- satisfy isHruleChar
@@ -609,12 +614,13 @@ hrule = try $ do
609614-- code blocks
610615--
611616
612−indentedLine :: MarkdownParser String
617+indentedLine :: PandocMonad m => MarkdownParser m String
613618indentedLine = indentSpaces >> anyLine >>= return . (++ "\n")
614619
615−blockDelimiter :: (Char -> Bool)
620+blockDelimiter :: PandocMonad m
621+ => (Char -> Bool)
616622 -> Maybe Int
617− -> Parser [Char] st Int
623+ -> ParserT [Char] st m Int
618624blockDelimiter f len = try $ do
619625 c <- lookAhead (satisfy f)
620626 case len of
@@ -622,7 +628,7 @@ blockDelimiter f len = try $ do
622628 Nothing -> count 3 (char c) >> many (char c) >>=
623629 return . (+ 3) . length
624630
625−attributes :: MarkdownParser Attr
631+attributes :: PandocMonad m => MarkdownParser m Attr
626632attributes = try $ do
627633 char '{'
628634 spnl
@@ -630,28 +636,28 @@ attributes = try $ do
630636 char '}'
631637 return $ foldl (\x f -> f x) nullAttr attrs
632638
633−attribute :: MarkdownParser (Attr -> Attr)
639+attribute :: PandocMonad m => MarkdownParser m (Attr -> Attr)
634640attribute = identifierAttr <|> classAttr <|> keyValAttr <|> specialAttr
635641
636−identifier :: MarkdownParser String
642+identifier :: PandocMonad m => MarkdownParser m String
637643identifier = do
638644 first <- letter
639645 rest <- many $ alphaNum <|> oneOf "-_:."
640646 return (first:rest)
641647
642−identifierAttr :: MarkdownParser (Attr -> Attr)
648+identifierAttr :: PandocMonad m => MarkdownParser m (Attr -> Attr)
643649identifierAttr = try $ do
644650 char '#'
645651 result <- identifier
646652 return $ \(_,cs,kvs) -> (result,cs,kvs)
647653
648−classAttr :: MarkdownParser (Attr -> Attr)
654+classAttr :: PandocMonad m => MarkdownParser m (Attr -> Attr)
649655classAttr = try $ do
650656 char '.'
651657 result <- identifier
652658 return $ \(id',cs,kvs) -> (id',cs ++ [result],kvs)
653659
654−keyValAttr :: MarkdownParser (Attr -> Attr)
660+keyValAttr :: PandocMonad m => MarkdownParser m (Attr -> Attr)
655661keyValAttr = try $ do
656662 key <- identifier
657663 char '='
@@ -664,12 +670,12 @@ keyValAttr = try $ do
664670 "class" -> (id',cs ++ words val,kvs)
665671 _ -> (id',cs,kvs ++ [(key,val)])
666672
667−specialAttr :: MarkdownParser (Attr -> Attr)
673+specialAttr :: PandocMonad m => MarkdownParser m (Attr -> Attr)
668674specialAttr = do
669675 char '-'
670676 return $ \(id',cs,kvs) -> (id',cs ++ ["unnumbered"],kvs)
671677
672−codeBlockFenced :: MarkdownParser (F Blocks)
678+codeBlockFenced :: PandocMonad m => MarkdownParser m (F Blocks)
673679codeBlockFenced = try $ do
674680 c <- try (guardEnabled Ext_fenced_code_blocks >> lookAhead (char '~'))
675681 <|> (guardEnabled Ext_backtick_code_blocks >> lookAhead (char '`'))
@@ -690,7 +696,7 @@ toLanguageId = map toLower . go
690696 go "objective-c" = "objectivec"
691697 go x = x
692698
693−codeBlockIndented :: MarkdownParser (F Blocks)
699+codeBlockIndented :: PandocMonad m => MarkdownParser m (F Blocks)
694700codeBlockIndented = do
695701 contents <- many1 (indentedLine <|>
696702 try (do b <- blanklines
@@ -701,7 +707,7 @@ codeBlockIndented = do
701707 return $ return $ B.codeBlockWith ("", classes, []) $
702708 stripTrailingNewlines $ concat contents
703709
704−lhsCodeBlock :: MarkdownParser (F Blocks)
710+lhsCodeBlock :: PandocMonad m => MarkdownParser m (F Blocks)
705711lhsCodeBlock = do
706712 guardEnabled Ext_literate_haskell
707713 (return . B.codeBlockWith ("",["sourceCode","literate","haskell"],[]) <$>
@@ -709,7 +715,7 @@ lhsCodeBlock = do
709715 <|> (return . B.codeBlockWith ("",["sourceCode","haskell"],[]) <$>
710716 lhsCodeBlockInverseBird)
711717
712−lhsCodeBlockLaTeX :: MarkdownParser String
718+lhsCodeBlockLaTeX :: PandocMonad m => MarkdownParser m String
713719lhsCodeBlockLaTeX = try $ do
714720 string "\\begin{code}"
715721 manyTill spaceChar newline
@@ -717,13 +723,13 @@ lhsCodeBlockLaTeX = try $ do
717723 blanklines
718724 return $ stripTrailingNewlines contents
719725
720−lhsCodeBlockBird :: MarkdownParser String
726+lhsCodeBlockBird :: PandocMonad m => MarkdownParser m String
721727lhsCodeBlockBird = lhsCodeBlockBirdWith '>'
722728
723−lhsCodeBlockInverseBird :: MarkdownParser String
729+lhsCodeBlockInverseBird :: PandocMonad m => MarkdownParser m String
724730lhsCodeBlockInverseBird = lhsCodeBlockBirdWith '<'
725731
726−lhsCodeBlockBirdWith :: Char -> MarkdownParser String
732+lhsCodeBlockBirdWith :: PandocMonad m => Char -> MarkdownParser m String
727733lhsCodeBlockBirdWith c = try $ do
728734 pos <- getPosition
729735 when (sourceColumn pos /= 1) $ fail "Not in first column"
@@ -735,7 +741,7 @@ lhsCodeBlockBirdWith c = try $ do
735741 blanklines
736742 return $ intercalate "\n" lns'
737743
738−birdTrackLine :: Char -> Parser [Char] st String
744+birdTrackLine :: PandocMonad m => Char -> ParserT [Char] st m String
739745birdTrackLine c = try $ do
740746 char c
741747 -- allow html tags on left margin:
@@ -746,10 +752,10 @@ birdTrackLine c = try $ do
746752-- block quotes
747753--
748754
749−emailBlockQuoteStart :: MarkdownParser Char
755+emailBlockQuoteStart :: PandocMonad m => MarkdownParser m Char
750756emailBlockQuoteStart = try $ skipNonindentSpaces >> char '>' <* optional (char ' ')
751757
752−emailBlockQuote :: MarkdownParser [String]
758+emailBlockQuote :: PandocMonad m => MarkdownParser m [String]
753759emailBlockQuote = try $ do
754760 emailBlockQuoteStart
755761 let emailLine = many $ nonEndline <|> try
@@ -763,7 +769,7 @@ emailBlockQuote = try $ do
763769 optional blanklines
764770 return raw
765771
766−blockQuote :: MarkdownParser (F Blocks)
772+blockQuote :: PandocMonad m => MarkdownParser m (F Blocks)
767773blockQuote = do
768774 raw <- emailBlockQuote
769775 -- parse the extracted block, which may contain various block elements:
@@ -774,7 +780,7 @@ blockQuote = do
774780-- list blocks
775781--
776782
777−bulletListStart :: MarkdownParser ()
783+bulletListStart :: PandocMonad m => MarkdownParser m ()
778784bulletListStart = try $ do
779785 optional newline -- if preceded by a Plain block in a list context
780786 startpos <- sourceColumn <$> getPosition
@@ -786,7 +792,7 @@ bulletListStart = try $ do
786792 lookAhead (newline <|> spaceChar)
787793 () <$ atMostSpaces (tabStop - (endpos - startpos))
788794
789−anyOrderedListStart :: MarkdownParser (Int, ListNumberStyle, ListNumberDelim)
795+anyOrderedListStart :: PandocMonad m => MarkdownParser m (Int, ListNumberStyle, ListNumberDelim)
790796anyOrderedListStart = try $ do
791797 optional newline -- if preceded by a Plain block in a list context
792798 startpos <- sourceColumn <$> getPosition
@@ -810,10 +816,10 @@ anyOrderedListStart = try $ do
810816 atMostSpaces (tabStop - (endpos - startpos))
811817 return res
812818
813−listStart :: MarkdownParser ()
819+listStart :: PandocMonad m => MarkdownParser m ()
814820listStart = bulletListStart <|> (anyOrderedListStart >> return ())
815821
816−listLine :: MarkdownParser String
822+listLine :: PandocMonad m => MarkdownParser m String
817823listLine = try $ do
818824 notFollowedBy' (do indentSpaces
819825 many spaceChar
@@ -822,7 +828,7 @@ listLine = try $ do
822828 optional (() <$ indentSpaces)
823829 listLineCommon
824830
825−listLineCommon :: MarkdownParser String
831+listLineCommon :: PandocMonad m => MarkdownParser m String
826832listLineCommon = concat <$> manyTill
827833 ( many1 (satisfy $ \c -> c /= '\n' && c /= '<')
828834 <|> liftM snd (htmlTag isCommentTag)
@@ -830,8 +836,9 @@ listLineCommon = concat <$> manyTill
830836 ) newline
831837
832838-- parse raw text for one list item, excluding start marker and continuations
833−rawListItem :: MarkdownParser a
834− -> MarkdownParser String
839+rawListItem :: PandocMonad m
840+ => MarkdownParser m a
841+ -> MarkdownParser m String
835842rawListItem start = try $ do
836843 start
837844 first <- listLineCommon
@@ -842,21 +849,21 @@ rawListItem start = try $ do
842849-- continuation of a list item - indented and separated by blankline
843850-- or (in compact lists) endline.
844851-- note: nested lists are parsed as continuations
845−listContinuation :: MarkdownParser String
852+listContinuation :: PandocMonad m => MarkdownParser m String
846853listContinuation = try $ do
847854 lookAhead indentSpaces
848855 result <- many1 listContinuationLine
849856 blanks <- many blankline
850857 return $ concat result ++ blanks
851858
852−notFollowedByHtmlCloser :: MarkdownParser ()
859+notFollowedByHtmlCloser :: PandocMonad m => MarkdownParser m ()
853860notFollowedByHtmlCloser = do
854861 inHtmlBlock <- stateInHtmlBlock <$> getState
855862 case inHtmlBlock of
856863 Just t -> notFollowedBy' $ htmlTag (~== TagClose t)
857864 Nothing -> return ()
858865
859−listContinuationLine :: MarkdownParser String
866+listContinuationLine :: PandocMonad m => MarkdownParser m String
860867listContinuationLine = try $ do
861868 notFollowedBy blankline
862869 notFollowedBy' listStart
@@ -865,8 +872,9 @@ listContinuationLine = try $ do
865872 result <- anyLine
866873 return $ result ++ "\n"
867874
868−listItem :: MarkdownParser a
869− -> MarkdownParser (F Blocks)
875+listItem :: PandocMonad m
876+ => MarkdownParser m a
877+ -> MarkdownParser m (F Blocks)
870878listItem start = try $ do
871879 first <- rawListItem start
872880 continuations <- many listContinuation
@@ -882,7 +890,7 @@ listItem start = try $ do
882890 updateState (\st -> st {stateParserContext = oldContext})
883891 return contents
884892
885−orderedList :: MarkdownParser (F Blocks)
893+orderedList :: PandocMonad m => MarkdownParser m (F Blocks)
886894orderedList = try $ do
887895 (start, style, delim) <- lookAhead anyOrderedListStart
888896 unless (style `elem` [DefaultStyle, Decimal, Example] &&
@@ -901,16 +909,16 @@ orderedList = try $ do
901909 atMostSpaces (tabStop - (endpos - startpos))
902910 return res )
903911 start' <- option 1 $ guardEnabled Ext_startnum >> return start
904− return $ B.orderedListWith (start', style, delim) <$> fmap compactify' items
912+ return $ B.orderedListWith (start', style, delim) <$> fmap compactify items
905913
906−bulletList :: MarkdownParser (F Blocks)
914+bulletList :: PandocMonad m => MarkdownParser m (F Blocks)
907915bulletList = do
908916 items <- fmap sequence $ many1 $ listItem bulletListStart
909− return $ B.bulletList <$> fmap compactify' items
917+ return $ B.bulletList <$> fmap compactify items
910918
911919-- definition lists
912920
913−defListMarker :: MarkdownParser ()
921+defListMarker :: PandocMonad m => MarkdownParser m ()
914922defListMarker = do
915923 sps <- nonindentSpaces
916924 char ':' <|> char '~'
@@ -921,7 +929,7 @@ defListMarker = do
921929 else mzero
922930 return ()
923931
924−definitionListItem :: Bool -> MarkdownParser (F (Inlines, [Blocks]))
932+definitionListItem :: PandocMonad m => Bool -> MarkdownParser m (F (Inlines, [Blocks]))
925933definitionListItem compact = try $ do
926934 rawLine' <- anyLine
927935 raw <- many1 $ defRawBlock compact
@@ -930,7 +938,7 @@ definitionListItem compact = try $ do
930938 optional blanklines
931939 return $ liftM2 (,) term (sequence contents)
932940
933−defRawBlock :: Bool -> MarkdownParser String
941+defRawBlock :: PandocMonad m => Bool -> MarkdownParser m String
934942defRawBlock compact = try $ do
935943 hasBlank <- option False $ blankline >> return True
936944 defListMarker
@@ -952,7 +960,7 @@ defRawBlock compact = try $ do
952960 return $ trimr (firstline ++ "\n" ++ unlines rawlines ++ cont) ++
953961 if hasBlank || not (null cont) then "\n\n" else ""
954962
955−definitionList :: MarkdownParser (F Blocks)
963+definitionList :: PandocMonad m => MarkdownParser m (F Blocks)
956964definitionList = try $ do
957965 lookAhead (anyLine >>
958966 optional (blankline >> notFollowedBy (table >> return ())) >>
@@ -960,13 +968,13 @@ definitionList = try $ do
960968 defListMarker)
961969 compactDefinitionList <|> normalDefinitionList
962970
963−compactDefinitionList :: MarkdownParser (F Blocks)
971+compactDefinitionList :: PandocMonad m => MarkdownParser m (F Blocks)
964972compactDefinitionList = do
965973 guardEnabled Ext_compact_definition_lists
966974 items <- fmap sequence $ many1 $ definitionListItem True
967− return $ B.definitionList <$> fmap compactify'DL items
975+ return $ B.definitionList <$> fmap compactifyDL items
968976
969−normalDefinitionList :: MarkdownParser (F Blocks)
977+normalDefinitionList :: PandocMonad m => MarkdownParser m (F Blocks)
970978normalDefinitionList = do
971979 guardEnabled Ext_definition_lists
972980 items <- fmap sequence $ many1 $ definitionListItem False
@@ -976,7 +984,7 @@ normalDefinitionList = do
976984-- paragraph block
977985--
978986
979−para :: MarkdownParser (F Blocks)
987+para :: PandocMonad m => MarkdownParser m (F Blocks)
980988para = try $ do
981989 exts <- getOption readerExtensions
982990 result <- trimInlinesF . mconcat <$> many1 inline
@@ -1001,25 +1009,25 @@ para = try $ do
10011009 result' <- result
10021010 case B.toList result' of
10031011 [Image attr alt (src,tit)]
1004− | Ext_implicit_figures `Set.member` exts ->
1012+ | Ext_implicit_figures `extensionEnabled` exts ->
10051013 -- the fig: at beginning of title indicates a figure
10061014 return $ B.para $ B.singleton
10071015 $ Image attr alt (src,'f':'i':'g':':':tit)
10081016 _ -> return $ B.para result'
10091017
1010−plain :: MarkdownParser (F Blocks)
1018+plain :: PandocMonad m => MarkdownParser m (F Blocks)
10111019plain = fmap B.plain . trimInlinesF . mconcat <$> many1 inline
10121020
10131021--
10141022-- raw html
10151023--
10161024
1017−htmlElement :: MarkdownParser String
1025+htmlElement :: PandocMonad m => MarkdownParser m String
10181026htmlElement = rawVerbatimBlock
10191027 <|> strictHtmlBlock
10201028 <|> liftM snd (htmlTag isBlockTag)
10211029
1022−htmlBlock :: MarkdownParser (F Blocks)
1030+htmlBlock :: PandocMonad m => MarkdownParser m (F Blocks)
10231031htmlBlock = do
10241032 guardEnabled Ext_raw_html
10251033 try (do
@@ -1044,24 +1052,24 @@ htmlBlock = do
10441052 <|> (guardEnabled Ext_markdown_in_html_blocks >> rawHtmlBlocks))
10451053 <|> htmlBlock'
10461054
1047−htmlBlock' :: MarkdownParser (F Blocks)
1055+htmlBlock' :: PandocMonad m => MarkdownParser m (F Blocks)
10481056htmlBlock' = try $ do
10491057 first <- htmlElement
10501058 skipMany spaceChar
10511059 optional blanklines
10521060 return $ return $ B.rawBlock "html" first
10531061
1054−strictHtmlBlock :: MarkdownParser String
1062+strictHtmlBlock :: PandocMonad m => MarkdownParser m String
10551063strictHtmlBlock = htmlInBalanced (not . isInlineTag)
10561064
1057−rawVerbatimBlock :: MarkdownParser String
1065+rawVerbatimBlock :: PandocMonad m => MarkdownParser m String
10581066rawVerbatimBlock = htmlInBalanced isVerbTag
10591067 where isVerbTag (TagOpen "pre" _) = True
10601068 isVerbTag (TagOpen "style" _) = True
10611069 isVerbTag (TagOpen "script" _) = True
10621070 isVerbTag _ = False
10631071
1064−rawTeXBlock :: MarkdownParser (F Blocks)
1072+rawTeXBlock :: PandocMonad m => MarkdownParser m (F Blocks)
10651073rawTeXBlock = do
10661074 guardEnabled Ext_raw_tex
10671075 result <- (B.rawBlock "latex" . concat <$>
@@ -1071,7 +1079,7 @@ rawTeXBlock = do
10711079 spaces
10721080 return $ return result
10731081
1074−rawHtmlBlocks :: MarkdownParser (F Blocks)
1082+rawHtmlBlocks :: PandocMonad m => MarkdownParser m (F Blocks)
10751083rawHtmlBlocks = do
10761084 (TagOpen tagtype _, raw) <- htmlTag isBlockTag
10771085 -- try to find closing tag
@@ -1101,7 +1109,7 @@ stripMarkdownAttribute s = renderTags' $ map filterAttrib $ parseTags s
11011109-- line block
11021110--
11031111
1104−lineBlock :: MarkdownParser (F Blocks)
1112+lineBlock :: PandocMonad m => MarkdownParser m (F Blocks)
11051113lineBlock = try $ do
11061114 guardEnabled Ext_line_blocks
11071115 lines' <- lineBlockLines >>=
@@ -1114,8 +1122,9 @@ lineBlock = try $ do
11141122
11151123-- Parse a dashed line with optional trailing spaces; return its length
11161124-- and the length including trailing space.
1117−dashedLine :: Char
1118− -> Parser [Char] st (Int, Int)
1125+dashedLine :: PandocMonad m
1126+ => Char
1127+ -> ParserT [Char] st m (Int, Int)
11191128dashedLine ch = do
11201129 dashes <- many1 (char ch)
11211130 sp <- many spaceChar
@@ -1125,8 +1134,9 @@ dashedLine ch = do
11251134
11261135-- Parse a table header with dashed lines of '-' preceded by
11271136-- one (or zero) line of text.
1128−simpleTableHeader :: Bool -- ^ Headerless table
1129− -> MarkdownParser (F [Blocks], [Alignment], [Int])
1137+simpleTableHeader :: PandocMonad m
1138+ => Bool -- ^ Headerless table
1139+ -> MarkdownParser m (F [Blocks], [Alignment], [Int])
11301140simpleTableHeader headless = try $ do
11311141 rawContent <- if headless
11321142 then return ""
@@ -1170,16 +1180,17 @@ alignType strLst len =
11701180 (False, False) -> AlignDefault
11711181
11721182-- Parse a table footer - dashed lines followed by blank line.
1173−tableFooter :: MarkdownParser String
1183+tableFooter :: PandocMonad m => MarkdownParser m String
11741184tableFooter = try $ skipNonindentSpaces >> many1 (dashedLine '-') >> blanklines
11751185
11761186-- Parse a table separator - dashed line.
1177−tableSep :: MarkdownParser Char
1187+tableSep :: PandocMonad m => MarkdownParser m Char
11781188tableSep = try $ skipNonindentSpaces >> many1 (dashedLine '-') >> char '\n'
11791189
11801190-- Parse a raw line and split it into chunks by indices.
1181−rawTableLine :: [Int]
1182− -> MarkdownParser [String]
1191+rawTableLine :: PandocMonad m
1192+ => [Int]
1193+ -> MarkdownParser m [String]
11831194rawTableLine indices = do
11841195 notFollowedBy' (blanklines <|> tableFooter)
11851196 line <- many1Till anyChar newline
@@ -1187,14 +1198,16 @@ rawTableLine indices = do
11871198 splitStringByIndices (init indices) line
11881199
11891200-- Parse a table line and return a list of lists of blocks (columns).
1190−tableLine :: [Int]
1191− -> MarkdownParser (F [Blocks])
1201+tableLine :: PandocMonad m
1202+ => [Int]
1203+ -> MarkdownParser m (F [Blocks])
11921204tableLine indices = rawTableLine indices >>=
11931205 fmap sequence . mapM (parseFromString (mconcat <$> many plain))
11941206
11951207-- Parse a multiline table row and return a list of blocks (columns).
1196−multilineRow :: [Int]
1197− -> MarkdownParser (F [Blocks])
1208+multilineRow :: PandocMonad m
1209+ => [Int]
1210+ -> MarkdownParser m (F [Blocks])
11981211multilineRow indices = do
11991212 colLines <- many1 (rawTableLine indices)
12001213 let cols = map unlines $ transpose colLines
@@ -1202,7 +1215,7 @@ multilineRow indices = do
12021215
12031216-- Parses a table caption: inlines beginning with 'Table:'
12041217-- and followed by blank lines.
1205−tableCaption :: MarkdownParser (F Inlines)
1218+tableCaption :: PandocMonad m => MarkdownParser m (F Inlines)
12061219tableCaption = try $ do
12071220 guardEnabled Ext_table_captions
12081221 skipNonindentSpaces
@@ -1210,8 +1223,9 @@ tableCaption = try $ do
12101223 trimInlinesF . mconcat <$> many1 inline <* blanklines
12111224
12121225-- Parse a simple table with '---' header and one line per row.
1213−simpleTable :: Bool -- ^ Headerless table
1214− -> MarkdownParser ([Alignment], [Double], F [Blocks], F [[Blocks]])
1226+simpleTable :: PandocMonad m
1227+ => Bool -- ^ Headerless table
1228+ -> MarkdownParser m ([Alignment], [Double], F [Blocks], F [[Blocks]])
12151229simpleTable headless = do
12161230 (aligns, _widths, heads', lines') <-
12171231 tableWith (simpleTableHeader headless) tableLine
@@ -1224,13 +1238,15 @@ simpleTable headless = do
12241238-- (which may be multiline), then the rows,
12251239-- which may be multiline, separated by blank lines, and
12261240-- ending with a footer (dashed line followed by blank line).
1227−multilineTable :: Bool -- ^ Headerless table
1228− -> MarkdownParser ([Alignment], [Double], F [Blocks], F [[Blocks]])
1241+multilineTable :: PandocMonad m
1242+ => Bool -- ^ Headerless table
1243+ -> MarkdownParser m ([Alignment], [Double], F [Blocks], F [[Blocks]])
12291244multilineTable headless =
12301245 tableWith (multilineTableHeader headless) multilineRow blanklines tableFooter
12311246
1232−multilineTableHeader :: Bool -- ^ Headerless table
1233− -> MarkdownParser (F [Blocks], [Alignment], [Int])
1247+multilineTableHeader :: PandocMonad m
1248+ => Bool -- ^ Headerless table
1249+ -> MarkdownParser m (F [Blocks], [Alignment], [Int])
12341250multilineTableHeader headless = try $ do
12351251 unless headless $
12361252 tableSep >> notFollowedBy blankline
@@ -1261,8 +1277,8 @@ multilineTableHeader headless = try $ do
12611277-- (which may be grid), then the rows,
12621278-- which may be grid, separated by blank lines, and
12631279-- ending with a footer (dashed line followed by blank line).
1264−gridTable :: Bool -- ^ Headerless table
1265− -> MarkdownParser ([Alignment], [Double], F [Blocks], F [[Blocks]])
1280+gridTable :: PandocMonad m => Bool -- ^ Headerless table
1281+ -> MarkdownParser m ([Alignment], [Double], F [Blocks], F [[Blocks]])
12661282gridTable headless =
12671283 tableWith (gridTableHeader headless) gridTableRow
12681284 (gridTableSep '-') gridTableFooter
@@ -1271,7 +1287,7 @@ gridTableSplitLine :: [Int] -> String -> [String]
12711287gridTableSplitLine indices line = map removeFinalBar $ tail $
12721288 splitStringByIndices (init indices) $ trimr line
12731289
1274−gridPart :: Char -> Parser [Char] st ((Int, Int), Alignment)
1290+gridPart :: PandocMonad m => Char -> ParserT [Char] st m ((Int, Int), Alignment)
12751291gridPart ch = do
12761292 leftColon <- option False (True <$ char ':')
12771293 dashes <- many1 (char ch)
@@ -1286,7 +1302,7 @@ gridPart ch = do
12861302 (False, False) -> AlignDefault
12871303 return ((lengthDashes, lengthDashes + 1), alignment)
12881304
1289−gridDashedLines :: Char -> Parser [Char] st [((Int, Int), Alignment)]
1305+gridDashedLines :: PandocMonad m => Char -> ParserT [Char] st m [((Int, Int), Alignment)]
12901306gridDashedLines ch = try $ char '+' >> many1 (gridPart ch) <* blankline
12911307
12921308removeFinalBar :: String -> String
@@ -1294,12 +1310,12 @@ removeFinalBar =
12941310 reverse . dropWhile (`elem` " \t") . dropWhile (=='|') . reverse
12951311
12961312-- | Separator between rows of grid table.
1297−gridTableSep :: Char -> MarkdownParser Char
1313+gridTableSep :: PandocMonad m => Char -> MarkdownParser m Char
12981314gridTableSep ch = try $ gridDashedLines ch >> return '\n'
12991315
13001316-- | Parse header for a grid table.
1301−gridTableHeader :: Bool -- ^ Headerless table
1302− -> MarkdownParser (F [Blocks], [Alignment], [Int])
1317+gridTableHeader :: PandocMonad m => Bool -- ^ Headerless table
1318+ -> MarkdownParser m (F [Blocks], [Alignment], [Int])
13031319gridTableHeader headless = try $ do
13041320 optional blanklines
13051321 dashes <- gridDashedLines '-'
@@ -1320,20 +1336,20 @@ gridTableHeader headless = try $ do
13201336 heads <- fmap sequence $ mapM (parseFromString parseBlocks . trim) rawHeads
13211337 return (heads, aligns, indices)
13221338
1323−gridTableRawLine :: [Int] -> MarkdownParser [String]
1339+gridTableRawLine :: PandocMonad m => [Int] -> MarkdownParser m [String]
13241340gridTableRawLine indices = do
13251341 char '|'
13261342 line <- anyLine
13271343 return (gridTableSplitLine indices line)
13281344
13291345-- | Parse row of grid table.
1330−gridTableRow :: [Int]
1331− -> MarkdownParser (F [Blocks])
1346+gridTableRow :: PandocMonad m => [Int]
1347+ -> MarkdownParser m (F [Blocks])
13321348gridTableRow indices = do
13331349 colLines <- many1 (gridTableRawLine indices)
13341350 let cols = map ((++ "\n") . unlines . removeOneLeadingSpace) $
13351351 transpose colLines
1336− fmap compactify' <$> fmap sequence (mapM (parseFromString parseBlocks) cols)
1352+ fmap compactify <$> fmap sequence (mapM (parseFromString parseBlocks) cols)
13371353
13381354removeOneLeadingSpace :: [String] -> [String]
13391355removeOneLeadingSpace xs =
@@ -1344,10 +1360,10 @@ removeOneLeadingSpace xs =
13441360 startsWithSpace (y:_) = y == ' '
13451361
13461362-- | Parse footer for a grid table.
1347−gridTableFooter :: MarkdownParser [Char]
1363+gridTableFooter :: PandocMonad m => MarkdownParser m [Char]
13481364gridTableFooter = blanklines
13491365
1350−pipeBreak :: MarkdownParser ([Alignment], [Int])
1366+pipeBreak :: PandocMonad m => MarkdownParser m ([Alignment], [Int])
13511367pipeBreak = try $ do
13521368 nonindentSpaces
13531369 openPipe <- (True <$ char '|') <|> return False
@@ -1359,7 +1375,7 @@ pipeBreak = try $ do
13591375 blankline
13601376 return $ unzip (first:rest)
13611377
1362−pipeTable :: MarkdownParser ([Alignment], [Double], F [Blocks], F [[Blocks]])
1378+pipeTable :: PandocMonad m => MarkdownParser m ([Alignment], [Double], F [Blocks], F [[Blocks]])
13631379pipeTable = try $ do
13641380 nonindentSpaces
13651381 lookAhead nonspaceChar
@@ -1377,13 +1393,13 @@ pipeTable = try $ do
13771393 else replicate (length aligns) 0.0
13781394 return $ (aligns, widths, heads', sequence lines'')
13791395
1380−sepPipe :: MarkdownParser ()
1396+sepPipe :: PandocMonad m => MarkdownParser m ()
13811397sepPipe = try $ do
13821398 char '|' <|> char '+'
13831399 notFollowedBy blankline
13841400
13851401-- parse a row, also returning probable alignments for org-table cells
1386−pipeTableRow :: MarkdownParser (F [Blocks])
1402+pipeTableRow :: PandocMonad m => MarkdownParser m (F [Blocks])
13871403pipeTableRow = try $ do
13881404 scanForPipe
13891405 skipMany spaceChar
@@ -1399,14 +1415,14 @@ pipeTableRow = try $ do
13991415 blankline
14001416 return $ sequence cells
14011417
1402−pipeTableCell :: MarkdownParser (F Blocks)
1418+pipeTableCell :: PandocMonad m => MarkdownParser m (F Blocks)
14031419pipeTableCell = do
14041420 result <- many inline
14051421 if null result
14061422 then return mempty
14071423 else return $ B.plain . mconcat <$> sequence result
14081424
1409−pipeTableHeaderPart :: Parser [Char] st (Alignment, Int)
1425+pipeTableHeaderPart :: PandocMonad m => ParserT [Char] st m (Alignment, Int)
14101426pipeTableHeaderPart = try $ do
14111427 skipMany spaceChar
14121428 left <- optionMaybe (char ':')
@@ -1422,7 +1438,7 @@ pipeTableHeaderPart = try $ do
14221438 (Just _,Just _) -> AlignCenter), len)
14231439
14241440-- Succeed only if current line contains a pipe.
1425−scanForPipe :: Parser [Char] st ()
1441+scanForPipe :: PandocMonad m => ParserT [Char] st m ()
14261442scanForPipe = do
14271443 inp <- getInput
14281444 case break (\c -> c == '\n' || c == '|') inp of
@@ -1432,11 +1448,12 @@ scanForPipe = do
14321448-- | Parse a table using 'headerParser', 'rowParser',
14331449-- 'lineParser', and 'footerParser'. Variant of the version in
14341450-- Text.Pandoc.Parsing.
1435−tableWith :: MarkdownParser (F [Blocks], [Alignment], [Int])
1436− -> ([Int] -> MarkdownParser (F [Blocks]))
1437− -> MarkdownParser sep
1438− -> MarkdownParser end
1439− -> MarkdownParser ([Alignment], [Double], F [Blocks], F [[Blocks]])
1451+tableWith :: PandocMonad m
1452+ => MarkdownParser m (F [Blocks], [Alignment], [Int])
1453+ -> ([Int] -> MarkdownParser m (F [Blocks]))
1454+ -> MarkdownParser m sep
1455+ -> MarkdownParser m end
1456+ -> MarkdownParser m ([Alignment], [Double], F [Blocks], F [[Blocks]])
14401457tableWith headerParser rowParser lineParser footerParser = try $ do
14411458 (heads, aligns, indices) <- headerParser
14421459 lines' <- fmap sequence $ rowParser indices `sepEndBy1` lineParser
@@ -1447,7 +1464,7 @@ tableWith headerParser rowParser lineParser footerParser = try $ do
14471464 else widthsFromIndices numColumns indices
14481465 return $ (aligns, widths, heads, lines')
14491466
1450−table :: MarkdownParser (F Blocks)
1467+table :: PandocMonad m => MarkdownParser m (F Blocks)
14511468table = try $ do
14521469 frontCaption <- option Nothing (Just <$> tableCaption)
14531470 (aligns, widths, heads, lns) <-
@@ -1479,7 +1496,7 @@ table = try $ do
14791496-- inline
14801497--
14811498
1482−inline :: MarkdownParser (F Inlines)
1499+inline :: PandocMonad m => MarkdownParser m (F Inlines)
14831500inline = choice [ whitespace
14841501 , bareURL
14851502 , str
@@ -1509,7 +1526,7 @@ inline = choice [ whitespace
15091526 , ltSign
15101527 ] <?> "inline"
15111528
1512−escapedChar' :: MarkdownParser Char
1529+escapedChar' :: PandocMonad m => MarkdownParser m Char
15131530escapedChar' = try $ do
15141531 char '\\'
15151532 (guardEnabled Ext_all_symbols_escapable >> satisfy (not . isAlphaNum))
@@ -1518,7 +1535,7 @@ escapedChar' = try $ do
15181535 <|> (guardEnabled Ext_escaped_line_breaks >> char '\n')
15191536 <|> oneOf "\\`*_{}[]()>#+-.!~\""
15201537
1521−escapedChar :: MarkdownParser (F Inlines)
1538+escapedChar :: PandocMonad m => MarkdownParser m (F Inlines)
15221539escapedChar = do
15231540 result <- escapedChar'
15241541 case result of
@@ -1527,14 +1544,14 @@ escapedChar = do
15271544 return (return B.linebreak) -- "\[newline]" is a linebreak
15281545 _ -> return $ return $ B.str [result]
15291546
1530−ltSign :: MarkdownParser (F Inlines)
1547+ltSign :: PandocMonad m => MarkdownParser m (F Inlines)
15311548ltSign = do
15321549 guardDisabled Ext_raw_html
15331550 <|> (notFollowedByHtmlCloser >> notFollowedBy' (htmlTag isBlockTag))
15341551 char '<'
15351552 return $ return $ B.str "<"
15361553
1537−exampleRef :: MarkdownParser (F Inlines)
1554+exampleRef :: PandocMonad m => MarkdownParser m (F Inlines)
15381555exampleRef = try $ do
15391556 guardEnabled Ext_example_lists
15401557 char '@'
@@ -1545,7 +1562,7 @@ exampleRef = try $ do
15451562 Just n -> B.str (show n)
15461563 Nothing -> B.str ('@':lab)
15471564
1548−symbol :: MarkdownParser (F Inlines)
1565+symbol :: PandocMonad m => MarkdownParser m (F Inlines)
15491566symbol = do
15501567 result <- noneOf "<\\\n\t "
15511568 <|> try (do lookAhead $ char '\\'
@@ -1554,7 +1571,7 @@ symbol = do
15541571 return $ return $ B.str [result]
15551572
15561573-- parses inline code, between n `s and n `s
1557−code :: MarkdownParser (F Inlines)
1574+code :: PandocMonad m => MarkdownParser m (F Inlines)
15581575code = try $ do
15591576 starts <- many1 (char '`')
15601577 skipSpaces
@@ -1566,16 +1583,17 @@ code = try $ do
15661583 >> attributes)
15671584 return $ return $ B.codeWith attr $ trim $ concat result
15681585
1569−math :: MarkdownParser (F Inlines)
1586+math :: PandocMonad m => MarkdownParser m (F Inlines)
15701587math = (return . B.displayMath <$> (mathDisplay >>= applyMacros'))
15711588 <|> (return . B.math <$> (mathInline >>= applyMacros')) <+?>
1572− ((getOption readerSmart >>= guard) *> (return <$> apostrophe)
1589+ (guardEnabled Ext_smart *> (return <$> apostrophe)
15731590 <* notFollowedBy (space <|> satisfy isPunctuation))
15741591
15751592-- Parses material enclosed in *s, **s, _s, or __s.
15761593-- Designed to avoid backtracking.
1577−enclosure :: Char
1578− -> MarkdownParser (F Inlines)
1594+enclosure :: PandocMonad m
1595+ => Char
1596+ -> MarkdownParser m (F Inlines)
15791597enclosure c = do
15801598 -- we can't start an enclosure with _ if after a string and
15811599 -- the intraword_underscores extension is enabled:
@@ -1591,7 +1609,7 @@ enclosure c = do
15911609 1 -> one c mempty
15921610 _ -> return (return $ B.str cs)
15931611
1594−ender :: Char -> Int -> MarkdownParser ()
1612+ender :: PandocMonad m => Char -> Int -> MarkdownParser m ()
15951613ender c n = try $ do
15961614 count n (char c)
15971615 guard (c == '*')
@@ -1602,7 +1620,7 @@ ender c n = try $ do
16021620-- If one c, emit emph and then parse two.
16031621-- If two cs, emit strong and then parse one.
16041622-- Otherwise, emit ccc then the results.
1605−three :: Char -> MarkdownParser (F Inlines)
1623+three :: PandocMonad m => Char -> MarkdownParser m (F Inlines)
16061624three c = do
16071625 contents <- mconcat <$> many (notFollowedBy (ender c 1) >> inline)
16081626 (ender c 3 >> return ((B.strong . B.emph) <$> contents))
@@ -1612,7 +1630,7 @@ three c = do
16121630
16131631-- Parse inlines til you hit two c's, and emit strong.
16141632-- If you never do hit two cs, emit ** plus inlines parsed.
1615−two :: Char -> F Inlines -> MarkdownParser (F Inlines)
1633+two :: PandocMonad m => Char -> F Inlines -> MarkdownParser m (F Inlines)
16161634two c prefix' = do
16171635 contents <- mconcat <$> many (try $ notFollowedBy (ender c 2) >> inline)
16181636 (ender c 2 >> return (B.strong <$> (prefix' <> contents)))
@@ -1620,7 +1638,7 @@ two c prefix' = do
16201638
16211639-- Parse inlines til you hit a c, and emit emph.
16221640-- If you never hit a c, emit * plus inlines parsed.
1623−one :: Char -> F Inlines -> MarkdownParser (F Inlines)
1641+one :: PandocMonad m => Char -> F Inlines -> MarkdownParser m (F Inlines)
16241642one c prefix' = do
16251643 contents <- mconcat <$> many ( (notFollowedBy (ender c 1) >> inline)
16261644 <|> try (string [c,c] >>
@@ -1629,52 +1647,53 @@ one c prefix' = do
16291647 (ender c 1 >> return (B.emph <$> (prefix' <> contents)))
16301648 <|> return (return (B.str [c]) <> (prefix' <> contents))
16311649
1632−strongOrEmph :: MarkdownParser (F Inlines)
1650+strongOrEmph :: PandocMonad m => MarkdownParser m (F Inlines)
16331651strongOrEmph = enclosure '*' <|> enclosure '_'
16341652
16351653-- | Parses a list of inlines between start and end delimiters.
1636−inlinesBetween :: (Show b)
1637− => MarkdownParser a
1638− -> MarkdownParser b
1639− -> MarkdownParser (F Inlines)
1654+inlinesBetween :: PandocMonad m
1655+ => (Show b)
1656+ => MarkdownParser m a
1657+ -> MarkdownParser m b
1658+ -> MarkdownParser m (F Inlines)
16401659inlinesBetween start end =
16411660 (trimInlinesF . mconcat) <$> try (start >> many1Till inner end)
16421661 where inner = innerSpace <|> (notFollowedBy' (() <$ whitespace) >> inline)
16431662 innerSpace = try $ whitespace <* notFollowedBy' end
16441663
1645−strikeout :: MarkdownParser (F Inlines)
1664+strikeout :: PandocMonad m => MarkdownParser m (F Inlines)
16461665strikeout = fmap B.strikeout <$>
16471666 (guardEnabled Ext_strikeout >> inlinesBetween strikeStart strikeEnd)
16481667 where strikeStart = string "~~" >> lookAhead nonspaceChar
16491668 >> notFollowedBy (char '~')
16501669 strikeEnd = try $ string "~~"
16511670
1652−superscript :: MarkdownParser (F Inlines)
1671+superscript :: PandocMonad m => MarkdownParser m (F Inlines)
16531672superscript = fmap B.superscript <$> try (do
16541673 guardEnabled Ext_superscript
16551674 char '^'
16561675 mconcat <$> many1Till (notFollowedBy spaceChar >> inline) (char '^'))
16571676
1658−subscript :: MarkdownParser (F Inlines)
1677+subscript :: PandocMonad m => MarkdownParser m (F Inlines)
16591678subscript = fmap B.subscript <$> try (do
16601679 guardEnabled Ext_subscript
16611680 char '~'
16621681 mconcat <$> many1Till (notFollowedBy spaceChar >> inline) (char '~'))
16631682
1664−whitespace :: MarkdownParser (F Inlines)
1683+whitespace :: PandocMonad m => MarkdownParser m (F Inlines)
16651684whitespace = spaceChar >> return <$> (lb <|> regsp) <?> "whitespace"
16661685 where lb = spaceChar >> skipMany spaceChar >> option B.space (endline >> return B.linebreak)
16671686 regsp = skipMany spaceChar >> return B.space
16681687
1669−nonEndline :: Parser [Char] st Char
1688+nonEndline :: PandocMonad m => ParserT [Char] st m Char
16701689nonEndline = satisfy (/='\n')
16711690
1672−str :: MarkdownParser (F Inlines)
1691+str :: PandocMonad m => MarkdownParser m (F Inlines)
16731692str = do
16741693 result <- many1 alphaNum
16751694 updateLastStrPos
16761695 let spacesToNbr = map (\c -> if c == ' ' then '\160' else c)
1677− isSmart <- getOption readerSmart
1696+ isSmart <- extensionEnabled Ext_smart <$> getOption readerExtensions
16781697 if isSmart
16791698 then case likelyAbbrev result of
16801699 [] -> return $ return $ B.str result
@@ -1699,7 +1718,7 @@ likelyAbbrev x =
16991718 in map snd $ filter (\(y,_) -> y == x) abbrPairs
17001719
17011720-- an endline character that can be treated as a space, not a structural break
1702−endline :: MarkdownParser (F Inlines)
1721+endline :: PandocMonad m => MarkdownParser m (F Inlines)
17031722endline = try $ do
17041723 newline
17051724 notFollowedBy blankline
@@ -1721,17 +1740,17 @@ endline = try $ do
17211740--
17221741
17231742-- a reference label for a link
1724−reference :: MarkdownParser (F Inlines, String)
1743+reference :: PandocMonad m => MarkdownParser m (F Inlines, String)
17251744reference = do notFollowedBy' (string "[^") -- footnote reference
17261745 withRaw $ trimInlinesF <$> inlinesInBalancedBrackets
17271746
1728−parenthesizedChars :: MarkdownParser [Char]
1747+parenthesizedChars :: PandocMonad m => MarkdownParser m [Char]
17291748parenthesizedChars = do
17301749 result <- charsInBalanced '(' ')' litChar
17311750 return $ '(' : result ++ ")"
17321751
17331752-- source for a link, with optional title
1734−source :: MarkdownParser (String, String)
1753+source :: PandocMonad m => MarkdownParser m (String, String)
17351754source = do
17361755 char '('
17371756 skipSpaces
@@ -1748,10 +1767,10 @@ source = do
17481767 char ')'
17491768 return (escapeURI $ trimr src, tit)
17501769
1751−linkTitle :: MarkdownParser String
1770+linkTitle :: PandocMonad m => MarkdownParser m String
17521771linkTitle = quotedTitle '"' <|> quotedTitle '\''
17531772
1754−link :: MarkdownParser (F Inlines)
1773+link :: PandocMonad m => MarkdownParser m (F Inlines)
17551774link = try $ do
17561775 st <- getState
17571776 guard $ stateAllowLinks st
@@ -1760,7 +1779,7 @@ link = try $ do
17601779 setState $ st{ stateAllowLinks = True }
17611780 regLink B.linkWith lab <|> referenceLink B.linkWith (lab,raw)
17621781
1763−bracketedSpan :: MarkdownParser (F Inlines)
1782+bracketedSpan :: PandocMonad m => MarkdownParser m (F Inlines)
17641783bracketedSpan = try $ do
17651784 guardEnabled Ext_bracketed_spans
17661785 (lab,_) <- reference
@@ -1773,8 +1792,10 @@ bracketedSpan = try $ do
17731792 -> return $ B.smallcaps <$> lab
17741793 _ -> return $ B.spanWith attr <$> lab
17751794
1776−regLink :: (Attr -> String -> String -> Inlines -> Inlines)
1777− -> F Inlines -> MarkdownParser (F Inlines)
1795+regLink :: PandocMonad m
1796+ => (Attr -> String -> String -> Inlines -> Inlines)
1797+ -> F Inlines
1798+ -> MarkdownParser m (F Inlines)
17781799regLink constructor lab = try $ do
17791800 (src, tit) <- source
17801801 attr <- option nullAttr $
@@ -1782,8 +1803,10 @@ regLink constructor lab = try $ do
17821803 return $ constructor attr src tit <$> lab
17831804
17841805-- a link like [this][ref] or [this][] or [this]
1785−referenceLink :: (Attr -> String -> String -> Inlines -> Inlines)
1786− -> (F Inlines, String) -> MarkdownParser (F Inlines)
1806+referenceLink :: PandocMonad m
1807+ => (Attr -> String -> String -> Inlines -> Inlines)
1808+ -> (F Inlines, String)
1809+ -> MarkdownParser m (F Inlines)
17871810referenceLink constructor (lab, raw) = do
17881811 sp <- (True <$ lookAhead (char ' ')) <|> return False
17891812 (_,raw') <- option (mempty, "") $
@@ -1824,7 +1847,7 @@ dropBrackets = reverse . dropRB . reverse . dropLB
18241847 dropLB ('[':xs) = xs
18251848 dropLB xs = xs
18261849
1827−bareURL :: MarkdownParser (F Inlines)
1850+bareURL :: PandocMonad m => MarkdownParser m (F Inlines)
18281851bareURL = try $ do
18291852 guardEnabled Ext_autolink_bare_uris
18301853 getState >>= guard . stateAllowLinks
@@ -1832,7 +1855,7 @@ bareURL = try $ do
18321855 notFollowedBy $ try $ spaces >> htmlTag (~== TagClose "a")
18331856 return $ return $ B.link src "" (B.str orig)
18341857
1835−autoLink :: MarkdownParser (F Inlines)
1858+autoLink :: PandocMonad m => MarkdownParser m (F Inlines)
18361859autoLink = try $ do
18371860 getState >>= guard . stateAllowLinks
18381861 char '<'
@@ -1846,7 +1869,7 @@ autoLink = try $ do
18461869 guardEnabled Ext_link_attributes >> attributes
18471870 return $ return $ B.linkWith attr (src ++ escapeURI extra) "" (B.str $ orig ++ extra)
18481871
1849−image :: MarkdownParser (F Inlines)
1872+image :: PandocMonad m => MarkdownParser m (F Inlines)
18501873image = try $ do
18511874 char '!'
18521875 (lab,raw) <- reference
@@ -1856,7 +1879,7 @@ image = try $ do
18561879 _ -> B.imageWith attr' src
18571880 regLink constructor lab <|> referenceLink constructor (lab,raw)
18581881
1859−note :: MarkdownParser (F Inlines)
1882+note :: PandocMonad m => MarkdownParser m (F Inlines)
18601883note = try $ do
18611884 guardEnabled Ext_footnotes
18621885 ref <- noteMarker
@@ -1872,14 +1895,14 @@ note = try $ do
18721895 let contents' = runF contents st{ stateNotes' = [] }
18731896 return $ B.note contents'
18741897
1875−inlineNote :: MarkdownParser (F Inlines)
1898+inlineNote :: PandocMonad m => MarkdownParser m (F Inlines)
18761899inlineNote = try $ do
18771900 guardEnabled Ext_inline_notes
18781901 char '^'
18791902 contents <- inlinesInBalancedBrackets
18801903 return $ B.note . B.para <$> contents
18811904
1882−rawLaTeXInline' :: MarkdownParser (F Inlines)
1905+rawLaTeXInline' :: PandocMonad m => MarkdownParser m (F Inlines)
18831906rawLaTeXInline' = try $ do
18841907 guardEnabled Ext_raw_tex
18851908 lookAhead $ char '\\' >> notFollowedBy' (string "start") -- context env
@@ -1887,7 +1910,7 @@ rawLaTeXInline' = try $ do
18871910 return $ return $ B.rawInline "tex" s
18881911 -- "tex" because it might be context or latex
18891912
1890−rawConTeXtEnvironment :: Parser [Char] st String
1913+rawConTeXtEnvironment :: PandocMonad m => ParserT [Char] st m String
18911914rawConTeXtEnvironment = try $ do
18921915 string "\\start"
18931916 completion <- inBrackets (letter <|> digit <|> spaceChar)
@@ -1896,14 +1919,14 @@ rawConTeXtEnvironment = try $ do
18961919 (try $ string "\\stop" >> string completion)
18971920 return $ "\\start" ++ completion ++ concat contents ++ "\\stop" ++ completion
18981921
1899−inBrackets :: (Parser [Char] st Char) -> Parser [Char] st String
1922+inBrackets :: PandocMonad m => (ParserT [Char] st m Char) -> ParserT [Char] st m String
19001923inBrackets parser = do
19011924 char '['
19021925 contents <- many parser
19031926 char ']'
19041927 return $ "[" ++ contents ++ "]"
19051928
1906−spanHtml :: MarkdownParser (F Inlines)
1929+spanHtml :: PandocMonad m => MarkdownParser m (F Inlines)
19071930spanHtml = try $ do
19081931 guardEnabled Ext_native_spans
19091932 (TagOpen _ attrs, _) <- htmlTag (~== TagOpen "span" [])
@@ -1918,7 +1941,7 @@ spanHtml = try $ do
19181941 -> return $ B.smallcaps <$> contents
19191942 _ -> return $ B.spanWith (ident, classes, keyvals) <$> contents
19201943
1921−divHtml :: MarkdownParser (F Blocks)
1944+divHtml :: PandocMonad m => MarkdownParser m (F Blocks)
19221945divHtml = try $ do
19231946 guardEnabled Ext_native_divs
19241947 (TagOpen _ attrs, rawtag) <- htmlTag (~== TagOpen "div" [])
@@ -1940,7 +1963,7 @@ divHtml = try $ do
19401963 else -- avoid backtracing
19411964 return $ return (B.rawBlock "html" (rawtag <> bls)) <> contents
19421965
1943−rawHtmlInline :: MarkdownParser (F Inlines)
1966+rawHtmlInline :: PandocMonad m => MarkdownParser m (F Inlines)
19441967rawHtmlInline = do
19451968 guardEnabled Ext_raw_html
19461969 inHtmlBlock <- stateInHtmlBlock <$> getState
@@ -1962,7 +1985,7 @@ rawHtmlInline = do
19621985emojiChars :: [Char]
19631986emojiChars = ['a'..'z'] ++ ['0'..'9'] ++ ['_','+','-']
19641987
1965−emoji :: MarkdownParser (F Inlines)
1988+emoji :: PandocMonad m => MarkdownParser m (F Inlines)
19661989emoji = try $ do
19671990 guardEnabled Ext_emoji
19681991 char ':'
@@ -1974,7 +1997,7 @@ emoji = try $ do
19741997
19751998-- Citations
19761999
1977−cite :: MarkdownParser (F Inlines)
2000+cite :: PandocMonad m => MarkdownParser m (F Inlines)
19782001cite = do
19792002 guardEnabled Ext_citations
19802003 citations <- textualCite
@@ -1982,7 +2005,7 @@ cite = do
19822005 return $ (flip B.cite (B.text raw)) <$> cs
19832006 return citations
19842007
1985−textualCite :: MarkdownParser (F Inlines)
2008+textualCite :: PandocMonad m => MarkdownParser m (F Inlines)
19862009textualCite = try $ do
19872010 (_, key) <- citeKey
19882011 let first = Citation{ citationId = key
@@ -2017,7 +2040,7 @@ textualCite = try $ do
20172040 Just n -> B.str (show n)
20182041 _ -> B.cite [first] $ B.str $ '@':key)
20192042
2020−bareloc :: Citation -> MarkdownParser (F [Citation])
2043+bareloc :: PandocMonad m => Citation -> MarkdownParser m (F [Citation])
20212044bareloc c = try $ do
20222045 spnl
20232046 char '['
@@ -2032,7 +2055,7 @@ bareloc c = try $ do
20322055 rest' <- rest
20332056 return $ c{ citationSuffix = B.toList suff' } : rest'
20342057
2035−normalCite :: MarkdownParser (F [Citation])
2058+normalCite :: PandocMonad m => MarkdownParser m (F [Citation])
20362059normalCite = try $ do
20372060 char '['
20382061 spnl
@@ -2041,7 +2064,7 @@ normalCite = try $ do
20412064 char ']'
20422065 return citations
20432066
2044−suffix :: MarkdownParser (F Inlines)
2067+suffix :: PandocMonad m => MarkdownParser m (F Inlines)
20452068suffix = try $ do
20462069 hasSpace <- option False (notFollowedBy nonspaceChar >> return True)
20472070 spnl
@@ -2050,14 +2073,14 @@ suffix = try $ do
20502073 then (B.space <>) <$> rest
20512074 else rest
20522075
2053−prefix :: MarkdownParser (F Inlines)
2076+prefix :: PandocMonad m => MarkdownParser m (F Inlines)
20542077prefix = trimInlinesF . mconcat <$>
20552078 manyTill inline (char ']' <|> liftM (const ']') (lookAhead citeKey))
20562079
2057−citeList :: MarkdownParser (F [Citation])
2080+citeList :: PandocMonad m => MarkdownParser m (F [Citation])
20582081citeList = fmap sequence $ sepBy1 citation (try $ char ';' >> spnl)
20592082
2060−citation :: MarkdownParser (F Citation)
2083+citation :: PandocMonad m => MarkdownParser m (F Citation)
20612084citation = try $ do
20622085 pref <- prefix
20632086 (suppress_author, key) <- citeKey
@@ -2075,13 +2098,13 @@ citation = try $ do
20752098 , citationHash = 0
20762099 }
20772100
2078−smart :: MarkdownParser (F Inlines)
2101+smart :: PandocMonad m => MarkdownParser m (F Inlines)
20792102smart = do
2080− getOption readerSmart >>= guard
2103+ guardEnabled Ext_smart
20812104 doubleQuoted <|> singleQuoted <|>
20822105 choice (map (return <$>) [apostrophe, dash, ellipses])
20832106
2084−singleQuoted :: MarkdownParser (F Inlines)
2107+singleQuoted :: PandocMonad m => MarkdownParser m (F Inlines)
20852108singleQuoted = try $ do
20862109 singleQuoteStart
20872110 withQuoteContext InSingleQuote $
@@ -2091,7 +2114,7 @@ singleQuoted = try $ do
20912114-- doubleQuoted will handle regular double-quoted sections, as well
20922115-- as dialogues with an open double-quote without a close double-quote
20932116-- in the same paragraph.
2094−doubleQuoted :: MarkdownParser (F Inlines)
2117+doubleQuoted :: PandocMonad m => MarkdownParser m (F Inlines)
20952118doubleQuoted = try $ do
20962119 doubleQuoteStart
20972120 contents <- mconcat <$> many (try $ notFollowedBy doubleQuoteEnd >> inline)