@@ -155,13 +155,13 @@ type Parser t s = Parsec t s
155155a >>~ b = a >>= \x -> b >> return x
156156
157157-- | Parse any line of text
158−anyLine :: Parsec [Char] st [Char]
158+anyLine :: Parser [Char] st [Char]
159159anyLine = manyTill anyChar newline
160160
161161-- | Like @manyTill@, but reads at least one item.
162−many1Till :: Parsec [tok] st a
163− -> Parsec [tok] st end
164− -> Parsec [tok] st [a]
162+many1Till :: Parser [tok] st a
163+ -> Parser [tok] st end
164+ -> Parser [tok] st [a]
165165many1Till p end = do
166166 first <- p
167167 rest <- manyTill p end
@@ -170,7 +170,7 @@ many1Till p end = do
170170-- | A more general form of @notFollowedBy@. This one allows any
171171-- type of parser to be specified, and succeeds only if that parser fails.
172172-- It does not consume any input.
173−notFollowedBy' :: Show b => Parsec [a] st b -> Parsec [a] st ()
173+notFollowedBy' :: Show b => Parser [a] st b -> Parser [a] st ()
174174notFollowedBy' p = try $ join $ do a <- try p
175175 return (unexpected (show a))
176176 <|>
@@ -178,7 +178,7 @@ notFollowedBy' p = try $ join $ do a <- try p
178178-- (This version due to Andrew Pimlott on the Haskell mailing list.)
179179
180180-- | Parses one of a list of strings (tried in order).
181−oneOfStrings :: [String] -> Parsec [Char] st String
181+oneOfStrings :: [String] -> Parser [Char] st String
182182oneOfStrings [] = fail "no strings"
183183oneOfStrings strs = do
184184 c <- anyChar
@@ -189,35 +189,35 @@ oneOfStrings strs = do
189189 | otherwise -> (c:) `fmap` oneOfStrings strs'
190190
191191-- | Parses a space or tab.
192−spaceChar :: Parsec [Char] st Char
192+spaceChar :: Parser [Char] st Char
193193spaceChar = satisfy $ \c -> c == ' ' || c == '\t'
194194
195195-- | Parses a nonspace, nonnewline character.
196−nonspaceChar :: Parsec [Char] st Char
196+nonspaceChar :: Parser [Char] st Char
197197nonspaceChar = satisfy $ \x -> x /= '\t' && x /= '\n' && x /= ' ' && x /= '\r'
198198
199199-- | Skips zero or more spaces or tabs.
200−skipSpaces :: Parsec [Char] st ()
200+skipSpaces :: Parser [Char] st ()
201201skipSpaces = skipMany spaceChar
202202
203203-- | Skips zero or more spaces or tabs, then reads a newline.
204−blankline :: Parsec [Char] st Char
204+blankline :: Parser [Char] st Char
205205blankline = try $ skipSpaces >> newline
206206
207207-- | Parses one or more blank lines and returns a string of newlines.
208−blanklines :: Parsec [Char] st [Char]
208+blanklines :: Parser [Char] st [Char]
209209blanklines = many1 blankline
210210
211211-- | Parses material enclosed between start and end parsers.
212−enclosed :: Parsec [Char] st t -- ^ start parser
213− -> Parsec [Char] st end -- ^ end parser
214− -> Parsec [Char] st a -- ^ content parser (to be used repeatedly)
215− -> Parsec [Char] st [a]
212+enclosed :: Parser [Char] st t -- ^ start parser
213+ -> Parser [Char] st end -- ^ end parser
214+ -> Parser [Char] st a -- ^ content parser (to be used repeatedly)
215+ -> Parser [Char] st [a]
216216enclosed start end parser = try $
217217 start >> notFollowedBy space >> many1Till parser end
218218
219219-- | Parse string, case insensitive.
220−stringAnyCase :: [Char] -> Parsec [Char] st String
220+stringAnyCase :: [Char] -> Parser [Char] st String
221221stringAnyCase [] = string ""
222222stringAnyCase (x:xs) = do
223223 firstChar <- char (toUpper x) <|> char (toLower x)
@@ -225,7 +225,7 @@ stringAnyCase (x:xs) = do
225225 return (firstChar:rest)
226226
227227-- | Parse contents of 'str' using 'parser' and return result.
228−parseFromString :: Parsec [tok] st a -> [tok] -> Parsec [tok] st a
228+parseFromString :: Parser [tok] st a -> [tok] -> Parser [tok] st a
229229parseFromString parser str = do
230230 oldPos <- getPosition
231231 oldInput <- getInput
@@ -236,7 +236,7 @@ parseFromString parser str = do
236236 return result
237237
238238-- | Parse raw line block up to and including blank lines.
239−lineClump :: Parsec [Char] st String
239+lineClump :: Parser [Char] st String
240240lineClump = blanklines
241241 <|> (many1 (notFollowedBy blankline >> anyLine) >>= return . unlines)
242242
@@ -245,8 +245,8 @@ lineClump = blanklines
245245-- pairs of open and close, which must be different. For example,
246246-- @charsInBalanced '(' ')' anyChar@ will parse "(hello (there))"
247247-- and return "hello (there)".
248−charsInBalanced :: Char -> Char -> Parsec [Char] st Char
249− -> Parsec [Char] st String
248+charsInBalanced :: Char -> Char -> Parser [Char] st Char
249+ -> Parser [Char] st String
250250charsInBalanced open close parser = try $ do
251251 char open
252252 let isDelim c = c == open || c == close
@@ -271,7 +271,7 @@ uppercaseRomanDigits = map toUpper lowercaseRomanDigits
271271
272272-- | Parses a roman numeral (uppercase or lowercase), returns number.
273273romanNumeral :: Bool -- ^ Uppercase if true
274− -> Parsec [Char] st Int
274+ -> Parser [Char] st Int
275275romanNumeral upperCase = do
276276 let romanDigits = if upperCase
277277 then uppercaseRomanDigits
@@ -301,14 +301,14 @@ romanNumeral upperCase = do
301301
302302-- Parsers for email addresses and URIs
303303
304−emailChar :: Parsec [Char] st Char
304+emailChar :: Parser [Char] st Char
305305emailChar = alphaNum <|>
306306 satisfy (\c -> c == '-' || c == '+' || c == '_' || c == '.')
307307
308−domainChar :: Parsec [Char] st Char
308+domainChar :: Parser [Char] st Char
309309domainChar = alphaNum <|> char '-'
310310
311−domain :: Parsec [Char] st [Char]
311+domain :: Parser [Char] st [Char]
312312domain = do
313313 first <- many1 domainChar
314314 dom <- many1 $ try (char '.' >> many1 domainChar )
@@ -316,7 +316,7 @@ domain = do
316316
317317-- | Parses an email address; returns original and corresponding
318318-- escaped mailto: URI.
319−emailAddress :: Parsec [Char] st (String, String)
319+emailAddress :: Parser [Char] st (String, String)
320320emailAddress = try $ do
321321 firstLetter <- alphaNum
322322 restAddr <- many emailChar
@@ -327,7 +327,7 @@ emailAddress = try $ do
327327 return (full, escapeURI $ "mailto:" ++ full)
328328
329329-- | Parses a URI. Returns pair of original and URI-escaped version.
330−uri :: Parsec [Char] st (String, String)
330+uri :: Parser [Char] st (String, String)
331331uri = try $ do
332332 let protocols = [ "http:", "https:", "ftp:", "file:", "mailto:",
333333 "news:", "telnet:" ]
@@ -361,8 +361,8 @@ uri = try $ do
361361-- displacement (the difference between the source column at the end
362362-- and the source column at the beginning). Vertical displacement
363363-- (source row) is ignored.
364−withHorizDisplacement :: Parsec [Char] st a -- ^ Parser to apply
365− -> Parsec [Char] st (a, Int) -- ^ (result, displacement)
364+withHorizDisplacement :: Parser [Char] st a -- ^ Parser to apply
365+ -> Parser [Char] st (a, Int) -- ^ (result, displacement)
366366withHorizDisplacement parser = do
367367 pos1 <- getPosition
368368 result <- parser
@@ -371,7 +371,7 @@ withHorizDisplacement parser = do
371371
372372-- | Applies a parser and returns the raw string that was parsed,
373373-- along with the value produced by the parser.
374−withRaw :: Parsec [Char] st a -> Parsec [Char] st (a, [Char])
374+withRaw :: Parser [Char] st a -> Parser [Char] st (a, [Char])
375375withRaw parser = do
376376 pos1 <- getPosition
377377 inp <- getInput
@@ -388,20 +388,20 @@ withRaw parser = do
388388
389389-- | Parses a character and returns 'Null' (so that the parser can move on
390390-- if it gets stuck).
391−nullBlock :: Parsec [Char] st Block
391+nullBlock :: Parser [Char] st Block
392392nullBlock = anyChar >> return Null
393393
394394-- | Fail unless we're in literate haskell mode.
395−failUnlessLHS :: Parsec [tok] ParserState ()
395+failUnlessLHS :: Parser [tok] ParserState ()
396396failUnlessLHS = getOption readerLiterateHaskell >>= guard
397397
398398-- | Parses backslash, then applies character parser.
399−escaped :: Parsec [Char] st Char -- ^ Parser for character to escape
400− -> Parsec [Char] st Char
399+escaped :: Parser [Char] st Char -- ^ Parser for character to escape
400+ -> Parser [Char] st Char
401401escaped parser = try $ char '\\' >> parser
402402
403403-- | Parse character entity.
404−characterReference :: Parsec [Char] st Char
404+characterReference :: Parser [Char] st Char
405405characterReference = try $ do
406406 char '&'
407407 ent <- many1Till nonspaceChar (char ';')
@@ -410,19 +410,19 @@ characterReference = try $ do
410410 Nothing -> fail "entity not found"
411411
412412-- | Parses an uppercase roman numeral and returns (UpperRoman, number).
413−upperRoman :: Parsec [Char] st (ListNumberStyle, Int)
413+upperRoman :: Parser [Char] st (ListNumberStyle, Int)
414414upperRoman = do
415415 num <- romanNumeral True
416416 return (UpperRoman, num)
417417
418418-- | Parses a lowercase roman numeral and returns (LowerRoman, number).
419−lowerRoman :: Parsec [Char] st (ListNumberStyle, Int)
419+lowerRoman :: Parser [Char] st (ListNumberStyle, Int)
420420lowerRoman = do
421421 num <- romanNumeral False
422422 return (LowerRoman, num)
423423
424424-- | Parses a decimal numeral and returns (Decimal, number).
425−decimal :: Parsec [Char] st (ListNumberStyle, Int)
425+decimal :: Parser [Char] st (ListNumberStyle, Int)
426426decimal = do
427427 num <- many1 digit
428428 return (Decimal, read num)
@@ -431,7 +431,7 @@ decimal = do
431431-- returns (DefaultStyle, [next example number]). The next
432432-- example number is incremented in parser state, and the label
433433-- (if present) is added to the label table.
434−exampleNum :: Parsec [Char] ParserState (ListNumberStyle, Int)
434+exampleNum :: Parser [Char] ParserState (ListNumberStyle, Int)
435435exampleNum = do
436436 char '@'
437437 lab <- many (alphaNum <|> satisfy (\c -> c == '_' || c == '-'))
@@ -445,38 +445,38 @@ exampleNum = do
445445 return (Example, num)
446446
447447-- | Parses a '#' returns (DefaultStyle, 1).
448−defaultNum :: Parsec [Char] st (ListNumberStyle, Int)
448+defaultNum :: Parser [Char] st (ListNumberStyle, Int)
449449defaultNum = do
450450 char '#'
451451 return (DefaultStyle, 1)
452452
453453-- | Parses a lowercase letter and returns (LowerAlpha, number).
454−lowerAlpha :: Parsec [Char] st (ListNumberStyle, Int)
454+lowerAlpha :: Parser [Char] st (ListNumberStyle, Int)
455455lowerAlpha = do
456456 ch <- oneOf ['a'..'z']
457457 return (LowerAlpha, ord ch - ord 'a' + 1)
458458
459459-- | Parses an uppercase letter and returns (UpperAlpha, number).
460−upperAlpha :: Parsec [Char] st (ListNumberStyle, Int)
460+upperAlpha :: Parser [Char] st (ListNumberStyle, Int)
461461upperAlpha = do
462462 ch <- oneOf ['A'..'Z']
463463 return (UpperAlpha, ord ch - ord 'A' + 1)
464464
465465-- | Parses a roman numeral i or I
466−romanOne :: Parsec [Char] st (ListNumberStyle, Int)
466+romanOne :: Parser [Char] st (ListNumberStyle, Int)
467467romanOne = (char 'i' >> return (LowerRoman, 1)) <|>
468468 (char 'I' >> return (UpperRoman, 1))
469469
470470-- | Parses an ordered list marker and returns list attributes.
471−anyOrderedListMarker :: Parsec [Char] ParserState ListAttributes
471+anyOrderedListMarker :: Parser [Char] ParserState ListAttributes
472472anyOrderedListMarker = choice $
473473 [delimParser numParser | delimParser <- [inPeriod, inOneParen, inTwoParens],
474474 numParser <- [decimal, exampleNum, defaultNum, romanOne,
475475 lowerAlpha, lowerRoman, upperAlpha, upperRoman]]
476476
477477-- | Parses a list number (num) followed by a period, returns list attributes.
478−inPeriod :: Parsec [Char] st (ListNumberStyle, Int)
479− -> Parsec [Char] st ListAttributes
478+inPeriod :: Parser [Char] st (ListNumberStyle, Int)
479+ -> Parser [Char] st ListAttributes
480480inPeriod num = try $ do
481481 (style, start) <- num
482482 char '.'
@@ -486,16 +486,16 @@ inPeriod num = try $ do
486486 return (start, style, delim)
487487
488488-- | Parses a list number (num) followed by a paren, returns list attributes.
489−inOneParen :: Parsec [Char] st (ListNumberStyle, Int)
490− -> Parsec [Char] st ListAttributes
489+inOneParen :: Parser [Char] st (ListNumberStyle, Int)
490+ -> Parser [Char] st ListAttributes
491491inOneParen num = try $ do
492492 (style, start) <- num
493493 char ')'
494494 return (start, style, OneParen)
495495
496496-- | Parses a list number (num) enclosed in parens, returns list attributes.
497−inTwoParens :: Parsec [Char] st (ListNumberStyle, Int)
498− -> Parsec [Char] st ListAttributes
497+inTwoParens :: Parser [Char] st (ListNumberStyle, Int)
498+ -> Parser [Char] st ListAttributes
499499inTwoParens num = try $ do
500500 char '('
501501 (style, start) <- num
@@ -506,7 +506,7 @@ inTwoParens num = try $ do
506506-- returns number.
507507orderedListMarker :: ListNumberStyle
508508 -> ListNumberDelim
509− -> Parsec [Char] ParserState Int
509+ -> Parser [Char] ParserState Int
510510orderedListMarker style delim = do
511511 let num = defaultNum <|> -- # can continue any kind of list
512512 case style of
@@ -526,18 +526,18 @@ orderedListMarker style delim = do
526526 return start
527527
528528-- | Parses a character reference and returns a Str element.
529−charRef :: Parsec [Char] st Inline
529+charRef :: Parser [Char] st Inline
530530charRef = do
531531 c <- characterReference
532532 return $ Str [c]
533533
534534-- | Parse a table using 'headerParser', 'rowParser',
535535-- 'lineParser', and 'footerParser'.
536−tableWith :: Parsec [Char] ParserState ([[Block]], [Alignment], [Int])
537− -> ([Int] -> Parsec [Char] ParserState [[Block]])
538− -> Parsec [Char] ParserState sep
539− -> Parsec [Char] ParserState end
540− -> Parsec [Char] ParserState Block
536+tableWith :: Parser [Char] ParserState ([[Block]], [Alignment], [Int])
537+ -> ([Int] -> Parser [Char] ParserState [[Block]])
538+ -> Parser [Char] ParserState sep
539+ -> Parser [Char] ParserState end
540+ -> Parser [Char] ParserState Block
541541tableWith headerParser rowParser lineParser footerParser = try $ do
542542 (heads, aligns, indices) <- headerParser
543543 lines' <- rowParser indices `sepEndBy1` lineParser
@@ -579,9 +579,9 @@ widthsFromIndices numColumns' indices =
579579-- (which may be grid), then the rows,
580580-- which may be grid, separated by blank lines, and
581581-- ending with a footer (dashed line followed by blank line).
582−gridTableWith :: Parsec [Char] ParserState Block -- ^ Block parser
582+gridTableWith :: Parser [Char] ParserState Block -- ^ Block parser
583583 -> Bool -- ^ Headerless table
584− -> Parsec [Char] ParserState Block
584+ -> Parser [Char] ParserState Block
585585gridTableWith block headless =
586586 tableWith (gridTableHeader headless block) (gridTableRow block) (gridTableSep '-') gridTableFooter
587587
@@ -589,13 +589,13 @@ gridTableSplitLine :: [Int] -> String -> [String]
589589gridTableSplitLine indices line = map removeFinalBar $ tail $
590590 splitStringByIndices (init indices) $ removeTrailingSpace line
591591
592−gridPart :: Char -> Parsec [Char] st (Int, Int)
592+gridPart :: Char -> Parser [Char] st (Int, Int)
593593gridPart ch = do
594594 dashes <- many1 (char ch)
595595 char '+'
596596 return (length dashes, length dashes + 1)
597597
598−gridDashedLines :: Char -> Parsec [Char] st [(Int,Int)]
598+gridDashedLines :: Char -> Parser [Char] st [(Int,Int)]
599599gridDashedLines ch = try $ char '+' >> many1 (gridPart ch) >>~ blankline
600600
601601removeFinalBar :: String -> String
@@ -603,13 +603,13 @@ removeFinalBar =
603603 reverse . dropWhile (`elem` " \t") . dropWhile (=='|') . reverse
604604
605605-- | Separator between rows of grid table.
606−gridTableSep :: Char -> Parsec [Char] ParserState Char
606+gridTableSep :: Char -> Parser [Char] ParserState Char
607607gridTableSep ch = try $ gridDashedLines ch >> return '\n'
608608
609609-- | Parse header for a grid table.
610610gridTableHeader :: Bool -- ^ Headerless table
611− -> Parsec [Char] ParserState Block
612− -> Parsec [Char] ParserState ([[Block]], [Alignment], [Int])
611+ -> Parser [Char] ParserState Block
612+ -> Parser [Char] ParserState ([[Block]], [Alignment], [Int])
613613gridTableHeader headless block = try $ do
614614 optional blanklines
615615 dashes <- gridDashedLines '-'
@@ -633,16 +633,16 @@ gridTableHeader headless block = try $ do
633633 map removeLeadingTrailingSpace rawHeads
634634 return (heads, aligns, indices)
635635
636−gridTableRawLine :: [Int] -> Parsec [Char] ParserState [String]
636+gridTableRawLine :: [Int] -> Parser [Char] ParserState [String]
637637gridTableRawLine indices = do
638638 char '|'
639639 line <- many1Till anyChar newline
640640 return (gridTableSplitLine indices line)
641641
642642-- | Parse row of grid table.
643−gridTableRow :: Parsec [Char] ParserState Block
643+gridTableRow :: Parser [Char] ParserState Block
644644 -> [Int]
645− -> Parsec [Char] ParserState [[Block]]
645+ -> Parser [Char] ParserState [[Block]]
646646gridTableRow block indices = do
647647 colLines <- many1 (gridTableRawLine indices)
648648 let cols = map ((++ "\n") . unlines . removeOneLeadingSpace) $
@@ -661,13 +661,13 @@ compactifyCell :: [Block] -> [Block]
661661compactifyCell bs = head $ compactify [bs]
662662
663663-- | Parse footer for a grid table.
664−gridTableFooter :: Parsec [Char] ParserState [Char]
664+gridTableFooter :: Parser [Char] ParserState [Char]
665665gridTableFooter = blanklines
666666
667667---
668668
669669-- | Parse a string with a given parser and state.
670−readWith :: Parsec [t] ParserState a -- ^ parser
670+readWith :: Parser [t] ParserState a -- ^ parser
671671 -> ParserState -- ^ initial state
672672 -> [t] -- ^ input
673673 -> a
@@ -677,7 +677,7 @@ readWith parser state input =
677677 Right result -> result
678678
679679-- | Parse a string with @parser@ (for testing).
680−testStringWith :: (Show a) => Parsec [Char] ParserState a
680+testStringWith :: (Show a) => Parser [Char] ParserState a
681681 -> String
682682 -> IO ()
683683testStringWith parser str = UTF8.putStrLn $ show $
@@ -781,25 +781,25 @@ lookupKeySrc table key = case M.lookup key table of
781781 Just src -> Just src
782782
783783-- | Fail unless we're in "smart typography" mode.
784−failUnlessSmart :: Parsec [tok] ParserState ()
784+failUnlessSmart :: Parser [tok] ParserState ()
785785failUnlessSmart = getOption readerSmart >>= guard
786786
787−smartPunctuation :: Parsec [Char] ParserState Inline
788− -> Parsec [Char] ParserState Inline
787+smartPunctuation :: Parser [Char] ParserState Inline
788+ -> Parser [Char] ParserState Inline
789789smartPunctuation inlineParser = do
790790 failUnlessSmart
791791 choice [ quoted inlineParser, apostrophe, dash, ellipses ]
792792
793−apostrophe :: Parsec [Char] ParserState Inline
793+apostrophe :: Parser [Char] ParserState Inline
794794apostrophe = (char '\'' <|> char '\8217') >> return (Str "\x2019")
795795
796−quoted :: Parsec [Char] ParserState Inline
797− -> Parsec [Char] ParserState Inline
796+quoted :: Parser [Char] ParserState Inline
797+ -> Parser [Char] ParserState Inline
798798quoted inlineParser = doubleQuoted inlineParser <|> singleQuoted inlineParser
799799
800800withQuoteContext :: QuoteContext
801− -> (Parsec [Char] ParserState Inline)
802− -> Parsec [Char] ParserState Inline
801+ -> (Parser [Char] ParserState Inline)
802+ -> Parser [Char] ParserState Inline
803803withQuoteContext context parser = do
804804 oldState <- getState
805805 let oldQuoteContext = stateQuoteContext oldState
@@ -809,39 +809,39 @@ withQuoteContext context parser = do
809809 setState newState { stateQuoteContext = oldQuoteContext }
810810 return result
811811
812−singleQuoted :: Parsec [Char] ParserState Inline
813− -> Parsec [Char] ParserState Inline
812+singleQuoted :: Parser [Char] ParserState Inline
813+ -> Parser [Char] ParserState Inline
814814singleQuoted inlineParser = try $ do
815815 singleQuoteStart
816816 withQuoteContext InSingleQuote $ many1Till inlineParser singleQuoteEnd >>=
817817 return . Quoted SingleQuote . normalizeSpaces
818818
819−doubleQuoted :: Parsec [Char] ParserState Inline
820− -> Parsec [Char] ParserState Inline
819+doubleQuoted :: Parser [Char] ParserState Inline
820+ -> Parser [Char] ParserState Inline
821821doubleQuoted inlineParser = try $ do
822822 doubleQuoteStart
823823 withQuoteContext InDoubleQuote $ do
824824 contents <- manyTill inlineParser doubleQuoteEnd
825825 return . Quoted DoubleQuote . normalizeSpaces $ contents
826826
827−failIfInQuoteContext :: QuoteContext -> Parsec [tok] ParserState ()
827+failIfInQuoteContext :: QuoteContext -> Parser [tok] ParserState ()
828828failIfInQuoteContext context = do
829829 st <- getState
830830 if stateQuoteContext st == context
831831 then fail "already inside quotes"
832832 else return ()
833833
834−charOrRef :: [Char] -> Parsec [Char] st Char
834+charOrRef :: [Char] -> Parser [Char] st Char
835835charOrRef cs =
836836 oneOf cs <|> try (do c <- characterReference
837837 guard (c `elem` cs)
838838 return c)
839839
840−updateLastStrPos :: Parsec [Char] ParserState ()
840+updateLastStrPos :: Parser [Char] ParserState ()
841841updateLastStrPos = getPosition >>= \p ->
842842 updateState $ \s -> s{ stateLastStrPos = Just p }
843843
844−singleQuoteStart :: Parsec [Char] ParserState ()
844+singleQuoteStart :: Parser [Char] ParserState ()
845845singleQuoteStart = do
846846 failIfInQuoteContext InSingleQuote
847847 pos <- getPosition
@@ -856,28 +856,28 @@ singleQuoteStart = do
856856 -- possess/contraction
857857 return ()
858858
859−singleQuoteEnd :: Parsec [Char] st ()
859+singleQuoteEnd :: Parser [Char] st ()
860860singleQuoteEnd = try $ do
861861 charOrRef "'\8217\146"
862862 notFollowedBy alphaNum
863863
864−doubleQuoteStart :: Parsec [Char] ParserState ()
864+doubleQuoteStart :: Parser [Char] ParserState ()
865865doubleQuoteStart = do
866866 failIfInQuoteContext InDoubleQuote
867867 try $ do charOrRef "\"\8220\147"
868868 notFollowedBy (satisfy (\c -> c == ' ' || c == '\t' || c == '\n'))
869869
870−doubleQuoteEnd :: Parsec [Char] st ()
870+doubleQuoteEnd :: Parser [Char] st ()
871871doubleQuoteEnd = do
872872 charOrRef "\"\8221\148"
873873 return ()
874874
875−ellipses :: Parsec [Char] st Inline
875+ellipses :: Parser [Char] st Inline
876876ellipses = do
877877 try (charOrRef "\8230\133") <|> try (string "..." >> return '…')
878878 return (Str "\8230")
879879
880−dash :: Parsec [Char] ParserState Inline
880+dash :: Parser [Char] ParserState Inline
881881dash = do
882882 oldDashes <- getOption readerOldDashes
883883 if oldDashes
@@ -885,28 +885,28 @@ dash = do
885885 else Str `fmap` (hyphenDash <|> emDash <|> enDash)
886886
887887-- Two hyphens = en-dash, three = em-dash
888−hyphenDash :: Parsec [Char] st String
888+hyphenDash :: Parser [Char] st String
889889hyphenDash = do
890890 try $ string "--"
891891 option "\8211" (char '-' >> return "\8212")
892892
893−emDash :: Parsec [Char] st String
893+emDash :: Parser [Char] st String
894894emDash = do
895895 try (charOrRef "\8212\151")
896896 return "\8212"
897897
898−enDash :: Parsec [Char] st String
898+enDash :: Parser [Char] st String
899899enDash = do
900900 try (charOrRef "\8212\151")
901901 return "\8211"
902902
903−enDashOld :: Parsec [Char] st Inline
903+enDashOld :: Parser [Char] st Inline
904904enDashOld = do
905905 try (charOrRef "\8211\150") <|>
906906 try (char '-' >> lookAhead (satisfy isDigit) >> return '–')
907907 return (Str "\8211")
908908
909−emDashOld :: Parsec [Char] st Inline
909+emDashOld :: Parser [Char] st Inline
910910emDashOld = do
911911 try (charOrRef "\8212\151") <|> (try $ string "--" >> optional (char '-') >> return '-')
912912 return (Str "\8212")
@@ -916,7 +916,7 @@ emDashOld = do
916916--
917917
918918-- | Parse a \newcommand or \renewcommand macro definition.
919−macro :: Parsec [Char] ParserState Block
919+macro :: Parser [Char] ParserState Block
920920macro = do
921921 apply <- getOption readerApplyMacros
922922 inp <- getInput
@@ -931,7 +931,7 @@ macro = do
931931 else return $ RawBlock "latex" def'
932932
933933-- | Apply current macros to string.
934−applyMacros' :: String -> Parsec [Char] ParserState String
934+applyMacros' :: String -> Parser [Char] ParserState String
935935applyMacros' target = do
936936 apply <- getOption readerApplyMacros
937937 if apply
@@ -939,3 +939,44 @@ applyMacros' target = do
939939 return $ applyMacros macros target
940940 else return target
941941
942+---- pandoc2 block sep/line end parsers
943+{-
944+
945+-- | Push parser onto stack of endline parsers.
946+-- These are applied after a newline within a block.
947+pushEndline :: PMonad m => P t m () -> P t m ()
948+pushEndline p = modifyState $ \st -> st{ sEndline = sEndline st |> p }
949+
950+-- | Pop parser off stack of endline parsers.
951+popEndline :: PMonad m => P t m ()
952+popEndline = do
953+ st <- getState
954+ case viewr (sEndline st) of
955+ EmptyR -> logM ERROR "Tried to pop empty pEndline stack"
956+ ps :> _ -> setState st{ sEndline = ps }
957+
958+-- | Apply a parser in a context with a specified endline parser.
959+withEndline :: PMonad m => P t m a -> P t m b -> P t m b
960+withEndline sep p = pushEndline (() <$ sep) *> p <* popEndline
961+
962+-- | Push parser onto stack of block separator parsers.
963+-- These are applied after a newline following a block.
964+pushBlockSep :: PMonad m => P t m () -> P t m ()
965+pushBlockSep p = modifyState $ \st -> st{ sBlockSep = sBlockSep st |> p }
966+
967+-- | Pop parser off of stack of block separator parsers.
968+popBlockSep :: PMonad m => P t m ()
969+popBlockSep = do
970+ st <- getState
971+ case viewr (sBlockSep st) of
972+ EmptyR -> logM ERROR "Tried to pop empty pBlockSep stack"
973+ ps :> _ -> setState st{ sBlockSep = ps }
974+
975+-- | Apply a parser in a context with specified block separator parser.
976+withBlockSep :: PMonad m => P t m a -> P t m b -> P t m b
977+withBlockSep sep p = pushBlockSep (() <$ sep) *> p <* popBlockSep
978+
979+-- | Parse a block separator.
980+pBlockSep :: PMonad m => P t m ()
981+pBlockSep = try (getState >>= sequenceA . sBlockSep) >> return ()
982+-}