polyparse 1.1 → 1.2
raw patch · 49 files changed
+3683/−6348 lines, 49 filesPVP ok
version bump matches the API change (PVP)
API changes (from Hackage documentation)
- Text.Parse: instance (Parse a) => Parse (Maybe a)
- Text.Parse: instance (Parse a) => Parse [a]
- Text.ParserCombinators.Poly: P :: ([t] -> (EitherE String a, [t])) -> Parser t a
- Text.ParserCombinators.Poly: adjustErr :: Parser t a -> (String -> String) -> Parser t a
- Text.ParserCombinators.Poly: adjustErrBad :: Parser t a -> (String -> String) -> Parser t a
- Text.ParserCombinators.Poly: apply :: Parser t (a -> b) -> Parser t a -> Parser t b
- Text.ParserCombinators.Poly: bracket :: Parser t bra -> Parser t ket -> Parser t a -> Parser t a
- Text.ParserCombinators.Poly: bracketSep :: Parser t bra -> Parser t sep -> Parser t ket -> Parser t a -> Parser t [a]
- Text.ParserCombinators.Poly: commit :: Parser t a -> Parser t a
- Text.ParserCombinators.Poly: discard :: Parser t a -> Parser t b -> Parser t a
- Text.ParserCombinators.Poly: exactly :: Int -> Parser t a -> Parser t [a]
- Text.ParserCombinators.Poly: failBad :: String -> Parser t a
- Text.ParserCombinators.Poly: indent :: Int -> String -> String
- Text.ParserCombinators.Poly: instance Functor (Parser t)
- Text.ParserCombinators.Poly: instance Monad (Parser t)
- Text.ParserCombinators.Poly: many :: Parser t a -> Parser t [a]
- Text.ParserCombinators.Poly: many1 :: Parser t a -> Parser t [a]
- Text.ParserCombinators.Poly: manyFinally :: Parser t a -> Parser t z -> Parser t [a]
- Text.ParserCombinators.Poly: newtype Parser t a
- Text.ParserCombinators.Poly: next :: Parser t t
- Text.ParserCombinators.Poly: onFail :: Parser t a -> Parser t a -> Parser t a
- Text.ParserCombinators.Poly: oneOf :: [Parser t a] -> Parser t a
- Text.ParserCombinators.Poly: oneOf' :: [(String, Parser t a)] -> Parser t a
- Text.ParserCombinators.Poly: optional :: Parser t a -> Parser t (Maybe a)
- Text.ParserCombinators.Poly: reparse :: [t] -> Parser t ()
- Text.ParserCombinators.Poly: runParser :: Parser t a -> [t] -> (Either String a, [t])
- Text.ParserCombinators.Poly: satisfy :: (t -> Bool) -> Parser t t
- Text.ParserCombinators.Poly: sepBy :: Parser t a -> Parser t sep -> Parser t [a]
- Text.ParserCombinators.Poly: sepBy1 :: Parser t a -> Parser t sep -> Parser t [a]
- Text.ParserCombinators.Poly.Lazy: manyFinally :: Parser t a -> Parser t z -> Parser t [a]
- Text.ParserCombinators.Poly.NoLeak.Lazy: P :: ([t] -> Result [t] a) -> Parser t a
- Text.ParserCombinators.Poly.NoLeak.Lazy: instance Functor (Parser t)
- Text.ParserCombinators.Poly.NoLeak.Lazy: instance Functor (Result z)
- Text.ParserCombinators.Poly.NoLeak.Lazy: instance Monad (Parser t)
- Text.ParserCombinators.Poly.NoLeak.Lazy: instance PolyParse (Parser t)
- Text.ParserCombinators.Poly.NoLeak.Lazy: newtype Parser t a
- Text.ParserCombinators.Poly.NoLeak.Lazy: next :: Parser t t
- Text.ParserCombinators.Poly.NoLeak.Lazy: reparse :: [t] -> Parser t ()
- Text.ParserCombinators.Poly.NoLeak.Lazy: runParser :: Parser t a -> [t] -> (a, [t])
- Text.ParserCombinators.Poly.NoLeak.Lazy: satisfy :: (t -> Bool) -> Parser t t
- Text.ParserCombinators.Poly.NoLeak.Plain: P :: ([t] -> Result [t] a) -> Parser t a
- Text.ParserCombinators.Poly.NoLeak.Plain: instance Functor (Parser t)
- Text.ParserCombinators.Poly.NoLeak.Plain: instance Functor (Result z)
- Text.ParserCombinators.Poly.NoLeak.Plain: instance Monad (Parser t)
- Text.ParserCombinators.Poly.NoLeak.Plain: instance PolyParse (Parser t)
- Text.ParserCombinators.Poly.NoLeak.Plain: newtype Parser t a
- Text.ParserCombinators.Poly.NoLeak.Plain: next :: Parser t t
- Text.ParserCombinators.Poly.NoLeak.Plain: reparse :: [t] -> Parser t ()
- Text.ParserCombinators.Poly.NoLeak.Plain: runParser :: Parser t a -> [t] -> (Either String a, [t])
- Text.ParserCombinators.Poly.NoLeak.Plain: satisfy :: (t -> Bool) -> Parser t t
- Text.ParserCombinators.Poly.NoLeak.State: P :: (s -> [t] -> Result [t] s a) -> Parser s t a
- Text.ParserCombinators.Poly.NoLeak.State: instance Functor (Parser s t)
- Text.ParserCombinators.Poly.NoLeak.State: instance Functor (Result z s)
- Text.ParserCombinators.Poly.NoLeak.State: instance Monad (Parser s t)
- Text.ParserCombinators.Poly.NoLeak.State: instance PolyParse (Parser s t)
- Text.ParserCombinators.Poly.NoLeak.State: newtype Parser s t a
- Text.ParserCombinators.Poly.NoLeak.State: next :: Parser s t t
- Text.ParserCombinators.Poly.NoLeak.State: reparse :: [t] -> Parser s t ()
- Text.ParserCombinators.Poly.NoLeak.State: runParser :: Parser s t a -> s -> [t] -> (Either String a, s, [t])
- Text.ParserCombinators.Poly.NoLeak.State: satisfy :: (t -> Bool) -> Parser s t t
- Text.ParserCombinators.Poly.NoLeak.State: stGet :: Parser s t s
- Text.ParserCombinators.Poly.NoLeak.State: stQuery :: (s -> a) -> Parser s t a
- Text.ParserCombinators.Poly.NoLeak.State: stUpdate :: (s -> s) -> Parser s t ()
- Text.ParserCombinators.Poly.NoLeak.StateLazy: P :: (s -> [t] -> Result [t] s a) -> Parser s t a
- Text.ParserCombinators.Poly.NoLeak.StateLazy: instance Functor (Parser s t)
- Text.ParserCombinators.Poly.NoLeak.StateLazy: instance Functor (Result z s)
- Text.ParserCombinators.Poly.NoLeak.StateLazy: instance Monad (Parser s t)
- Text.ParserCombinators.Poly.NoLeak.StateLazy: instance PolyParse (Parser s t)
- Text.ParserCombinators.Poly.NoLeak.StateLazy: manyFinally :: Parser s t a -> Parser s t z -> Parser s t [a]
- Text.ParserCombinators.Poly.NoLeak.StateLazy: newtype Parser s t a
- Text.ParserCombinators.Poly.NoLeak.StateLazy: next :: Parser s t t
- Text.ParserCombinators.Poly.NoLeak.StateLazy: reparse :: [t] -> Parser s t ()
- Text.ParserCombinators.Poly.NoLeak.StateLazy: runParser :: Parser s t a -> s -> [t] -> (a, s, [t])
- Text.ParserCombinators.Poly.NoLeak.StateLazy: satisfy :: (t -> Bool) -> Parser s t t
- Text.ParserCombinators.Poly.NoLeak.StateLazy: stGet :: Parser s t s
- Text.ParserCombinators.Poly.NoLeak.StateLazy: stQuery :: (s -> a) -> Parser s t a
- Text.ParserCombinators.Poly.NoLeak.StateLazy: stUpdate :: (s -> s) -> Parser s t ()
- Text.ParserCombinators.PolyLazy: P :: ([t] -> (Either String a, [t])) -> Parser t a
- Text.ParserCombinators.PolyLazy: adjustErr :: Parser t a -> (String -> String) -> Parser t a
- Text.ParserCombinators.PolyLazy: adjustErrBad :: Parser t a -> (String -> String) -> Parser t a
- Text.ParserCombinators.PolyLazy: apply :: Parser t (a -> b) -> Parser t a -> Parser t b
- Text.ParserCombinators.PolyLazy: bracket :: Parser t bra -> Parser t ket -> Parser t a -> Parser t a
- Text.ParserCombinators.PolyLazy: bracketSep :: Parser t bra -> Parser t sep -> Parser t ket -> Parser t a -> Parser t [a]
- Text.ParserCombinators.PolyLazy: commit :: Parser t a -> Parser t a
- Text.ParserCombinators.PolyLazy: discard :: Parser t a -> Parser t b -> Parser t a
- Text.ParserCombinators.PolyLazy: exactly :: Int -> Parser t a -> Parser t [a]
- Text.ParserCombinators.PolyLazy: failBad :: String -> Parser t a
- Text.ParserCombinators.PolyLazy: indent :: Int -> String -> String
- Text.ParserCombinators.PolyLazy: instance Functor (Parser t)
- Text.ParserCombinators.PolyLazy: instance Monad (Parser t)
- Text.ParserCombinators.PolyLazy: many :: Parser t a -> Parser t [a]
- Text.ParserCombinators.PolyLazy: many1 :: Parser t a -> Parser t [a]
- Text.ParserCombinators.PolyLazy: manyFinally :: Parser t a -> Parser t z -> Parser t [a]
- Text.ParserCombinators.PolyLazy: newtype Parser t a
- Text.ParserCombinators.PolyLazy: next :: Parser t t
- Text.ParserCombinators.PolyLazy: onFail :: Parser t a -> Parser t a -> Parser t a
- Text.ParserCombinators.PolyLazy: oneOf :: [Parser t a] -> Parser t a
- Text.ParserCombinators.PolyLazy: oneOf' :: [(String, Parser t a)] -> Parser t a
- Text.ParserCombinators.PolyLazy: optional :: Parser t a -> Parser t (Maybe a)
- Text.ParserCombinators.PolyLazy: reparse :: [t] -> Parser t ()
- Text.ParserCombinators.PolyLazy: runParser :: Parser t a -> [t] -> (a, [t])
- Text.ParserCombinators.PolyLazy: satisfy :: (t -> Bool) -> Parser t t
- Text.ParserCombinators.PolyLazy: sepBy :: Parser t a -> Parser t sep -> Parser t [a]
- Text.ParserCombinators.PolyLazy: sepBy1 :: Parser t a -> Parser t sep -> Parser t [a]
- Text.ParserCombinators.PolyState: P :: (s -> [t] -> (EitherE String a, s, [t])) -> Parser s t a
- Text.ParserCombinators.PolyState: adjustErr :: Parser s t a -> (String -> String) -> Parser s t a
- Text.ParserCombinators.PolyState: adjustErrBad :: Parser s t a -> (String -> String) -> Parser s t a
- Text.ParserCombinators.PolyState: apply :: Parser s t (a -> b) -> Parser s t a -> Parser s t b
- Text.ParserCombinators.PolyState: bracket :: Parser s t bra -> Parser s t ket -> Parser s t a -> Parser s t a
- Text.ParserCombinators.PolyState: bracketSep :: Parser s t bra -> Parser s t sep -> Parser s t ket -> Parser s t a -> Parser s t [a]
- Text.ParserCombinators.PolyState: commit :: Parser s t a -> Parser s t a
- Text.ParserCombinators.PolyState: discard :: Parser s t a -> Parser s t b -> Parser s t a
- Text.ParserCombinators.PolyState: exactly :: Int -> Parser s t a -> Parser s t [a]
- Text.ParserCombinators.PolyState: failBad :: String -> Parser s t a
- Text.ParserCombinators.PolyState: indent :: Int -> String -> String
- Text.ParserCombinators.PolyState: instance Functor (Parser s t)
- Text.ParserCombinators.PolyState: instance Monad (Parser s t)
- Text.ParserCombinators.PolyState: many :: Parser s t a -> Parser s t [a]
- Text.ParserCombinators.PolyState: many1 :: Parser s t a -> Parser s t [a]
- Text.ParserCombinators.PolyState: manyFinally :: Parser s t a -> Parser s t z -> Parser s t [a]
- Text.ParserCombinators.PolyState: newtype Parser s t a
- Text.ParserCombinators.PolyState: next :: Parser s t t
- Text.ParserCombinators.PolyState: onFail :: Parser s t a -> Parser s t a -> Parser s t a
- Text.ParserCombinators.PolyState: oneOf :: [Parser s t a] -> Parser s t a
- Text.ParserCombinators.PolyState: oneOf' :: [(String, Parser s t a)] -> Parser s t a
- Text.ParserCombinators.PolyState: reparse :: [t] -> Parser s t ()
- Text.ParserCombinators.PolyState: runParser :: Parser s t a -> s -> [t] -> (Either String a, s, [t])
- Text.ParserCombinators.PolyState: satisfy :: (t -> Bool) -> Parser s t t
- Text.ParserCombinators.PolyState: sepBy :: Parser s t a -> Parser s t sep -> Parser s t [a]
- Text.ParserCombinators.PolyState: sepBy1 :: Parser s t a -> Parser s t sep -> Parser s t [a]
- Text.ParserCombinators.PolyState: stGet :: Parser s t s
- Text.ParserCombinators.PolyState: stQuery :: (s -> a) -> Parser s t a
- Text.ParserCombinators.PolyState: stUpdate :: (s -> s) -> Parser s t ()
- Text.ParserCombinators.PolyStateLazy: P :: (s -> [t] -> (Either String a, s, [t])) -> Parser s t a
- Text.ParserCombinators.PolyStateLazy: adjustErr :: Parser s t a -> (String -> String) -> Parser s t a
- Text.ParserCombinators.PolyStateLazy: adjustErrBad :: Parser s t a -> (String -> String) -> Parser s t a
- Text.ParserCombinators.PolyStateLazy: apply :: Parser s t (a -> b) -> Parser s t a -> Parser s t b
- Text.ParserCombinators.PolyStateLazy: bracket :: Parser s t bra -> Parser s t ket -> Parser s t a -> Parser s t a
- Text.ParserCombinators.PolyStateLazy: bracketSep :: Parser s t bra -> Parser s t sep -> Parser s t ket -> Parser s t a -> Parser s t [a]
- Text.ParserCombinators.PolyStateLazy: commit :: Parser s t a -> Parser s t a
- Text.ParserCombinators.PolyStateLazy: discard :: Parser s t a -> Parser s t b -> Parser s t a
- Text.ParserCombinators.PolyStateLazy: exactly :: Int -> Parser s t a -> Parser s t [a]
- Text.ParserCombinators.PolyStateLazy: failBad :: String -> Parser s t a
- Text.ParserCombinators.PolyStateLazy: indent :: Int -> String -> String
- Text.ParserCombinators.PolyStateLazy: instance Functor (Parser s t)
- Text.ParserCombinators.PolyStateLazy: instance Monad (Parser s t)
- Text.ParserCombinators.PolyStateLazy: many :: Parser s t a -> Parser s t [a]
- Text.ParserCombinators.PolyStateLazy: many1 :: Parser s t a -> Parser s t [a]
- Text.ParserCombinators.PolyStateLazy: manyFinally :: Parser s t a -> Parser s t z -> Parser s t [a]
- Text.ParserCombinators.PolyStateLazy: newtype Parser s t a
- Text.ParserCombinators.PolyStateLazy: next :: Parser s t t
- Text.ParserCombinators.PolyStateLazy: onFail :: Parser s t a -> Parser s t a -> Parser s t a
- Text.ParserCombinators.PolyStateLazy: oneOf :: [Parser s t a] -> Parser s t a
- Text.ParserCombinators.PolyStateLazy: oneOf' :: [(String, Parser s t a)] -> Parser s t a
- Text.ParserCombinators.PolyStateLazy: optional :: Parser s t a -> Parser s t (Maybe a)
- Text.ParserCombinators.PolyStateLazy: reparse :: [t] -> Parser s t ()
- Text.ParserCombinators.PolyStateLazy: runParser :: Parser s t a -> s -> [t] -> (a, s, [t])
- Text.ParserCombinators.PolyStateLazy: satisfy :: (t -> Bool) -> Parser s t t
- Text.ParserCombinators.PolyStateLazy: sepBy :: Parser s t a -> Parser s t sep -> Parser s t [a]
- Text.ParserCombinators.PolyStateLazy: sepBy1 :: Parser s t a -> Parser s t sep -> Parser s t [a]
- Text.ParserCombinators.PolyStateLazy: stGet :: Parser s t s
- Text.ParserCombinators.PolyStateLazy: stQuery :: (s -> a) -> Parser s t a
- Text.ParserCombinators.PolyStateLazy: stUpdate :: (s -> s) -> Parser s t ()
+ Text.Parse: instance Parse a => Parse (Maybe a)
+ Text.Parse: instance Parse a => Parse [a]
+ Text.Parse: parens :: Bool -> TextParser a -> TextParser a
+ Text.Parse: parseDec :: Integral a => a -> TextParser a
+ Text.Parse: parseFloat :: RealFrac a => TextParser a
+ Text.Parse: parseHex :: Integral a => a -> TextParser a
+ Text.Parse: parseInt :: Integral a => String -> a -> (Char -> Bool) -> (Char -> Int) -> a -> TextParser a
+ Text.Parse: parseLitChar :: TextParser Char
+ Text.Parse: parseOct :: Integral a => a -> TextParser a
+ Text.Parse: parsePrec :: Parse a => Int -> TextParser a
+ Text.Parse: parseSigned :: Real a => TextParser a -> TextParser a
+ Text.ParserCombinators.Poly.Lazy: Committed :: (Result z a) -> Result z a
+ Text.ParserCombinators.Poly.Lazy: Failure :: z -> String -> Result z a
+ Text.ParserCombinators.Poly.Lazy: Success :: z -> a -> Result z a
+ Text.ParserCombinators.Poly.Lazy: data Result z a
+ Text.ParserCombinators.Poly.Lazy: instance Functor (Result z)
+ Text.ParserCombinators.Poly.Plain: Committed :: (Result z a) -> Result z a
+ Text.ParserCombinators.Poly.Plain: Failure :: z -> String -> Result z a
+ Text.ParserCombinators.Poly.Plain: Success :: z -> a -> Result z a
+ Text.ParserCombinators.Poly.Plain: data Result z a
+ Text.ParserCombinators.Poly.Plain: instance Functor (Result z)
+ Text.ParserCombinators.Poly.State: Committed :: (Result z s a) -> Result z s a
+ Text.ParserCombinators.Poly.State: Failure :: z -> s -> String -> Result z s a
+ Text.ParserCombinators.Poly.State: Success :: z -> s -> a -> Result z s a
+ Text.ParserCombinators.Poly.State: data Result z s a
+ Text.ParserCombinators.Poly.State: instance Functor (Result z s)
+ Text.ParserCombinators.Poly.StateLazy: Committed :: (Result z s a) -> Result z s a
+ Text.ParserCombinators.Poly.StateLazy: Failure :: z -> s -> String -> Result z s a
+ Text.ParserCombinators.Poly.StateLazy: Success :: z -> s -> a -> Result z s a
+ Text.ParserCombinators.Poly.StateLazy: data Result z s a
+ Text.ParserCombinators.Poly.StateLazy: instance Functor (Result z s)
+ Text.ParserCombinators.Poly.StateLazy: manyFinally :: Parser s t a -> Parser s t z -> Parser s t [a]
- Text.Parse: enumeration :: (Show a) => String -> [a] -> TextParser a
+ Text.Parse: enumeration :: Show a => String -> [a] -> TextParser a
- Text.Parse: field :: (Parse a) => String -> TextParser a
+ Text.Parse: field :: Parse a => String -> TextParser a
- Text.Parse: parse :: (Parse a) => TextParser a
+ Text.Parse: parse :: Parse a => TextParser a
- Text.Parse: parseByRead :: (Read a) => String -> TextParser a
+ Text.Parse: parseByRead :: Read a => String -> TextParser a
- Text.Parse: parseList :: (Parse a) => TextParser [a]
+ Text.Parse: parseList :: Parse a => TextParser [a]
- Text.ParserCombinators.HuttonMeijerWallace: eof :: (Show p) => Parser s (p, t) String ()
+ Text.ParserCombinators.HuttonMeijerWallace: eof :: Show p => Parser s (p, t) String ()
- Text.ParserCombinators.HuttonMeijerWallace: nottok :: (Eq t) => [t] -> Parser s (p, t) e t
+ Text.ParserCombinators.HuttonMeijerWallace: nottok :: Eq t => [t] -> Parser s (p, t) e t
- Text.ParserCombinators.HuttonMeijerWallace: toEOF :: (Show p) => Parser s (p, t) String a -> Parser s (p, t) String a
+ Text.ParserCombinators.HuttonMeijerWallace: toEOF :: Show p => Parser s (p, t) String a -> Parser s (p, t) String a
- Text.ParserCombinators.HuttonMeijerWallace: tok :: (Eq t) => t -> Parser s (p, t) e t
+ Text.ParserCombinators.HuttonMeijerWallace: tok :: Eq t => t -> Parser s (p, t) e t
- Text.ParserCombinators.Poly.Base: adjustErr :: (PolyParse p) => p a -> (String -> String) -> p a
+ Text.ParserCombinators.Poly.Base: adjustErr :: PolyParse p => p a -> (String -> String) -> p a
- Text.ParserCombinators.Poly.Base: adjustErrBad :: (PolyParse p) => p a -> (String -> String) -> p a
+ Text.ParserCombinators.Poly.Base: adjustErrBad :: PolyParse p => p a -> (String -> String) -> p a
- Text.ParserCombinators.Poly.Base: apply :: (PolyParse p) => p (a -> b) -> p a -> p b
+ Text.ParserCombinators.Poly.Base: apply :: PolyParse p => p (a -> b) -> p a -> p b
- Text.ParserCombinators.Poly.Base: bracket :: (PolyParse p) => p bra -> p ket -> p a -> p a
+ Text.ParserCombinators.Poly.Base: bracket :: PolyParse p => p bra -> p ket -> p a -> p a
- Text.ParserCombinators.Poly.Base: bracketSep :: (PolyParse p) => p bra -> p sep -> p ket -> p a -> p [a]
+ Text.ParserCombinators.Poly.Base: bracketSep :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a]
- Text.ParserCombinators.Poly.Base: commit :: (PolyParse p) => p a -> p a
+ Text.ParserCombinators.Poly.Base: commit :: PolyParse p => p a -> p a
- Text.ParserCombinators.Poly.Base: discard :: (PolyParse p) => p a -> p b -> p a
+ Text.ParserCombinators.Poly.Base: discard :: PolyParse p => p a -> p b -> p a
- Text.ParserCombinators.Poly.Base: exactly :: (PolyParse p) => Int -> p a -> p [a]
+ Text.ParserCombinators.Poly.Base: exactly :: PolyParse p => Int -> p a -> p [a]
- Text.ParserCombinators.Poly.Base: failBad :: (PolyParse p) => String -> p a
+ Text.ParserCombinators.Poly.Base: failBad :: PolyParse p => String -> p a
- Text.ParserCombinators.Poly.Base: many :: (PolyParse p) => p a -> p [a]
+ Text.ParserCombinators.Poly.Base: many :: PolyParse p => p a -> p [a]
- Text.ParserCombinators.Poly.Base: many1 :: (PolyParse p) => p a -> p [a]
+ Text.ParserCombinators.Poly.Base: many1 :: PolyParse p => p a -> p [a]
- Text.ParserCombinators.Poly.Base: manyFinally :: (PolyParse p) => p a -> p z -> p [a]
+ Text.ParserCombinators.Poly.Base: manyFinally :: PolyParse p => p a -> p z -> p [a]
- Text.ParserCombinators.Poly.Base: onFail :: (PolyParse p) => p a -> p a -> p a
+ Text.ParserCombinators.Poly.Base: onFail :: PolyParse p => p a -> p a -> p a
- Text.ParserCombinators.Poly.Base: oneOf :: (PolyParse p) => [p a] -> p a
+ Text.ParserCombinators.Poly.Base: oneOf :: PolyParse p => [p a] -> p a
- Text.ParserCombinators.Poly.Base: oneOf' :: (PolyParse p) => [(String, p a)] -> p a
+ Text.ParserCombinators.Poly.Base: oneOf' :: PolyParse p => [(String, p a)] -> p a
- Text.ParserCombinators.Poly.Base: optional :: (PolyParse p) => p a -> p (Maybe a)
+ Text.ParserCombinators.Poly.Base: optional :: PolyParse p => p a -> p (Maybe a)
- Text.ParserCombinators.Poly.Base: sepBy :: (PolyParse p) => p a -> p sep -> p [a]
+ Text.ParserCombinators.Poly.Base: sepBy :: PolyParse p => p a -> p sep -> p [a]
- Text.ParserCombinators.Poly.Base: sepBy1 :: (PolyParse p) => p a -> p sep -> p [a]
+ Text.ParserCombinators.Poly.Base: sepBy1 :: PolyParse p => p a -> p sep -> p [a]
- Text.ParserCombinators.Poly.Lazy: P :: ([t] -> (Either String a, [t])) -> Parser t a
+ Text.ParserCombinators.Poly.Lazy: P :: ([t] -> Result [t] a) -> Parser t a
- Text.ParserCombinators.Poly.Plain: P :: ([t] -> (EitherE String a, [t])) -> Parser t a
+ Text.ParserCombinators.Poly.Plain: P :: ([t] -> Result [t] a) -> Parser t a
- Text.ParserCombinators.Poly.State: P :: (s -> [t] -> (EitherE String a, s, [t])) -> Parser s t a
+ Text.ParserCombinators.Poly.State: P :: (s -> [t] -> Result [t] s a) -> Parser s t a
- Text.ParserCombinators.Poly.StateLazy: P :: (s -> [t] -> (Either String a, s, [t])) -> Parser s t a
+ Text.ParserCombinators.Poly.StateLazy: P :: (s -> [t] -> Result [t] s a) -> Parser s t a
Files
- Makefile +2/−10
- docs/changelog.html +23/−0
- docs/haddock/Text-Parse.html +372/−3
- docs/haddock/Text-ParserCombinators-Poly-Base.html +2/−28
- docs/haddock/Text-ParserCombinators-Poly-Lazy.html +173/−66
- docs/haddock/Text-ParserCombinators-Poly-Plain.html +149/−2
- docs/haddock/Text-ParserCombinators-Poly-State.html +194/−10
- docs/haddock/Text-ParserCombinators-Poly-StateLazy.html +210/−58
- docs/haddock/Text-ParserCombinators-Poly.html +28/−1356
- docs/haddock/doc-index-A.html +6/−114
- docs/haddock/doc-index-B.html +3/−71
- docs/haddock/doc-index-C.html +38/−38
- docs/haddock/doc-index-D.html +2/−38
- docs/haddock/doc-index-E.html +2/−38
- docs/haddock/doc-index-F.html +20/−20
- docs/haddock/doc-index-I.html +2/−38
- docs/haddock/doc-index-M.html +6/−110
- docs/haddock/doc-index-N.html +8/−66
- docs/haddock/doc-index-O.html +8/−144
- docs/haddock/doc-index-P.html +76/−132
- docs/haddock/doc-index-R.html +30/−122
- docs/haddock/doc-index-S.html +35/−231
- docs/haddock/index.html +0/−85
- docs/haddock/src/Text/Parse.html +381/−178
- docs/haddock/src/Text/ParserCombinators/HuttonMeijer.html +224/−218
- docs/haddock/src/Text/ParserCombinators/HuttonMeijerWallace.html +303/−297
- docs/haddock/src/Text/ParserCombinators/Poly.html +11/−247
- docs/haddock/src/Text/ParserCombinators/Poly/Base.html +201/−190
- docs/haddock/src/Text/ParserCombinators/Poly/Lazy.html +135/−136
- docs/haddock/src/Text/ParserCombinators/Poly/Plain.html +113/−92
- docs/haddock/src/Text/ParserCombinators/Poly/State.html +131/−109
- docs/haddock/src/Text/ParserCombinators/Poly/StateLazy.html +181/−140
- docs/index.html +56/−61
- polyparse.cabal +4/−11
- src/Makefile +1/−8
- src/Text/Parse.hs +224/−27
- src/Text/ParserCombinators/Poly.hs +2/−244
- src/Text/ParserCombinators/Poly/Base.hs +5/−0
- src/Text/ParserCombinators/Poly/Lazy.hs +80/−87
- src/Text/ParserCombinators/Poly/NoLeak/Lazy.hs +0/−126
- src/Text/ParserCombinators/Poly/NoLeak/Plain.hs +0/−105
- src/Text/ParserCombinators/Poly/NoLeak/State.hs +0/−122
- src/Text/ParserCombinators/Poly/NoLeak/StateLazy.hs +0/−172
- src/Text/ParserCombinators/Poly/Plain.hs +53/−38
- src/Text/ParserCombinators/Poly/State.hs +74/−58
- src/Text/ParserCombinators/Poly/StateLazy.hs +115/−80
- src/Text/ParserCombinators/PolyLazy.hs +0/−275
- src/Text/ParserCombinators/PolyState.hs +0/−257
- src/Text/ParserCombinators/PolyStateLazy.hs +0/−290
Makefile view
@@ -1,28 +1,20 @@ SOFTWARE = polyparse-VERSION = 1.1+VERSION = 1.2 CPP = cpp -traditional #CPP = cpphs --text # useful e.g. on MacOS X -DIRS = Text Text/ParserCombinators Text/ParserCombinators/Poly \- Text/ParserCombinators/Poly/NoLeak+DIRS = Text Text/ParserCombinators Text/ParserCombinators/Poly SRCS = \ src/Text/ParserCombinators/HuttonMeijer.hs \ src/Text/ParserCombinators/HuttonMeijerWallace.hs \ src/Text/ParserCombinators/Poly.hs \- src/Text/ParserCombinators/PolyState.hs \- src/Text/ParserCombinators/PolyLazy.hs \- src/Text/ParserCombinators/PolyStateLazy.hs \ src/Text/ParserCombinators/Poly/Base.hs \ src/Text/ParserCombinators/Poly/Plain.hs \ src/Text/ParserCombinators/Poly/Lazy.hs \ src/Text/ParserCombinators/Poly/State.hs \ src/Text/ParserCombinators/Poly/StateLazy.hs \- src/Text/ParserCombinators/Poly/NoLeak/Plain.hs \- src/Text/ParserCombinators/Poly/NoLeak/Lazy.hs \- src/Text/ParserCombinators/Poly/NoLeak/State.hs \- src/Text/ParserCombinators/Poly/NoLeak/StateLazy.hs \ src/Text/Parse.hs TOOLSRCS = \
docs/changelog.html view
@@ -13,6 +13,29 @@ </center> <hr> +<h3>Changes in polyparse-1.2</h3>+<p>+<ul>+<li>Improves the Text.Parse implementation significantly. Where+ previously all the parsers for builtin basic datatype (Int,Float,Char)+ were just thin wrappers over the H'98 Read instances, now they are all+ proper parsers, therefore they should (a) be faster; (b) give better+ error messages.+<li>Reduced the number of implementation variations to choose from.+ In particular, NoLeak has become the default implementation, and+ the previous default has been dropped (because it space-leaks).+<!--+<li>[desired] The class interface providing common operations across all+ implementations, now need be no slower than the previous+ cut-n-pasted interface, due to compiler specialisation of all the+ instances.+<li>[desired] New combinators for parsing infix structures, with+ associativity and precedence information.+<li>[desired] Multiple layers of bracketing can be parsed in linear time,+ rather than the previous exponential solution.+-->+</ul>+ <h3>Changes in polyparse-1.1</h3> <p> <ul>
docs/haddock/Text-Parse.html view
@@ -78,6 +78,11 @@ ></DT ><DT ><A HREF="#3"+>Parsers for literal numerics and characters+</A+></DT+><DT+><A HREF="#4" >Re-export all the more general combinators from Poly too </A ></DT@@ -114,7 +119,7 @@ >type</SPAN > <A HREF="#t%3ATextParser" >TextParser</A-> a = <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"+> a = <A HREF="Text-ParserCombinators-Poly-Plain.html#t%3AParser" >Parser</A > Char a</TD ></TR@@ -145,6 +150,14 @@ ></TR ><TR ><TD CLASS="decl"+><A HREF="#v%3AparsePrec"+>parsePrec</A+> :: Int -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+></TR+><TR+><TD CLASS="decl" ><A HREF="#v%3AparseList" >parseList</A > :: <A HREF="Text-Parse.html#t%3ATextParser"@@ -210,6 +223,20 @@ ></TR ><TR ><TD CLASS="decl"+><A HREF="#v%3Aparens"+>parens</A+> :: Bool -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="decl" ><A HREF="#v%3Afield" >field</A > :: <A HREF="Text-Parse.html#t%3AParse"@@ -250,6 +277,92 @@ ></TR ><TR ><TD CLASS="decl"+><A HREF="#v%3AparseSigned"+>parseSigned</A+> :: Real a => <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="decl"+><A HREF="#v%3AparseInt"+>parseInt</A+> :: Integral a => String -> a -> (Char -> Bool) -> (Char -> Int) -> a -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="decl"+><A HREF="#v%3AparseDec"+>parseDec</A+> :: Integral a => a -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="decl"+><A HREF="#v%3AparseOct"+>parseOct</A+> :: Integral a => a -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="decl"+><A HREF="#v%3AparseHex"+>parseHex</A+> :: Integral a => a -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="decl"+><A HREF="#v%3AparseFloat"+>parseFloat</A+> :: RealFrac a => <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="decl"+><A HREF="#v%3AparseLitChar"+>parseLitChar</A+> :: <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> Char</TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="decl" >module <A HREF="Text-ParserCombinators-Poly.html" >Text.ParserCombinators.Poly</A ></TD@@ -300,7 +413,7 @@ ></A ><B >TextParser</B-> a = <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"+> a = <A HREF="Text-ParserCombinators-Poly-Plain.html#t%3AParser" >Parser</A > Char a</TD ><TD CLASS="declbut"@@ -396,6 +509,12 @@ ></TD ></TR ><TR+><TD CLASS="doc"+>A straightforward parser for an item. (A minimal definition of+ a class instance requires either |parse| or |parsePrec|.)+</TD+></TR+><TR ><TD CLASS="s8" ></TD ></TR@@ -404,6 +523,37 @@ ><TABLE CLASS="declbar" ><TR ><TD CLASS="declname"+><A NAME="v%3AparsePrec"+></A+><B+>parsePrec</B+> :: Int -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+><TD CLASS="declbut"+><A HREF="src/Text/Parse.html#parsePrec"+>Source</A+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="doc"+>A straightforward parser for an item, given the precedence of+ any surrounding expression. (Precedence determines whether+ parentheses are mandatory or optional.)+</TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname" ><A NAME="v%3AparseList" ></A ><B@@ -419,6 +569,12 @@ ></TABLE ></TD ></TR+><TR+><TD CLASS="doc"+>Parsing a list of items by default accepts the [] and comma syntax,+ except when the list is really a character string using "".+</TD+></TR ></TABLE ></TD ></TR@@ -565,7 +721,8 @@ ><TR ><TD CLASS="doc" >If there already exists a Read instance for a type, then we can make- a Parser for it, but with only poor error-reporting.+ a Parser for it, but with only poor error-reporting. The string argument+ is the expected type or value (for error-reporting only). </TD ></TR ><TR@@ -678,6 +835,37 @@ ><TABLE CLASS="declbar" ><TR ><TD CLASS="declname"+><A NAME="v%3Aparens"+></A+><B+>parens</B+> :: Bool -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+><TD CLASS="declbut"+><A HREF="src/Text/Parse.html#parens"+>Source</A+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="doc"+>Allow nested parens around an item (one set required when Bool is True).+</TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname" ><A NAME="v%3Afield" ></A ><B@@ -773,6 +961,187 @@ ><TR ><TD CLASS="section2" ><A NAME="3"+>Parsers for literal numerics and characters+</A+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname"+><A NAME="v%3AparseSigned"+></A+><B+>parseSigned</B+> :: Real a => <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+><TD CLASS="declbut"+><A HREF="src/Text/Parse.html#parseSigned"+>Source</A+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname"+><A NAME="v%3AparseInt"+></A+><B+>parseInt</B+> :: Integral a => String -> a -> (Char -> Bool) -> (Char -> Int) -> a -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+><TD CLASS="declbut"+><A HREF="src/Text/Parse.html#parseInt"+>Source</A+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname"+><A NAME="v%3AparseDec"+></A+><B+>parseDec</B+> :: Integral a => a -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+><TD CLASS="declbut"+><A HREF="src/Text/Parse.html#parseDec"+>Source</A+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname"+><A NAME="v%3AparseOct"+></A+><B+>parseOct</B+> :: Integral a => a -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+><TD CLASS="declbut"+><A HREF="src/Text/Parse.html#parseOct"+>Source</A+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname"+><A NAME="v%3AparseHex"+></A+><B+>parseHex</B+> :: Integral a => a -> <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+><TD CLASS="declbut"+><A HREF="src/Text/Parse.html#parseHex"+>Source</A+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname"+><A NAME="v%3AparseFloat"+></A+><B+>parseFloat</B+> :: RealFrac a => <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> a</TD+><TD CLASS="declbut"+><A HREF="src/Text/Parse.html#parseFloat"+>Source</A+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname"+><A NAME="v%3AparseLitChar"+></A+><B+>parseLitChar</B+> :: <A HREF="Text-Parse.html#t%3ATextParser"+>TextParser</A+> Char</TD+><TD CLASS="declbut"+><A HREF="src/Text/Parse.html#parseLitChar"+>Source</A+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="section2"+><A NAME="4" >Re-export all the more general combinators from Poly too </A ></TD
docs/haddock/Text-ParserCombinators-Poly-Base.html view
@@ -599,23 +599,13 @@ ><TD CLASS="decl" ><A HREF="Text-ParserCombinators-Poly-Base.html#t%3APolyParse" >PolyParse</A-> (<A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser"->Parser</A-> t)</TD-></TR-><TR-><TD CLASS="decl"-><A HREF="Text-ParserCombinators-Poly-Base.html#t%3APolyParse"->PolyParse</A-> (<A HREF="Text-ParserCombinators-Poly-NoLeak-Lazy.html#t%3AParser"->Parser</A-> t)</TD+> []</TD ></TR ><TR ><TD CLASS="decl" ><A HREF="Text-ParserCombinators-Poly-Base.html#t%3APolyParse" >PolyParse</A-> (<A HREF="Text-ParserCombinators-Poly-NoLeak-Plain.html#t%3AParser"+> (<A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser" >Parser</A > t)</TD ></TR@@ -626,22 +616,6 @@ > (<A HREF="Text-ParserCombinators-Poly-Plain.html#t%3AParser" >Parser</A > t)</TD-></TR-><TR-><TD CLASS="decl"-><A HREF="Text-ParserCombinators-Poly-Base.html#t%3APolyParse"->PolyParse</A-> (<A HREF="Text-ParserCombinators-Poly-NoLeak-State.html#t%3AParser"->Parser</A-> s t)</TD-></TR-><TR-><TD CLASS="decl"-><A HREF="Text-ParserCombinators-Poly-Base.html#t%3APolyParse"->PolyParse</A-> (<A HREF="Text-ParserCombinators-Poly-NoLeak-StateLazy.html#t%3AParser"->Parser</A-> s t)</TD ></TR ><TR ><TD CLASS="decl"
docs/haddock/Text-ParserCombinators-Poly-Lazy.html view
@@ -66,7 +66,7 @@ ><DL ><DT ><A HREF="#1"->The Parser datatype.+>The Parser datatype </A ></DT ><DD@@ -78,7 +78,7 @@ ></DT ><DT ><A HREF="#3"->Re-parsing+>re-parsing </A ></DT ></DL@@ -121,7 +121,9 @@ >Parser</A > t a = <A HREF="#v%3AP" >P</A-> ([t] -> (Either String a, [t]))</TD+> ([t] -> <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AResult"+>Result</A+> [t] a)</TD ></TR ><TR ><TD CLASS="s8"@@ -129,6 +131,50 @@ ></TR ><TR ><TD CLASS="decl"+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"+><TR+><TD CLASS="decl"+><SPAN CLASS="keyword"+>data</SPAN+> <A HREF="#t%3AResult"+>Result</A+> z a</TD+></TR+><TR+><TD CLASS="body"+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"+><TR+><TD CLASS="decl"+>= <A HREF="#v%3ASuccess"+>Success</A+> z a</TD+></TR+><TR+><TD CLASS="decl"+>| <A HREF="#v%3AFailure"+>Failure</A+> z String</TD+></TR+><TR+><TD CLASS="decl"+>| <A HREF="#v%3ACommitted"+>Committed</A+> (<A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AResult"+>Result</A+> z a)</TD+></TR+></TABLE+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="decl" ><A HREF="#v%3ArunParser" >runParser</A > :: <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser"@@ -141,9 +187,9 @@ ></TR ><TR ><TD CLASS="decl"-><A HREF="#v%3Asatisfy"->satisfy</A-> :: (t -> Bool) -> <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser"+><A HREF="#v%3Anext"+>next</A+> :: <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser" >Parser</A > t t</TD ></TR@@ -153,15 +199,11 @@ ></TR ><TR ><TD CLASS="decl"-><A HREF="#v%3AmanyFinally"->manyFinally</A-> :: <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser"->Parser</A-> t z -> <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser"+><A HREF="#v%3Asatisfy"+>satisfy</A+> :: (t -> Bool) -> <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser" >Parser</A-> t [a]</TD+> t t</TD ></TR ><TR ><TD CLASS="s8"@@ -199,7 +241,7 @@ ><TR ><TD CLASS="section1" ><A NAME="1"->The Parser datatype.+>The Parser datatype </A ></TD ></TR@@ -208,23 +250,6 @@ ></TD ></TR ><TR-><TD CLASS="doc"->When applied, these parsers do not return explicit failure.- An exception is- raised instead. This allows partial results to be returned- before a full parse is complete.- One of the key ways to ensure that your parser is properly lazy,- is to parse the initial portion of text returning a function, then- use the <TT->apply</TT-> combinator to build the final value.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR ><TD CLASS="topdecl" ><TABLE CLASS="declbar" ><TR@@ -249,12 +274,12 @@ ><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0" ><TR ><TD CLASS="ndoc"->The <TT+>This <TT >Parser</TT > datatype is a fairly generic parsing monad with error reporting. It can be used for arbitrary token types, not just- String input. (If you require a running state, use module PolyStateLazy- instead.)+ String input. (If you require a running state, use module PolyState+ instead) </TD ></TR ><TR@@ -270,7 +295,9 @@ ></A ><B >P</B-> ([t] -> (Either String a, [t]))</TD+> ([t] -> <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AResult"+>Result</A+> [t] a)</TD ><TD CLASS="rdoc" ></TD ></TR@@ -322,6 +349,105 @@ ><TABLE CLASS="declbar" ><TR ><TD CLASS="declname"+><SPAN CLASS="keyword"+>data</SPAN+> <A NAME="t%3AResult"+></A+><B+>Result</B+> z a</TD+><TD CLASS="declbut"+><A HREF="src/Text/ParserCombinators/Poly/Lazy.html#Result"+>Source</A+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="body"+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"+><TR+><TD CLASS="ndoc"+>A return type like Either, that distinguishes not only between+ right and wrong answers, but also has gradations of wrongness.+ This should only be used for writing very primitive+ parsers - really it is an internal detail of the library.+</TD+></TR+><TR+><TD CLASS="section4"+>Constructors</TD+></TR+><TR+><TD CLASS="body"+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"+><TR+><TD CLASS="arg"+><A NAME="v%3ASuccess"+></A+><B+>Success</B+> z a</TD+><TD CLASS="rdoc"+></TD+></TR+><TR+><TD CLASS="arg"+><A NAME="v%3AFailure"+></A+><B+>Failure</B+> z String</TD+><TD CLASS="rdoc"+></TD+></TR+><TR+><TD CLASS="arg"+><A NAME="v%3ACommitted"+></A+><B+>Committed</B+> (<A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AResult"+>Result</A+> z a)</TD+><TD CLASS="rdoc"+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="section4"+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:Result')" ALT="show/hide"+> Instances</TD+></TR+><TR+><TD CLASS="body"+><DIV ID="i:Result" STYLE="display:block;"+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"+><TR+><TD CLASS="decl"+>Functor (<A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AResult"+>Result</A+> z)</TD+></TR+></TABLE+></DIV+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname" ><A NAME="v%3ArunParser" ></A ><B@@ -339,9 +465,7 @@ ></TR ><TR ><TD CLASS="doc"->Apply a parser to an input token sequence. The parser cannot return- an error value explicitly, so errors raise an exception. Thus, results- can be partial (lazily constructed, but containing undefined).+>Apply a parser to an input token sequence. </TD ></TR ><TR@@ -364,15 +488,15 @@ ><TABLE CLASS="declbar" ><TR ><TD CLASS="declname"-><A NAME="v%3Asatisfy"+><A NAME="v%3Anext" ></A ><B->satisfy</B-> :: (t -> Bool) -> <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser"+>next</B+> :: <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser" >Parser</A > t t</TD ><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly/Lazy.html#satisfy"+><A HREF="src/Text/ParserCombinators/Poly/Lazy.html#next" >Source</A ></TD ></TR@@ -380,11 +504,6 @@ ></TD ></TR ><TR-><TD CLASS="doc"->One token satifying a predicate-</TD-></TR-><TR ><TD CLASS="s15" ></TD ></TR@@ -393,19 +512,15 @@ ><TABLE CLASS="declbar" ><TR ><TD CLASS="declname"-><A NAME="v%3AmanyFinally"+><A NAME="v%3Asatisfy" ></A ><B->manyFinally</B-> :: <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser"->Parser</A-> t z -> <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser"+>satisfy</B+> :: (t -> Bool) -> <A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser" >Parser</A-> t [a]</TD+> t t</TD ><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly/Lazy.html#manyFinally"+><A HREF="src/Text/ParserCombinators/Poly/Lazy.html#satisfy" >Source</A ></TD ></TR@@ -413,21 +528,13 @@ ></TD ></TR ><TR-><TD CLASS="doc"->'manyFinally e t' parses a possibly-empty sequence of e's,- terminated by a t. Any parse failures could be due either to- a badly-formed terminator or a badly-formed element, so raise- both possible errors.-</TD-></TR-><TR ><TD CLASS="s15" ></TD ></TR ><TR ><TD CLASS="section2" ><A NAME="3"->Re-parsing+>re-parsing </A ></TD ></TR
docs/haddock/Text-ParserCombinators-Poly-Plain.html view
@@ -121,7 +121,9 @@ >Parser</A > t a = <A HREF="#v%3AP" >P</A-> ([t] -> (EitherE String a, [t]))</TD+> ([t] -> <A HREF="Text-ParserCombinators-Poly-Plain.html#t%3AResult"+>Result</A+> [t] a)</TD ></TR ><TR ><TD CLASS="s8"@@ -129,6 +131,50 @@ ></TR ><TR ><TD CLASS="decl"+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"+><TR+><TD CLASS="decl"+><SPAN CLASS="keyword"+>data</SPAN+> <A HREF="#t%3AResult"+>Result</A+> z a</TD+></TR+><TR+><TD CLASS="body"+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"+><TR+><TD CLASS="decl"+>= <A HREF="#v%3ASuccess"+>Success</A+> z a</TD+></TR+><TR+><TD CLASS="decl"+>| <A HREF="#v%3AFailure"+>Failure</A+> z String</TD+></TR+><TR+><TD CLASS="decl"+>| <A HREF="#v%3ACommitted"+>Committed</A+> (<A HREF="Text-ParserCombinators-Poly-Plain.html#t%3AResult"+>Result</A+> z a)</TD+></TR+></TABLE+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="decl" ><A HREF="#v%3ArunParser" >runParser</A > :: <A HREF="Text-ParserCombinators-Poly-Plain.html#t%3AParser"@@ -249,7 +295,9 @@ ></A ><B >P</B-> ([t] -> (EitherE String a, [t]))</TD+> ([t] -> <A HREF="Text-ParserCombinators-Poly-Plain.html#t%3AResult"+>Result</A+> [t] a)</TD ><TD CLASS="rdoc" ></TD ></TR@@ -284,6 +332,105 @@ > (<A HREF="Text-ParserCombinators-Poly-Plain.html#t%3AParser" >Parser</A > t)</TD+></TR+></TABLE+></DIV+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname"+><SPAN CLASS="keyword"+>data</SPAN+> <A NAME="t%3AResult"+></A+><B+>Result</B+> z a</TD+><TD CLASS="declbut"+><A HREF="src/Text/ParserCombinators/Poly/Plain.html#Result"+>Source</A+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="body"+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"+><TR+><TD CLASS="ndoc"+>A return type like Either, that distinguishes not only between+ right and wrong answers, but also has commitment, so that a failure+ cannot be undone. This should only be used for writing very primitive+ parsers - really it is an internal detail of the library.+</TD+></TR+><TR+><TD CLASS="section4"+>Constructors</TD+></TR+><TR+><TD CLASS="body"+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"+><TR+><TD CLASS="arg"+><A NAME="v%3ASuccess"+></A+><B+>Success</B+> z a</TD+><TD CLASS="rdoc"+></TD+></TR+><TR+><TD CLASS="arg"+><A NAME="v%3AFailure"+></A+><B+>Failure</B+> z String</TD+><TD CLASS="rdoc"+></TD+></TR+><TR+><TD CLASS="arg"+><A NAME="v%3ACommitted"+></A+><B+>Committed</B+> (<A HREF="Text-ParserCombinators-Poly-Plain.html#t%3AResult"+>Result</A+> z a)</TD+><TD CLASS="rdoc"+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="section4"+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:Result')" ALT="show/hide"+> Instances</TD+></TR+><TR+><TD CLASS="body"+><DIV ID="i:Result" STYLE="display:block;"+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"+><TR+><TD CLASS="decl"+>Functor (<A HREF="Text-ParserCombinators-Poly-Plain.html#t%3AResult"+>Result</A+> z)</TD ></TR ></TABLE ></DIV
docs/haddock/Text-ParserCombinators-Poly-State.html view
@@ -83,14 +83,14 @@ ></DT ><DT ><A HREF="#4"->Re-parsing+>re-parsing </A ></DT ></DL ></DD ><DT ><A HREF="#5"->Re-export all more general combinators.+>Re-export all more general combinators </A ></DT ></DL@@ -126,7 +126,9 @@ >Parser</A > s t a = <A HREF="#v%3AP" >P</A-> (s -> [t] -> (EitherE String a, s, [t]))</TD+> (s -> [t] -> <A HREF="Text-ParserCombinators-Poly-State.html#t%3AResult"+>Result</A+> [t] s a)</TD ></TR ><TR ><TD CLASS="s8"@@ -134,6 +136,50 @@ ></TR ><TR ><TD CLASS="decl"+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"+><TR+><TD CLASS="decl"+><SPAN CLASS="keyword"+>data</SPAN+> <A HREF="#t%3AResult"+>Result</A+> z s a</TD+></TR+><TR+><TD CLASS="body"+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"+><TR+><TD CLASS="decl"+>= <A HREF="#v%3ASuccess"+>Success</A+> z s a</TD+></TR+><TR+><TD CLASS="decl"+>| <A HREF="#v%3AFailure"+>Failure</A+> z s String</TD+></TR+><TR+><TD CLASS="decl"+>| <A HREF="#v%3ACommitted"+>Committed</A+> (<A HREF="Text-ParserCombinators-Poly-State.html#t%3AResult"+>Result</A+> z s a)</TD+></TR+></TABLE+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="decl" ><A HREF="#v%3ArunParser" >runParser</A > :: <A HREF="Text-ParserCombinators-Poly-State.html#t%3AParser"@@ -146,6 +192,18 @@ ></TR ><TR ><TD CLASS="decl"+><A HREF="#v%3Anext"+>next</A+> :: <A HREF="Text-ParserCombinators-Poly-State.html#t%3AParser"+>Parser</A+> s t t</TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="decl" ><A HREF="#v%3Asatisfy" >satisfy</A > :: (t -> Bool) -> <A HREF="Text-ParserCombinators-Poly-State.html#t%3AParser"@@ -257,11 +315,12 @@ ><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0" ><TR ><TD CLASS="ndoc"->The <TT+>This <TT >Parser</TT > datatype is a fairly generic parsing monad with error- reporting and a running state. It can be used for arbitrary token- types, not just String input.+ reporting. It can be used for arbitrary token types, not just+ String input. (If you require a running state, use module PolyState+ instead) </TD ></TR ><TR@@ -277,7 +336,9 @@ ></A ><B >P</B-> (s -> [t] -> (EitherE String a, s, [t]))</TD+> (s -> [t] -> <A HREF="Text-ParserCombinators-Poly-State.html#t%3AResult"+>Result</A+> [t] s a)</TD ><TD CLASS="rdoc" ></TD ></TR@@ -329,6 +390,105 @@ ><TABLE CLASS="declbar" ><TR ><TD CLASS="declname"+><SPAN CLASS="keyword"+>data</SPAN+> <A NAME="t%3AResult"+></A+><B+>Result</B+> z s a</TD+><TD CLASS="declbut"+><A HREF="src/Text/ParserCombinators/Poly/State.html#Result"+>Source</A+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="body"+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"+><TR+><TD CLASS="ndoc"+>A return type like Either, that distinguishes not only between+ right and wrong answers, but also has gradations of wrongness.+ This should only be used for writing very primitive+ parsers - really it is an internal detail of the library.+</TD+></TR+><TR+><TD CLASS="section4"+>Constructors</TD+></TR+><TR+><TD CLASS="body"+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"+><TR+><TD CLASS="arg"+><A NAME="v%3ASuccess"+></A+><B+>Success</B+> z s a</TD+><TD CLASS="rdoc"+></TD+></TR+><TR+><TD CLASS="arg"+><A NAME="v%3AFailure"+></A+><B+>Failure</B+> z s String</TD+><TD CLASS="rdoc"+></TD+></TR+><TR+><TD CLASS="arg"+><A NAME="v%3ACommitted"+></A+><B+>Committed</B+> (<A HREF="Text-ParserCombinators-Poly-State.html#t%3AResult"+>Result</A+> z s a)</TD+><TD CLASS="rdoc"+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="section4"+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:Result')" ALT="show/hide"+> Instances</TD+></TR+><TR+><TD CLASS="body"+><DIV ID="i:Result" STYLE="display:block;"+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"+><TR+><TD CLASS="decl"+>Functor (<A HREF="Text-ParserCombinators-Poly-State.html#t%3AResult"+>Result</A+> z s)</TD+></TR+></TABLE+></DIV+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname" ><A NAME="v%3ArunParser" ></A ><B@@ -346,7 +506,7 @@ ></TR ><TR ><TD CLASS="doc"->Apply a parser to an initial state and input token sequence.+>Apply a parser to an input token sequence. </TD ></TR ><TR@@ -369,6 +529,30 @@ ><TABLE CLASS="declbar" ><TR ><TD CLASS="declname"+><A NAME="v%3Anext"+></A+><B+>next</B+> :: <A HREF="Text-ParserCombinators-Poly-State.html#t%3AParser"+>Parser</A+> s t t</TD+><TD CLASS="declbut"+><A HREF="src/Text/ParserCombinators/Poly/State.html#next"+>Source</A+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname" ><A NAME="v%3Asatisfy" ></A ><B@@ -489,7 +673,7 @@ ><TR ><TD CLASS="section2" ><A NAME="4"->Re-parsing+>re-parsing </A ></TD ></TR@@ -533,7 +717,7 @@ ><TR ><TD CLASS="section1" ><A NAME="5"->Re-export all more general combinators.+>Re-export all more general combinators </A ></TD ></TR
docs/haddock/Text-ParserCombinators-Poly-StateLazy.html view
@@ -66,35 +66,30 @@ ><DL ><DT ><A HREF="#1"->The Parser datatype.-</A-></DT-><DT-><A HREF="#2"->Combinators:+>The Parser datatype </A ></DT ><DD ><DL ><DT-><A HREF="#3"->Primitives+><A HREF="#2"+>basic parsers </A ></DT ><DT-><A HREF="#4"+><A HREF="#3" >State-handling </A ></DT ><DT-><A HREF="#5"->Re-parsing+><A HREF="#4"+>re-parsing </A ></DT ></DL ></DD ><DT-><A HREF="#6"+><A HREF="#5" >Re-export all more general combinators </A ></DT@@ -131,7 +126,9 @@ >Parser</A > s t a = <A HREF="#v%3AP" >P</A-> (s -> [t] -> (Either String a, s, [t]))</TD+> (s -> [t] -> <A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AResult"+>Result</A+> [t] s a)</TD ></TR ><TR ><TD CLASS="s8"@@ -139,6 +136,50 @@ ></TR ><TR ><TD CLASS="decl"+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"+><TR+><TD CLASS="decl"+><SPAN CLASS="keyword"+>data</SPAN+> <A HREF="#t%3AResult"+>Result</A+> z s a</TD+></TR+><TR+><TD CLASS="body"+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"+><TR+><TD CLASS="decl"+>= <A HREF="#v%3ASuccess"+>Success</A+> z s a</TD+></TR+><TR+><TD CLASS="decl"+>| <A HREF="#v%3AFailure"+>Failure</A+> z s String</TD+></TR+><TR+><TD CLASS="decl"+>| <A HREF="#v%3ACommitted"+>Committed</A+> (<A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AResult"+>Result</A+> z s a)</TD+></TR+></TABLE+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="decl" ><A HREF="#v%3ArunParser" >runParser</A > :: <A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AParser"@@ -175,6 +216,22 @@ ></TR ><TR ><TD CLASS="decl"+><A HREF="#v%3AmanyFinally"+>manyFinally</A+> :: <A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AParser"+>Parser</A+> s t a -> <A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AParser"+>Parser</A+> s t z -> <A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AParser"+>Parser</A+> s t [a]</TD+></TR+><TR+><TD CLASS="s8"+></TD+></TR+><TR+><TD CLASS="decl" ><A HREF="#v%3AstUpdate" >stUpdate</A > :: (s -> s) -> <A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AParser"@@ -241,7 +298,7 @@ ><TR ><TD CLASS="section1" ><A NAME="1"->The Parser datatype.+>The Parser datatype </A ></TD ></TR@@ -250,17 +307,6 @@ ></TD ></TR ><TR-><TD CLASS="doc"->Parsers do not return explicit failure. An exception is raised- instead. This allows partial results to be returned before a- full parse is complete.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR ><TD CLASS="topdecl" ><TABLE CLASS="declbar" ><TR@@ -285,11 +331,12 @@ ><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0" ><TR ><TD CLASS="ndoc"->The <TT+>This <TT >Parser</TT > datatype is a fairly generic parsing monad with error- reporting and a running state. It can be used for arbitrary token- types, not just String input.+ reporting. It can be used for arbitrary token types, not just+ String input. (If you require a running state, use module PolyState+ instead) </TD ></TR ><TR@@ -305,7 +352,9 @@ ></A ><B >P</B-> (s -> [t] -> (Either String a, s, [t]))</TD+> (s -> [t] -> <A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AResult"+>Result</A+> [t] s a)</TD ><TD CLASS="rdoc" ></TD ></TR@@ -357,15 +406,15 @@ ><TABLE CLASS="declbar" ><TR ><TD CLASS="declname"-><A NAME="v%3ArunParser"+><SPAN CLASS="keyword"+>data</SPAN+> <A NAME="t%3AResult" ></A ><B->runParser</B-> :: <A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AParser"->Parser</A-> s t a -> s -> [t] -> (a, s, [t])</TD+>Result</B+> z s a</TD ><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly/StateLazy.html#runParser"+><A HREF="src/Text/ParserCombinators/Poly/StateLazy.html#Result" >Source</A ></TD ></TR@@ -373,32 +422,117 @@ ></TD ></TR ><TR-><TD CLASS="doc"->Apply a parser to an initial state and input token sequence.- The parser cannot return an error value explicitly, so errors- raise an exception. Thus, results can be partial (lazily constructed,- but containing undefined).+><TD CLASS="body"+><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"+><TR+><TD CLASS="ndoc"+>A return type like Either, that distinguishes not only between+ right and wrong answers, but also has gradations of wrongness.+ This should only be used for writing very primitive+ parsers - really it is an internal detail of the library. </TD ></TR ><TR+><TD CLASS="section4"+>Constructors</TD+></TR+><TR+><TD CLASS="body"+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"+><TR+><TD CLASS="arg"+><A NAME="v%3ASuccess"+></A+><B+>Success</B+> z s a</TD+><TD CLASS="rdoc"+></TD+></TR+><TR+><TD CLASS="arg"+><A NAME="v%3AFailure"+></A+><B+>Failure</B+> z s String</TD+><TD CLASS="rdoc"+></TD+></TR+><TR+><TD CLASS="arg"+><A NAME="v%3ACommitted"+></A+><B+>Committed</B+> (<A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AResult"+>Result</A+> z s a)</TD+><TD CLASS="rdoc"+></TD+></TR+></TABLE+></TD+></TR+><TR+><TD CLASS="section4"+><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:Result')" ALT="show/hide"+> Instances</TD+></TR+><TR+><TD CLASS="body"+><DIV ID="i:Result" STYLE="display:block;"+><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"+><TR+><TD CLASS="decl"+>Functor (<A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AResult"+>Result</A+> z s)</TD+></TR+></TABLE+></DIV+></TD+></TR+></TABLE+></TD+></TR+><TR ><TD CLASS="s15" ></TD ></TR ><TR-><TD CLASS="section1"-><A NAME="2"->Combinators:-</A+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname"+><A NAME="v%3ArunParser"+></A+><B+>runParser</B+> :: <A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AParser"+>Parser</A+> s t a -> s -> [t] -> (a, s, [t])</TD+><TD CLASS="declbut"+><A HREF="src/Text/ParserCombinators/Poly/StateLazy.html#runParser"+>Source</A ></TD ></TR+></TABLE+></TD+></TR ><TR+><TD CLASS="doc"+>Apply a parser to an input token sequence.+</TD+></TR+><TR ><TD CLASS="s15" ></TD ></TR ><TR ><TD CLASS="section2"-><A NAME="3"->Primitives+><A NAME="2"+>basic parsers </A ></TD ></TR@@ -427,11 +561,6 @@ ></TD ></TR ><TR-><TD CLASS="doc"->Yield one token.-</TD-></TR-><TR ><TD CLASS="s15" ></TD ></TR@@ -456,17 +585,40 @@ ></TD ></TR ><TR-><TD CLASS="doc"->Yield one token if it satisfies a predicate.-</TD+><TD CLASS="s15"+></TD ></TR ><TR+><TD CLASS="topdecl"+><TABLE CLASS="declbar"+><TR+><TD CLASS="declname"+><A NAME="v%3AmanyFinally"+></A+><B+>manyFinally</B+> :: <A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AParser"+>Parser</A+> s t a -> <A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AParser"+>Parser</A+> s t z -> <A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AParser"+>Parser</A+> s t [a]</TD+><TD CLASS="declbut"+><A HREF="src/Text/ParserCombinators/Poly/StateLazy.html#manyFinally"+>Source</A+></TD+></TR+></TABLE+></TD+></TR+><TR ><TD CLASS="s15" ></TD ></TR ><TR ><TD CLASS="section2"-><A NAME="4"+><A NAME="3" >State-handling </A ></TD@@ -564,8 +716,8 @@ ></TR ><TR ><TD CLASS="section2"-><A NAME="5"->Re-parsing+><A NAME="4"+>re-parsing </A ></TD ></TR@@ -608,7 +760,7 @@ ></TR ><TR ><TD CLASS="section1"-><A NAME="6"+><A NAME="5" >Re-export all more general combinators </A ></TD
docs/haddock/Text-ParserCombinators-Poly.html view
@@ -55,1362 +55,34 @@ ><TR ><TD ><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"-><TR-><TD CLASS="section4"-><B->Contents</B-></TD-></TR-><TR-><TD-><DL-><DT-><A HREF="#1"->The Parser datatype-</A-></DT-><DT-><A HREF="#2"->Combinators:-</A-></DT-><DD-><DL-><DT-><A HREF="#3"->Primitives-</A-></DT-><DT-><A HREF="#4"->Error-handling-</A-></DT-><DT-><A HREF="#5"->Choices-</A-></DT-><DT-><A HREF="#6"->Sequences-</A-></DT-><DT-><A HREF="#7"->re-parsing-</A-></DT-></DL-></DD-></DL-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="section1"->Synopsis</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="body"-><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"-><TR-><TD CLASS="decl"-><SPAN CLASS="keyword"->newtype</SPAN-> <A HREF="#t%3AParser"->Parser</A-> t a = <A HREF="#v%3AP"->P</A-> ([t] -> (EitherE String a, [t]))</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3ArunParser"->runParser</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> [t] -> (Either String a, [t])</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3AfailBad"->failBad</A-> :: String -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3Acommit"->commit</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3Anext"->next</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t t</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3Asatisfy"->satisfy</A-> :: (t -> Bool) -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t t</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3Aapply"->apply</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t (a -> b) -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t b</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3Adiscard"->discard</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t b -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3AadjustErr"->adjustErr</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> (String -> String) -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3AadjustErrBad"->adjustErrBad</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> (String -> String) -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3Aindent"->indent</A-> :: Int -> String -> String</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3AonFail"->onFail</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3AoneOf"->oneOf</A-> :: [<A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a] -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3AoneOf%27"->oneOf'</A-> :: [(String, <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a)] -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3Aoptional"->optional</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t (Maybe a)</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3Aexactly"->exactly</A-> :: Int -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t [a]</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3Amany"->many</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t [a]</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3Amany1"->many1</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t [a]</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3AsepBy"->sepBy</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t sep -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t [a]</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3AsepBy1"->sepBy1</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t sep -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t [a]</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3AbracketSep"->bracketSep</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t bra -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t sep -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t ket -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t [a]</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3Abracket"->bracket</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t bra -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t ket -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3AmanyFinally"->manyFinally</A-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t z -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t [a]</TD-></TR-><TR-><TD CLASS="s8"-></TD-></TR-><TR-><TD CLASS="decl"-><A HREF="#v%3Areparse"->reparse</A-> :: [t] -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t ()</TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="section1"-><A NAME="1"->The Parser datatype-</A-></TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><SPAN CLASS="keyword"->newtype</SPAN-> <A NAME="t%3AParser"-></A-><B->Parser</B-> t a</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#Parser"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="body"-><TABLE CLASS="vanilla" CELLSPACING="0" CELLPADDING="0"-><TR-><TD CLASS="ndoc"->The <TT->Parser</TT-> datatype is a fairly generic parsing monad with error- reporting. It can be used for arbitrary token types, not just- String input. (If you require a running state, use module PolyState- instead)-</TD-></TR-><TR-><TD CLASS="section4"->Constructors</TD-></TR-><TR-><TD CLASS="body"-><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"-><TR-><TD CLASS="arg"-><A NAME="v%3AP"-></A-><B->P</B-> ([t] -> (EitherE String a, [t]))</TD-><TD CLASS="rdoc"-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="section4"-><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'i:Parser')" ALT="show/hide"-> Instances</TD-></TR-><TR-><TD CLASS="body"-><DIV ID="i:Parser" STYLE="display:block;"-><TABLE CLASS="vanilla" CELLSPACING="1" CELLPADDING="0"-><TR-><TD CLASS="decl"->Functor (<A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t)</TD-></TR-><TR-><TD CLASS="decl"->Monad (<A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t)</TD-></TR-></TABLE-></DIV-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3ArunParser"-></A-><B->runParser</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> [t] -> (Either String a, [t])</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#runParser"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->Apply a parser to an input token sequence.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3AfailBad"-></A-><B->failBad</B-> :: String -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#failBad"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->When a simple fail is not strong enough, use failBad for emphasis.- An emphasised (severe) error can propagate out through choice operators.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3Acommit"-></A-><B->commit</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#commit"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->Commit is a way of raising the severity of any errors found within- its argument. Used in the middle of a parser definition, it means that- any operations prior to commitment fail softly, but after commitment,- they fail hard.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="section1"-><A NAME="2"->Combinators:-</A-></TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="section2"-><A NAME="3"->Primitives-</A-></TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3Anext"-></A-><B->next</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t t</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#next"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->One token-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3Asatisfy"-></A-><B->satisfy</B-> :: (t -> Bool) -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t t</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#satisfy"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->One token satifying a predicate-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3Aapply"-></A-><B->apply</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t (a -> b) -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t b</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#apply"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->Apply a parsed function to a parsed value-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3Adiscard"-></A-><B->discard</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t b -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#discard"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"-><TT->x <TT-><A HREF="Text-ParserCombinators-Poly.html#v%3Adiscard"->discard</A-></TT-> y</TT-> parses both x and y, but discards the result of y-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="section2"-><A NAME="4"->Error-handling-</A-></TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3AadjustErr"-></A-><B->adjustErr</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> (String -> String) -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#adjustErr"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"-><TT->p <TT-><A HREF="Text-ParserCombinators-Poly.html#v%3AadjustErr"->adjustErr</A-></TT-> f</TT-> applies the transformation <TT->f</TT-> to any error message- generated in <TT->p</TT->, having no effect if <TT->p</TT-> succeeds.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3AadjustErrBad"-></A-><B->adjustErrBad</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> (String -> String) -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#adjustErrBad"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"-><TT->adjustErrBad</TT-> is just like <TT->adjustErr</TT-> except it also raises the- severity of the error.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3Aindent"-></A-><B->indent</B-> :: Int -> String -> String</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#indent"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->Helper for formatting error messages: indents all lines by a fixed amount.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="section2"-><A NAME="5"->Choices-</A-></TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3AonFail"-></A-><B->onFail</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#onFail"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"-><TT->p <TT-><A HREF="Text-ParserCombinators-Poly.html#v%3AonFail"->onFail</A-></TT-> q</TT-> means parse p unless p fails in which case parse q instead.- Can be chained together to give multiple attempts to parse something.- (Note that q could itself be a failing parser, e.g. to change the error- message from that defined in p to something different.)- However, a *severe* failure in p cannot be ignored.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3AoneOf"-></A-><B->oneOf</B-> :: [<A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a] -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#oneOf"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->Parse the first alternative in the list that succeeds.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3AoneOf%27"-></A-><B->oneOf'</B-> :: [(String, <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a)] -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#oneOf%27"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->Parse the first alternative that succeeds, but if none succeed,- report only the severe errors, and if none of those, then report- all the soft errors.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3Aoptional"-></A-><B->optional</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t (Maybe a)</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#optional"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"-><TT-><A HREF="Text-ParserCombinators-Poly.html#v%3Aoptional"->optional</A-></TT-> indicates whether the parser succeeded through the Maybe type.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="section2"-><A NAME="6"->Sequences-</A-></TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3Aexactly"-></A-><B->exactly</B-> :: Int -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t [a]</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#exactly"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->'exactly n p' parses a precise number of items, n, using the parser- p, in sequence.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3Amany"-></A-><B->many</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t [a]</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#many"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->'many p' parses a list of elements with individual parser p.- Cannot fail, since an empty list is a valid return value.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3Amany1"-></A-><B->many1</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t [a]</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#many1"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->Parse a non-empty list of items.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3AsepBy"-></A-><B->sepBy</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t sep -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t [a]</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#sepBy"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->Parse a list of items separated by discarded junk.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3AsepBy1"-></A-><B->sepBy1</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t sep -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t [a]</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#sepBy1"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->Parse a non-empty list of items separated by discarded junk.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3AbracketSep"-></A-><B->bracketSep</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t bra -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t sep -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t ket -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t [a]</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#bracketSep"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->Parse a list of items, discarding the start, end, and separator- items.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3Abracket"-></A-><B->bracket</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t bra -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t ket -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#bracket"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->Parse a bracketed item, discarding the brackets.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3AmanyFinally"-></A-><B->manyFinally</B-> :: <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t a -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t z -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t [a]</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#manyFinally"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->'manyFinally e t' parses a possibly-empty sequence of e's,- terminated by a t. Any parse failures could be due either to- a badly-formed terminator or a badly-formed element, so raise- both possible errors.-</TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="section2"-><A NAME="7"->re-parsing-</A-></TD-></TR-><TR-><TD CLASS="s15"-></TD-></TR-><TR-><TD CLASS="topdecl"-><TABLE CLASS="declbar"-><TR-><TD CLASS="declname"-><A NAME="v%3Areparse"-></A-><B->reparse</B-> :: [t] -> <A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Parser</A-> t ()</TD-><TD CLASS="declbut"-><A HREF="src/Text/ParserCombinators/Poly.html#reparse"->Source</A-></TD-></TR-></TABLE-></TD-></TR-><TR-><TD CLASS="doc"->Push some tokens back onto the front of the input stream and reparse.- This is useful e.g. for recursively expanding macros. When the- user-parser recognises a macro use, it can lookup the macro- expansion from the parse state, lex it, and then stuff the- lexed expansion back down into the parser.-</TD+></TABLE+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="section1"+>Documentation</TD+></TR+><TR+><TD CLASS="s15"+></TD+></TR+><TR+><TD CLASS="decl"+>module <A HREF="Text-ParserCombinators-Poly-Plain.html"+>Text.ParserCombinators.Poly.Plain</A+></TD ></TR ><TR ><TD CLASS="s15"
docs/haddock/doc-index-A.html view
@@ -122,92 +122,20 @@ ><TD ><TABLE CELLPADDING="0" CELLSPACING="5" ><TR-><TD CLASS="indexentry" COLSPAN="2"+><TD CLASS="indexentry" >adjustErr</TD-></TR-><TR-><TD CLASS="indexannot"->1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3AadjustErr"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3AadjustErr" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3AadjustErr"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3AadjustErr"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3AadjustErr"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR-><TD CLASS="indexentry" COLSPAN="2"+><TD CLASS="indexentry" >adjustErrBad</TD-></TR-><TR-><TD CLASS="indexannot"->1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3AadjustErrBad"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3AadjustErrBad" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3AadjustErrBad"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3AadjustErrBad"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3AadjustErrBad"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexentry"@@ -218,48 +146,12 @@ ></TD ></TR ><TR-><TD CLASS="indexentry" COLSPAN="2"+><TD CLASS="indexentry" >apply</TD-></TR-><TR-><TD CLASS="indexannot"->1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3Aapply"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3Aapply" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3Aapply"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3Aapply"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3Aapply"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ></TABLE ></TD
docs/haddock/doc-index-B.html view
@@ -145,85 +145,17 @@ ><TD CLASS="indexannot" >3 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3Abracket"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3Abracket" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3Abracket"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->6 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3Abracket"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->7 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3Abracket"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR-><TD CLASS="indexentry" COLSPAN="2"+><TD CLASS="indexentry" >bracketSep</TD-></TR-><TR-><TD CLASS="indexannot"->1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3AbracketSep"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3AbracketSep" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3AbracketSep"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3AbracketSep"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3AbracketSep"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ></TABLE ></TD
docs/haddock/doc-index-C.html view
@@ -123,6 +123,42 @@ ><TABLE CELLPADDING="0" CELLSPACING="5" ><TR ><TD CLASS="indexentry" COLSPAN="2"+>Committed</TD+></TR+><TR+><TD CLASS="indexannot"+>1 (Data Constructor)</TD+><TD CLASS="indexlinks"+><A HREF="Text-ParserCombinators-Poly-Lazy.html#v%3ACommitted"+>Text.ParserCombinators.Poly.Lazy</A+></TD+></TR+><TR+><TD CLASS="indexannot"+>2 (Data Constructor)</TD+><TD CLASS="indexlinks"+><A HREF="Text-ParserCombinators-Poly-Plain.html#v%3ACommitted"+>Text.ParserCombinators.Poly.Plain</A+>, Text.ParserCombinators.Poly, Text.Parse</TD+></TR+><TR+><TD CLASS="indexannot"+>3 (Data Constructor)</TD+><TD CLASS="indexlinks"+><A HREF="Text-ParserCombinators-Poly-State.html#v%3ACommitted"+>Text.ParserCombinators.Poly.State</A+></TD+></TR+><TR+><TD CLASS="indexannot"+>4 (Data Constructor)</TD+><TD CLASS="indexlinks"+><A HREF="Text-ParserCombinators-Poly-StateLazy.html#v%3ACommitted"+>Text.ParserCombinators.Poly.StateLazy</A+></TD+></TR+><TR+><TD CLASS="indexentry" COLSPAN="2" >chainl</TD ></TR ><TR@@ -218,48 +254,12 @@ ></TD ></TR ><TR-><TD CLASS="indexentry" COLSPAN="2"+><TD CLASS="indexentry" >commit</TD-></TR-><TR-><TD CLASS="indexannot"->1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3Acommit"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3Acommit" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3Acommit"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3Acommit"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3Acommit"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexentry"
docs/haddock/doc-index-D.html view
@@ -130,48 +130,12 @@ ></TD ></TR ><TR-><TD CLASS="indexentry" COLSPAN="2"+><TD CLASS="indexentry" >discard</TD-></TR-><TR-><TD CLASS="indexannot"->1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3Adiscard"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3Adiscard" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3Adiscard"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3Adiscard"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3Adiscard"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ></TABLE ></TD
docs/haddock/doc-index-E.html view
@@ -146,48 +146,12 @@ ></TD ></TR ><TR-><TD CLASS="indexentry" COLSPAN="2"+><TD CLASS="indexentry" >exactly</TD-></TR-><TR-><TD CLASS="indexannot"->1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3Aexactly"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3Aexactly" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3Aexactly"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3Aexactly"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3Aexactly"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ></TABLE ></TD
docs/haddock/doc-index-F.html view
@@ -123,47 +123,47 @@ ><TABLE CELLPADDING="0" CELLSPACING="5" ><TR ><TD CLASS="indexentry" COLSPAN="2"->failBad</TD+>Failure</TD ></TR ><TR ><TD CLASS="indexannot"->1 (Function)</TD+>1 (Data Constructor)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3AfailBad"->Text.ParserCombinators.Poly</A->, Text.Parse</TD+><A HREF="Text-ParserCombinators-Poly-Lazy.html#v%3AFailure"+>Text.ParserCombinators.Poly.Lazy</A+></TD ></TR ><TR ><TD CLASS="indexannot"->2 (Function)</TD+>2 (Data Constructor)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-Base.html#v%3AfailBad"->Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD+><A HREF="Text-ParserCombinators-Poly-Plain.html#v%3AFailure"+>Text.ParserCombinators.Poly.Plain</A+>, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexannot"->3 (Function)</TD+>3 (Data Constructor)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3AfailBad"->Text.ParserCombinators.PolyLazy</A+><A HREF="Text-ParserCombinators-Poly-State.html#v%3AFailure"+>Text.ParserCombinators.Poly.State</A ></TD ></TR ><TR ><TD CLASS="indexannot"->4 (Function)</TD+>4 (Data Constructor)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3AfailBad"->Text.ParserCombinators.PolyState</A+><A HREF="Text-ParserCombinators-Poly-StateLazy.html#v%3AFailure"+>Text.ParserCombinators.Poly.StateLazy</A ></TD ></TR ><TR-><TD CLASS="indexannot"->5 (Function)</TD+><TD CLASS="indexentry"+>failBad</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3AfailBad"->Text.ParserCombinators.PolyStateLazy</A-></TD+><A HREF="Text-ParserCombinators-Poly-Base.html#v%3AfailBad"+>Text.ParserCombinators.Poly.Base</A+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexentry"
docs/haddock/doc-index-I.html view
@@ -138,48 +138,12 @@ ></TD ></TR ><TR-><TD CLASS="indexentry" COLSPAN="2"+><TD CLASS="indexentry" >indent</TD-></TR-><TR-><TD CLASS="indexannot"->1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3Aindent"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3Aindent" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3Aindent"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3Aindent"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3Aindent"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexentry"
docs/haddock/doc-index-M.html view
@@ -145,41 +145,9 @@ ><TD CLASS="indexannot" >3 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3Amany"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3Amany" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3Amany"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->6 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3Amany"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->7 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3Amany"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexentry" COLSPAN="2"@@ -205,41 +173,9 @@ ><TD CLASS="indexannot" >3 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3Amany1"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3Amany1" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3Amany1"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->6 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3Amany1"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->7 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3Amany1"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexentry" COLSPAN="2"@@ -249,56 +185,16 @@ ><TD CLASS="indexannot" >1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3AmanyFinally"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3AmanyFinally" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-Lazy.html#v%3AmanyFinally"->Text.ParserCombinators.Poly.Lazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-StateLazy.html#v%3AmanyFinally"->Text.ParserCombinators.Poly.NoLeak.StateLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3AmanyFinally"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->6 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3AmanyFinally"->Text.ParserCombinators.PolyState</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexannot"->7 (Function)</TD+>2 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3AmanyFinally"->Text.ParserCombinators.PolyStateLazy</A+><A HREF="Text-ParserCombinators-Poly-StateLazy.html#v%3AmanyFinally"+>Text.ParserCombinators.Poly.StateLazy</A ></TD ></TR ></TABLE
docs/haddock/doc-index-N.html view
@@ -145,90 +145,32 @@ ><TD CLASS="indexannot" >1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3Anext"->Text.ParserCombinators.Poly</A->, Text.Parse</TD+><A HREF="Text-ParserCombinators-Poly-Lazy.html#v%3Anext"+>Text.ParserCombinators.Poly.Lazy</A+></TD ></TR ><TR ><TD CLASS="indexannot" >2 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-Lazy.html#v%3Anext"->Text.ParserCombinators.Poly.NoLeak.Lazy</A-></TD+><A HREF="Text-ParserCombinators-Poly-Plain.html#v%3Anext"+>Text.ParserCombinators.Poly.Plain</A+>, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexannot" >3 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-Plain.html#v%3Anext"->Text.ParserCombinators.Poly.NoLeak.Plain</A+><A HREF="Text-ParserCombinators-Poly-State.html#v%3Anext"+>Text.ParserCombinators.Poly.State</A ></TD ></TR ><TR ><TD CLASS="indexannot" >4 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-State.html#v%3Anext"->Text.ParserCombinators.Poly.NoLeak.State</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-StateLazy.html#v%3Anext"->Text.ParserCombinators.Poly.NoLeak.StateLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->6 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-Plain.html#v%3Anext"->Text.ParserCombinators.Poly.Plain</A-></TD-></TR-><TR-><TD CLASS="indexannot"->7 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-StateLazy.html#v%3Anext" >Text.ParserCombinators.Poly.StateLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->8 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3Anext"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->9 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3Anext"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->10 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3Anext"->Text.ParserCombinators.PolyStateLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->11 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-Lazy.html#v%3Anext"->Text.ParserCombinators.Poly.Lazy</A->, <A HREF="Text-ParserCombinators-Poly-State.html#v%3Anext"->Text.ParserCombinators.Poly.State</A ></TD ></TR ><TR
docs/haddock/doc-index-O.html view
@@ -122,136 +122,28 @@ ><TD ><TABLE CELLPADDING="0" CELLSPACING="5" ><TR-><TD CLASS="indexentry" COLSPAN="2"+><TD CLASS="indexentry" >onFail</TD-></TR-><TR-><TD CLASS="indexannot"->1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3AonFail"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3AonFail" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3AonFail"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3AonFail"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3AonFail"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR-><TD CLASS="indexentry" COLSPAN="2"+><TD CLASS="indexentry" >oneOf</TD-></TR-><TR-><TD CLASS="indexannot"->1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3AoneOf"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3AoneOf" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3AoneOf"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3AoneOf"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3AoneOf"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR-><TD CLASS="indexentry" COLSPAN="2"+><TD CLASS="indexentry" >oneOf'</TD-></TR-><TR-><TD CLASS="indexannot"->1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3AoneOf%27"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3AoneOf%27" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3AoneOf%27"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3AoneOf%27"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3AoneOf%27"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexentry" COLSPAN="2"@@ -274,40 +166,12 @@ ></TD ></TR ><TR-><TD CLASS="indexentry" COLSPAN="2"+><TD CLASS="indexentry" >optional</TD-></TR-><TR-><TD CLASS="indexannot"->1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3Aoptional"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3Aoptional" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3Aoptional"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3Aoptional"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexentry"
docs/haddock/doc-index-P.html view
@@ -145,61 +145,21 @@ ><TD CLASS="indexannot" >3 (Data Constructor)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3AP"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->4 (Data Constructor)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Lazy.html#v%3AP" >Text.ParserCombinators.Poly.Lazy</A ></TD ></TR ><TR ><TD CLASS="indexannot"->5 (Data Constructor)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-Lazy.html#v%3AP"->Text.ParserCombinators.Poly.NoLeak.Lazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->6 (Data Constructor)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-Plain.html#v%3AP"->Text.ParserCombinators.Poly.NoLeak.Plain</A-></TD-></TR-><TR-><TD CLASS="indexannot"->7 (Data Constructor)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-State.html#v%3AP"->Text.ParserCombinators.Poly.NoLeak.State</A-></TD-></TR-><TR-><TD CLASS="indexannot"->8 (Data Constructor)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-StateLazy.html#v%3AP"->Text.ParserCombinators.Poly.NoLeak.StateLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->9 (Data Constructor)</TD+>4 (Data Constructor)</TD ><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Plain.html#v%3AP" >Text.ParserCombinators.Poly.Plain</A-></TD+>, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexannot"->10 (Data Constructor)</TD+>5 (Data Constructor)</TD ><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-State.html#v%3AP" >Text.ParserCombinators.Poly.State</A@@ -207,37 +167,13 @@ ></TR ><TR ><TD CLASS="indexannot"->11 (Data Constructor)</TD+>6 (Data Constructor)</TD ><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-StateLazy.html#v%3AP" >Text.ParserCombinators.Poly.StateLazy</A ></TD ></TR ><TR-><TD CLASS="indexannot"->12 (Data Constructor)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3AP"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->13 (Data Constructor)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3AP"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->14 (Data Constructor)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3AP"->Text.ParserCombinators.PolyStateLazy</A-></TD-></TR-><TR ><TD CLASS="indexentry" >Parse</TD ><TD CLASS="indexlinks"@@ -269,155 +205,163 @@ ><TD CLASS="indexannot" >3 (Type/Class)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#t%3AParser"->Text.ParserCombinators.Poly</A->, Text.Parse</TD+><A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser"+>Text.ParserCombinators.Poly.Lazy</A+></TD ></TR ><TR ><TD CLASS="indexannot" >4 (Type/Class)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AParser"->Text.ParserCombinators.Poly.Lazy</A-></TD+><A HREF="Text-ParserCombinators-Poly-Plain.html#t%3AParser"+>Text.ParserCombinators.Poly.Plain</A+>, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexannot" >5 (Type/Class)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-Lazy.html#t%3AParser"->Text.ParserCombinators.Poly.NoLeak.Lazy</A+><A HREF="Text-ParserCombinators-Poly-State.html#t%3AParser"+>Text.ParserCombinators.Poly.State</A ></TD ></TR ><TR ><TD CLASS="indexannot" >6 (Type/Class)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-Plain.html#t%3AParser"->Text.ParserCombinators.Poly.NoLeak.Plain</A+><A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AParser"+>Text.ParserCombinators.Poly.StateLazy</A ></TD ></TR ><TR-><TD CLASS="indexannot"->7 (Type/Class)</TD+><TD CLASS="indexentry"+>PolyParse</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-State.html#t%3AParser"->Text.ParserCombinators.Poly.NoLeak.State</A-></TD+><A HREF="Text-ParserCombinators-Poly-Base.html#t%3APolyParse"+>Text.ParserCombinators.Poly.Base</A+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR+><TD CLASS="indexentry" COLSPAN="2"+>papply</TD+></TR+><TR ><TD CLASS="indexannot"->8 (Type/Class)</TD+>1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-StateLazy.html#t%3AParser"->Text.ParserCombinators.Poly.NoLeak.StateLazy</A+><A HREF="Text-ParserCombinators-HuttonMeijer.html#v%3Apapply"+>Text.ParserCombinators.HuttonMeijer</A ></TD ></TR ><TR ><TD CLASS="indexannot"->9 (Type/Class)</TD+>2 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-Plain.html#t%3AParser"->Text.ParserCombinators.Poly.Plain</A+><A HREF="Text-ParserCombinators-HuttonMeijerWallace.html#v%3Apapply"+>Text.ParserCombinators.HuttonMeijerWallace</A ></TD ></TR ><TR-><TD CLASS="indexannot"->10 (Type/Class)</TD+><TD CLASS="indexentry"+>papply'</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-State.html#t%3AParser"->Text.ParserCombinators.Poly.State</A+><A HREF="Text-ParserCombinators-HuttonMeijerWallace.html#v%3Apapply%27"+>Text.ParserCombinators.HuttonMeijerWallace</A ></TD ></TR ><TR-><TD CLASS="indexannot"->11 (Type/Class)</TD+><TD CLASS="indexentry"+>parens</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AParser"->Text.ParserCombinators.Poly.StateLazy</A+><A HREF="Text-Parse.html#v%3Aparens"+>Text.Parse</A ></TD ></TR ><TR-><TD CLASS="indexannot"->12 (Type/Class)</TD+><TD CLASS="indexentry"+>parse</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#t%3AParser"->Text.ParserCombinators.PolyLazy</A+><A HREF="Text-Parse.html#v%3Aparse"+>Text.Parse</A ></TD ></TR ><TR-><TD CLASS="indexannot"->13 (Type/Class)</TD+><TD CLASS="indexentry"+>parseByRead</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#t%3AParser"->Text.ParserCombinators.PolyState</A+><A HREF="Text-Parse.html#v%3AparseByRead"+>Text.Parse</A ></TD ></TR ><TR-><TD CLASS="indexannot"->14 (Type/Class)</TD+><TD CLASS="indexentry"+>parseDec</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#t%3AParser"->Text.ParserCombinators.PolyStateLazy</A+><A HREF="Text-Parse.html#v%3AparseDec"+>Text.Parse</A ></TD ></TR ><TR ><TD CLASS="indexentry"->PolyParse</TD+>parseFloat</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-Base.html#t%3APolyParse"->Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD+><A HREF="Text-Parse.html#v%3AparseFloat"+>Text.Parse</A+></TD ></TR ><TR-><TD CLASS="indexentry" COLSPAN="2"->papply</TD+><TD CLASS="indexentry"+>parseHex</TD+><TD CLASS="indexlinks"+><A HREF="Text-Parse.html#v%3AparseHex"+>Text.Parse</A+></TD ></TR ><TR-><TD CLASS="indexannot"->1 (Function)</TD+><TD CLASS="indexentry"+>parseInt</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-HuttonMeijer.html#v%3Apapply"->Text.ParserCombinators.HuttonMeijer</A+><A HREF="Text-Parse.html#v%3AparseInt"+>Text.Parse</A ></TD ></TR ><TR-><TD CLASS="indexannot"->2 (Function)</TD+><TD CLASS="indexentry"+>parseList</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-HuttonMeijerWallace.html#v%3Apapply"->Text.ParserCombinators.HuttonMeijerWallace</A+><A HREF="Text-Parse.html#v%3AparseList"+>Text.Parse</A ></TD ></TR ><TR ><TD CLASS="indexentry"->papply'</TD+>parseLitChar</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-HuttonMeijerWallace.html#v%3Apapply%27"->Text.ParserCombinators.HuttonMeijerWallace</A+><A HREF="Text-Parse.html#v%3AparseLitChar"+>Text.Parse</A ></TD ></TR ><TR ><TD CLASS="indexentry"->parse</TD+>parseOct</TD ><TD CLASS="indexlinks"-><A HREF="Text-Parse.html#v%3Aparse"+><A HREF="Text-Parse.html#v%3AparseOct" >Text.Parse</A ></TD ></TR ><TR ><TD CLASS="indexentry"->parseByRead</TD+>parsePrec</TD ><TD CLASS="indexlinks"-><A HREF="Text-Parse.html#v%3AparseByRead"+><A HREF="Text-Parse.html#v%3AparsePrec" >Text.Parse</A ></TD ></TR ><TR ><TD CLASS="indexentry"->parseList</TD+>parseSigned</TD ><TD CLASS="indexlinks"-><A HREF="Text-Parse.html#v%3AparseList"+><A HREF="Text-Parse.html#v%3AparseSigned" >Text.Parse</A ></TD ></TR
docs/haddock/doc-index-R.html view
@@ -123,75 +123,71 @@ ><TABLE CELLPADDING="0" CELLSPACING="5" ><TR ><TD CLASS="indexentry" COLSPAN="2"->reparse</TD+>Result</TD ></TR ><TR ><TD CLASS="indexannot"->1 (Function)</TD+>1 (Type/Class)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-HuttonMeijerWallace.html#v%3Areparse"->Text.ParserCombinators.HuttonMeijerWallace</A+><A HREF="Text-ParserCombinators-Poly-Lazy.html#t%3AResult"+>Text.ParserCombinators.Poly.Lazy</A ></TD ></TR ><TR ><TD CLASS="indexannot"->2 (Function)</TD+>2 (Type/Class)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3Areparse"->Text.ParserCombinators.Poly</A->, Text.Parse</TD+><A HREF="Text-ParserCombinators-Poly-Plain.html#t%3AResult"+>Text.ParserCombinators.Poly.Plain</A+>, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexannot"->3 (Function)</TD+>3 (Type/Class)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-Lazy.html#v%3Areparse"->Text.ParserCombinators.Poly.Lazy</A+><A HREF="Text-ParserCombinators-Poly-State.html#t%3AResult"+>Text.ParserCombinators.Poly.State</A ></TD ></TR ><TR ><TD CLASS="indexannot"->4 (Function)</TD+>4 (Type/Class)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-Lazy.html#v%3Areparse"->Text.ParserCombinators.Poly.NoLeak.Lazy</A+><A HREF="Text-ParserCombinators-Poly-StateLazy.html#t%3AResult"+>Text.ParserCombinators.Poly.StateLazy</A ></TD ></TR ><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-Plain.html#v%3Areparse"->Text.ParserCombinators.Poly.NoLeak.Plain</A-></TD+><TD CLASS="indexentry" COLSPAN="2"+>reparse</TD ></TR ><TR ><TD CLASS="indexannot"->6 (Function)</TD+>1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-State.html#v%3Areparse"->Text.ParserCombinators.Poly.NoLeak.State</A+><A HREF="Text-ParserCombinators-HuttonMeijerWallace.html#v%3Areparse"+>Text.ParserCombinators.HuttonMeijerWallace</A ></TD ></TR ><TR ><TD CLASS="indexannot"->7 (Function)</TD+>2 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-StateLazy.html#v%3Areparse"->Text.ParserCombinators.Poly.NoLeak.StateLazy</A+><A HREF="Text-ParserCombinators-Poly-Lazy.html#v%3Areparse"+>Text.ParserCombinators.Poly.Lazy</A ></TD ></TR ><TR ><TD CLASS="indexannot"->8 (Function)</TD+>3 (Function)</TD ><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Plain.html#v%3Areparse" >Text.ParserCombinators.Poly.Plain</A-></TD+>, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexannot"->9 (Function)</TD+>4 (Function)</TD ><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-State.html#v%3Areparse" >Text.ParserCombinators.Poly.State</A@@ -199,37 +195,13 @@ ></TR ><TR ><TD CLASS="indexannot"->10 (Function)</TD+>5 (Function)</TD ><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-StateLazy.html#v%3Areparse" >Text.ParserCombinators.Poly.StateLazy</A ></TD ></TR ><TR-><TD CLASS="indexannot"->11 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3Areparse"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->12 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3Areparse"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->13 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3Areparse"->Text.ParserCombinators.PolyStateLazy</A-></TD-></TR-><TR ><TD CLASS="indexentry" COLSPAN="2" >runParser</TD ></TR@@ -237,61 +209,21 @@ ><TD CLASS="indexannot" >1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3ArunParser"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Lazy.html#v%3ArunParser" >Text.ParserCombinators.Poly.Lazy</A ></TD ></TR ><TR ><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-Lazy.html#v%3ArunParser"->Text.ParserCombinators.Poly.NoLeak.Lazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-Plain.html#v%3ArunParser"->Text.ParserCombinators.Poly.NoLeak.Plain</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-State.html#v%3ArunParser"->Text.ParserCombinators.Poly.NoLeak.State</A-></TD-></TR-><TR-><TD CLASS="indexannot"->6 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-StateLazy.html#v%3ArunParser"->Text.ParserCombinators.Poly.NoLeak.StateLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->7 (Function)</TD+>2 (Function)</TD ><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Plain.html#v%3ArunParser" >Text.ParserCombinators.Poly.Plain</A-></TD+>, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexannot"->8 (Function)</TD+>3 (Function)</TD ><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-State.html#v%3ArunParser" >Text.ParserCombinators.Poly.State</A@@ -299,34 +231,10 @@ ></TR ><TR ><TD CLASS="indexannot"->9 (Function)</TD+>4 (Function)</TD ><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-StateLazy.html#v%3ArunParser" >Text.ParserCombinators.Poly.StateLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->10 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3ArunParser"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->11 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3ArunParser"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->12 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3ArunParser"->Text.ParserCombinators.PolyStateLazy</A ></TD ></TR ></TABLE
docs/haddock/doc-index-S.html view
@@ -122,200 +122,100 @@ ><TD ><TABLE CELLPADDING="0" CELLSPACING="5" ><TR-><TD CLASS="indexentry"->sat</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-HuttonMeijer.html#v%3Asat"->Text.ParserCombinators.HuttonMeijer</A-></TD-></TR-><TR ><TD CLASS="indexentry" COLSPAN="2"->satisfy</TD-></TR-><TR-><TD CLASS="indexannot"->1 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3Asatisfy"->Text.ParserCombinators.Poly</A->, Text.Parse</TD+>Success</TD ></TR ><TR ><TD CLASS="indexannot"->2 (Function)</TD+>1 (Data Constructor)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-Lazy.html#v%3Asatisfy"+><A HREF="Text-ParserCombinators-Poly-Lazy.html#v%3ASuccess" >Text.ParserCombinators.Poly.Lazy</A ></TD ></TR ><TR ><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-Lazy.html#v%3Asatisfy"->Text.ParserCombinators.Poly.NoLeak.Lazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-Plain.html#v%3Asatisfy"->Text.ParserCombinators.Poly.NoLeak.Plain</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-State.html#v%3Asatisfy"->Text.ParserCombinators.Poly.NoLeak.State</A-></TD-></TR-><TR-><TD CLASS="indexannot"->6 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-StateLazy.html#v%3Asatisfy"->Text.ParserCombinators.Poly.NoLeak.StateLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->7 (Function)</TD+>2 (Data Constructor)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-Plain.html#v%3Asatisfy"+><A HREF="Text-ParserCombinators-Poly-Plain.html#v%3ASuccess" >Text.ParserCombinators.Poly.Plain</A-></TD+>, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexannot"->8 (Function)</TD+>3 (Data Constructor)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-State.html#v%3Asatisfy"+><A HREF="Text-ParserCombinators-Poly-State.html#v%3ASuccess" >Text.ParserCombinators.Poly.State</A ></TD ></TR ><TR ><TD CLASS="indexannot"->9 (Function)</TD+>4 (Data Constructor)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-StateLazy.html#v%3Asatisfy"+><A HREF="Text-ParserCombinators-Poly-StateLazy.html#v%3ASuccess" >Text.ParserCombinators.Poly.StateLazy</A ></TD ></TR ><TR-><TD CLASS="indexannot"->10 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3Asatisfy"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->11 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3Asatisfy"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->12 (Function)</TD+><TD CLASS="indexentry"+>sat</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3Asatisfy"->Text.ParserCombinators.PolyStateLazy</A+><A HREF="Text-ParserCombinators-HuttonMeijer.html#v%3Asat"+>Text.ParserCombinators.HuttonMeijer</A ></TD ></TR ><TR ><TD CLASS="indexentry" COLSPAN="2"->sepBy</TD+>satisfy</TD ></TR ><TR ><TD CLASS="indexannot" >1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3AsepBy"->Text.ParserCombinators.Poly</A->, Text.Parse</TD+><A HREF="Text-ParserCombinators-Poly-Lazy.html#v%3Asatisfy"+>Text.ParserCombinators.Poly.Lazy</A+></TD ></TR ><TR ><TD CLASS="indexannot" >2 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-Base.html#v%3AsepBy"->Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD+><A HREF="Text-ParserCombinators-Poly-Plain.html#v%3Asatisfy"+>Text.ParserCombinators.Poly.Plain</A+>, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexannot" >3 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3AsepBy"->Text.ParserCombinators.PolyLazy</A+><A HREF="Text-ParserCombinators-Poly-State.html#v%3Asatisfy"+>Text.ParserCombinators.Poly.State</A ></TD ></TR ><TR ><TD CLASS="indexannot" >4 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3AsepBy"->Text.ParserCombinators.PolyState</A+><A HREF="Text-ParserCombinators-Poly-StateLazy.html#v%3Asatisfy"+>Text.ParserCombinators.Poly.StateLazy</A ></TD ></TR ><TR-><TD CLASS="indexannot"->5 (Function)</TD+><TD CLASS="indexentry"+>sepBy</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3AsepBy"->Text.ParserCombinators.PolyStateLazy</A-></TD+><A HREF="Text-ParserCombinators-Poly-Base.html#v%3AsepBy"+>Text.ParserCombinators.Poly.Base</A+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR-><TD CLASS="indexentry" COLSPAN="2"+><TD CLASS="indexentry" >sepBy1</TD-></TR-><TR-><TD CLASS="indexannot"->1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly.html#v%3AsepBy1"->Text.ParserCombinators.Poly</A->, Text.Parse</TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-Base.html#v%3AsepBy1" >Text.ParserCombinators.Poly.Base</A->, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.NoLeak.Lazy, Text.ParserCombinators.Poly.NoLeak.Plain, Text.ParserCombinators.Poly.NoLeak.State, Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy</TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyLazy.html#v%3AsepBy1"->Text.ParserCombinators.PolyLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->4 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3AsepBy1"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3AsepBy1"->Text.ParserCombinators.PolyStateLazy</A-></TD+>, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy, Text.ParserCombinators.Poly, Text.Parse</TD ></TR ><TR ><TD CLASS="indexentry" COLSPAN="2"@@ -381,51 +281,19 @@ ><TD CLASS="indexannot" >1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-State.html#v%3AstGet"->Text.ParserCombinators.Poly.NoLeak.State</A-></TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-StateLazy.html#v%3AstGet"->Text.ParserCombinators.Poly.NoLeak.StateLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-State.html#v%3AstGet" >Text.ParserCombinators.Poly.State</A ></TD ></TR ><TR ><TD CLASS="indexannot"->4 (Function)</TD+>2 (Function)</TD ><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-StateLazy.html#v%3AstGet" >Text.ParserCombinators.Poly.StateLazy</A ></TD ></TR ><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3AstGet"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->6 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3AstGet"->Text.ParserCombinators.PolyStateLazy</A-></TD-></TR-><TR ><TD CLASS="indexentry" COLSPAN="2" >stQuery</TD ></TR@@ -433,51 +301,19 @@ ><TD CLASS="indexannot" >1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-State.html#v%3AstQuery"->Text.ParserCombinators.Poly.NoLeak.State</A-></TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-StateLazy.html#v%3AstQuery"->Text.ParserCombinators.Poly.NoLeak.StateLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-State.html#v%3AstQuery" >Text.ParserCombinators.Poly.State</A ></TD ></TR ><TR ><TD CLASS="indexannot"->4 (Function)</TD+>2 (Function)</TD ><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-StateLazy.html#v%3AstQuery" >Text.ParserCombinators.Poly.StateLazy</A ></TD ></TR ><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3AstQuery"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->6 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3AstQuery"->Text.ParserCombinators.PolyStateLazy</A-></TD-></TR-><TR ><TD CLASS="indexentry" COLSPAN="2" >stUpdate</TD ></TR@@ -485,48 +321,16 @@ ><TD CLASS="indexannot" >1 (Function)</TD ><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-State.html#v%3AstUpdate"->Text.ParserCombinators.Poly.NoLeak.State</A-></TD-></TR-><TR-><TD CLASS="indexannot"->2 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-Poly-NoLeak-StateLazy.html#v%3AstUpdate"->Text.ParserCombinators.Poly.NoLeak.StateLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->3 (Function)</TD-><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-State.html#v%3AstUpdate" >Text.ParserCombinators.Poly.State</A ></TD ></TR ><TR ><TD CLASS="indexannot"->4 (Function)</TD+>2 (Function)</TD ><TD CLASS="indexlinks" ><A HREF="Text-ParserCombinators-Poly-StateLazy.html#v%3AstUpdate" >Text.ParserCombinators.Poly.StateLazy</A-></TD-></TR-><TR-><TD CLASS="indexannot"->5 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyState.html#v%3AstUpdate"->Text.ParserCombinators.PolyState</A-></TD-></TR-><TR-><TD CLASS="indexannot"->6 (Function)</TD-><TD CLASS="indexlinks"-><A HREF="Text-ParserCombinators-PolyStateLazy.html#v%3AstUpdate"->Text.ParserCombinators.PolyStateLazy</A ></TD ></TR ><TR
docs/haddock/index.html view
@@ -128,61 +128,6 @@ ></TD ></TR ><TR-><TD STYLE="width: 44em"-><IMG SRC="minus.gif" CLASS="coll" ONCLICK="toggle(this,'n:3')" ALT="show/hide"->NoLeak</TD-><TD-></TD-><TD-></TD-></TR-><TR-><TD STYLE="padding: 0; padding-left: 2em" COLSPAN="3"-><TABLE CLASS="vanilla2" CELLSPACING="0" CELLPADDING="0" ID="n:3" STYLE="display:block;"-><TR-><TD STYLE="padding-left: 1.25em;width: 42em"-><A HREF="Text-ParserCombinators-Poly-NoLeak-Lazy.html"->Text.ParserCombinators.Poly.NoLeak.Lazy</A-></TD-><TD-></TD-><TD-></TD-></TR-><TR-><TD STYLE="padding-left: 1.25em;width: 42em"-><A HREF="Text-ParserCombinators-Poly-NoLeak-Plain.html"->Text.ParserCombinators.Poly.NoLeak.Plain</A-></TD-><TD-></TD-><TD-></TD-></TR-><TR-><TD STYLE="padding-left: 1.25em;width: 42em"-><A HREF="Text-ParserCombinators-Poly-NoLeak-State.html"->Text.ParserCombinators.Poly.NoLeak.State</A-></TD-><TD-></TD-><TD-></TD-></TR-><TR-><TD STYLE="padding-left: 1.25em;width: 42em"-><A HREF="Text-ParserCombinators-Poly-NoLeak-StateLazy.html"->Text.ParserCombinators.Poly.NoLeak.StateLazy</A-></TD-><TD-></TD-><TD-></TD-></TR-></TABLE-></TD-></TR-><TR ><TD STYLE="padding-left: 1.25em;width: 44em" ><A HREF="Text-ParserCombinators-Poly-Plain.html" >Text.ParserCombinators.Poly.Plain</A@@ -213,36 +158,6 @@ ></TD ></TR ></TABLE-></TD-></TR-><TR-><TD STYLE="padding-left: 1.25em;width: 46em"-><A HREF="Text-ParserCombinators-PolyLazy.html"->Text.ParserCombinators.PolyLazy</A-></TD-><TD-></TD-><TD-></TD-></TR-><TR-><TD STYLE="padding-left: 1.25em;width: 46em"-><A HREF="Text-ParserCombinators-PolyState.html"->Text.ParserCombinators.PolyState</A-></TD-><TD-></TD-><TD-></TD-></TR-><TR-><TD STYLE="padding-left: 1.25em;width: 46em"-><A HREF="Text-ParserCombinators-PolyStateLazy.html"->Text.ParserCombinators.PolyStateLazy</A-></TD-><TD-></TD-><TD ></TD ></TR ></TABLE
docs/haddock/src/Text/Parse.html view
@@ -1,182 +1,385 @@ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"> <html>-<pre><a name="(line1)"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>Parse-<a name="(line2)"></a> <font color=Cyan>(</font> <font color=Blue>-- * The Parse class is a replacement for the standard Read class. </font>-<a name="(line3)"></a> <font color=Blue>-- $parser</font>-<a name="(line4)"></a> TextParser <font color=Blue>-- synonym for Parser Char, i.e. string input, no state</font>-<a name="(line5)"></a> <font color=Cyan>,</font> Parse<font color=Cyan>(</font><font color=Red>..</font><font color=Cyan>)</font> <font color=Blue>-- instances: (), (a,b), (a,b,c), Maybe a, Either a, [a],</font>-<a name="(line6)"></a> <font color=Blue>-- Int, Integer, Float, Double, Char, Bool</font>-<a name="(line7)"></a> <font color=Cyan>,</font> parseByRead <font color=Blue>-- :: Read a => String -> TextParser a</font>-<a name="(line8)"></a> <font color=Blue>-- ** Combinators specific to string input, lexed haskell-style</font>-<a name="(line9)"></a> <font color=Cyan>,</font> word <font color=Blue>-- :: TextParser String</font>-<a name="(line10)"></a> <font color=Cyan>,</font> isWord <font color=Blue>-- :: String -> TextParser ()</font>-<a name="(line11)"></a> <font color=Cyan>,</font> optionalParens <font color=Blue>-- :: TextParser a -> TextParser a</font>-<a name="(line12)"></a> <font color=Cyan>,</font> field <font color=Blue>-- :: Parse a => String -> TextParser a</font>-<a name="(line13)"></a> <font color=Cyan>,</font> constructors<font color=Blue>-- :: [(String,TextParser a)] -> TextParser a</font>-<a name="(line14)"></a> <font color=Cyan>,</font> enumeration <font color=Blue>-- :: Show a => String -> [a] -> TextParser a</font>-<a name="(line15)"></a> <font color=Blue>-- ** Re-export all the more general combinators from Poly too</font>-<a name="(line16)"></a> <font color=Cyan>,</font> <font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly-<a name="(line17)"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line18)"></a>-<a name="(line19)"></a><font color=Green><u>import</u></font> Char <font color=Cyan>(</font>isSpace<font color=Cyan>)</font>-<a name="(line20)"></a><font color=Green><u>import</u></font> List <font color=Cyan>(</font>intersperse<font color=Cyan>)</font>-<a name="(line21)"></a><font color=Green><u>import</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly-<a name="(line22)"></a>-<a name="(line23)"></a><font color=Blue>------------------------------------------------------------------------</font>-<a name="(line24)"></a><font color=Blue>-- $parser</font>-<a name="(line25)"></a><font color=Blue>-- The Parse class is a replacement for the standard Read class. It is a</font>-<a name="(line26)"></a><font color=Blue>-- specialisation of the (poly) Parser monad for String input.</font>-<a name="(line27)"></a><font color=Blue>-- There are instances defined for all Prelude types.</font>-<a name="(line28)"></a><font color=Blue>-- For user-defined types, you can write your own instance, or use</font>-<a name="(line29)"></a><font color=Blue>-- DrIFT to generate them automatically, e.g. {-! derive : Parse !-}</font>-<a name="(line30)"></a>-<a name="(line31)"></a><a name="TextParser"></a><font color=Blue>-- | A synonym for Parser Char, i.e. string input (no state)</font>-<a name="(line32)"></a><a name="TextParser"></a><font color=Green><u>type</u></font> TextParser a <font color=Red>=</font> Parser Char a-<a name="(line33)"></a>-<a name="(line34)"></a><a name="Parse"></a><font color=Blue>-- | The class @Parse@ is a replacement for @Read@, operating over String input.</font>-<a name="(line35)"></a><a name="Parse"></a><font color=Blue>-- Essentially, it permits better error messages for why something failed to</font>-<a name="(line36)"></a><a name="Parse"></a><font color=Blue>-- parse. It is rather important that @parse@ can read back exactly what</font>-<a name="(line37)"></a><a name="Parse"></a><font color=Blue>-- is generated by the corresponding instance of @show@. To apply a parser</font>-<a name="(line38)"></a><a name="Parse"></a><font color=Blue>-- to some text, use @runParser@.</font>-<a name="(line39)"></a><a name="Parse"></a><font color=Green><u>class</u></font> Parse a <font color=Green><u>where</u></font>-<a name="(line40)"></a> parse <font color=Red>::</font> TextParser a-<a name="(line41)"></a> parseList <font color=Red>::</font> TextParser <font color=Red>[</font>a<font color=Red>]</font> <font color=Blue>-- only to distinguish [] and ""</font>-<a name="(line42)"></a> parseList <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord <font color=Magenta>"[]"</font><font color=Cyan>;</font> return [] <font color=Cyan>}</font>-<a name="(line43)"></a> <font color=Cyan>`onFail`</font>-<a name="(line44)"></a> <font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord <font color=Magenta>"["</font><font color=Cyan>;</font> isWord <font color=Magenta>"]"</font><font color=Cyan>;</font> return [] <font color=Cyan>}</font>-<a name="(line45)"></a> <font color=Cyan>`onFail`</font>-<a name="(line46)"></a> bracketSep <font color=Cyan>(</font>isWord <font color=Magenta>"["</font><font color=Cyan>)</font> <font color=Cyan>(</font>isWord <font color=Magenta>","</font><font color=Cyan>)</font> <font color=Cyan>(</font>isWord <font color=Magenta>"]"</font><font color=Cyan>)</font> parse-<a name="(line47)"></a> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Expected a list, but\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line48)"></a>-<a name="(line49)"></a><a name="parseByRead"></a><font color=Blue>-- | If there already exists a Read instance for a type, then we can make</font>-<a name="(line50)"></a><font color=Blue>-- a Parser for it, but with only poor error-reporting.</font>-<a name="(line51)"></a>parseByRead <font color=Red>::</font> Read a <font color=Red>=></font> String <font color=Red>-></font> TextParser a-<a name="(line52)"></a>parseByRead name <font color=Red>=</font>-<a name="(line53)"></a> P <font color=Cyan>(</font><font color=Red>\</font>s<font color=Red>-></font> <font color=Green><u>case</u></font> reads s <font color=Green><u>of</u></font>-<a name="(line54)"></a> [] <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>False<font color=Cyan>,</font><font color=Magenta>"no parse, expected a "</font><font color=Cyan>++</font>name<font color=Cyan>)</font><font color=Cyan>,</font> s<font color=Cyan>)</font>-<a name="(line55)"></a> <font color=Red>[</font><font color=Cyan>(</font>a<font color=Cyan>,</font>s'<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>Right a<font color=Cyan>,</font> s'<font color=Cyan>)</font>-<a name="(line56)"></a> <font color=Green><u>_</u></font> <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>False<font color=Cyan>,</font><font color=Magenta>"ambiguous parse, expected a "</font><font color=Cyan>++</font>name<font color=Cyan>)</font><font color=Cyan>,</font> s<font color=Cyan>)</font>-<a name="(line57)"></a> <font color=Cyan>)</font>-<a name="(line58)"></a>-<a name="(line59)"></a><a name="word"></a><font color=Blue>-- | One lexical chunk (Haskell-style lexing).</font>-<a name="(line60)"></a>word <font color=Red>::</font> TextParser String-<a name="(line61)"></a>word <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s<font color=Red>-></font> <font color=Green><u>case</u></font> lex s <font color=Green><u>of</u></font>-<a name="(line62)"></a> [] <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>False<font color=Cyan>,</font><font color=Magenta>"no input? (impossible)"</font><font color=Cyan>)</font><font color=Cyan>,</font> s<font color=Cyan>)</font>-<a name="(line63)"></a> <font color=Red>[</font><font color=Cyan>(</font><font color=Magenta>""</font><font color=Cyan>,</font>s'<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>False<font color=Cyan>,</font><font color=Magenta>"no input?"</font><font color=Cyan>)</font><font color=Cyan>,</font> s'<font color=Cyan>)</font>-<a name="(line64)"></a> <font color=Cyan>(</font><font color=Cyan>(</font>x<font color=Cyan>,</font>s'<font color=Cyan>)</font><font color=Red><b>:</b></font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> s'<font color=Cyan>)</font> <font color=Cyan>)</font>-<a name="(line65)"></a>-<a name="(line66)"></a><a name="isWord"></a><font color=Blue>-- | Ensure that the next input word is the given string. (Note the input</font>-<a name="(line67)"></a><font color=Blue>-- is lexed as haskell, so wordbreaks at spaces, symbols, etc.)</font>-<a name="(line68)"></a>isWord <font color=Red>::</font> String <font color=Red>-></font> TextParser String-<a name="(line69)"></a>isWord w <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> w' <font color=Red><-</font> word-<a name="(line70)"></a> <font color=Cyan>;</font> <font color=Green><u>if</u></font> w'<font color=Cyan>==</font>w <font color=Green><u>then</u></font> return w <font color=Green><u>else</u></font> fail <font color=Cyan>(</font><font color=Magenta>"expected "</font><font color=Cyan>++</font>w<font color=Cyan>++</font><font color=Magenta>" got "</font><font color=Cyan>++</font>w'<font color=Cyan>)</font>-<a name="(line71)"></a> <font color=Cyan>}</font>-<a name="(line72)"></a>-<a name="(line73)"></a><a name="optionalParens"></a><font color=Blue>-- | Allow true string parens around an item.</font>-<a name="(line74)"></a>optionalParens <font color=Red>::</font> TextParser a <font color=Red>-></font> TextParser a-<a name="(line75)"></a>optionalParens p <font color=Red>=</font> bracket <font color=Cyan>(</font>isWord <font color=Magenta>"("</font><font color=Cyan>)</font> <font color=Cyan>(</font>isWord <font color=Magenta>")"</font><font color=Cyan>)</font> p <font color=Cyan>`onFail`</font> p-<a name="(line76)"></a>-<a name="(line77)"></a><a name="field"></a><font color=Blue>-- | Deal with named field syntax. The string argument is the field name,</font>-<a name="(line78)"></a><font color=Blue>-- and the parser returns the value of the field.</font>-<a name="(line79)"></a>field <font color=Red>::</font> Parse a <font color=Red>=></font> String <font color=Red>-></font> TextParser a-<a name="(line80)"></a>field name <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord name<font color=Cyan>;</font> commit <font color=Cyan>$</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord <font color=Magenta>"="</font><font color=Cyan>;</font> parse <font color=Cyan>}</font> <font color=Cyan>}</font>-<a name="(line81)"></a>-<a name="(line82)"></a><a name="constructors"></a><font color=Blue>-- | Parse one of a bunch of alternative constructors. In the list argument,</font>-<a name="(line83)"></a><font color=Blue>-- the first element of the pair is the constructor name, and</font>-<a name="(line84)"></a><font color=Blue>-- the second is the parser for the rest of the value. The first matching</font>-<a name="(line85)"></a><font color=Blue>-- parse is returned.</font>-<a name="(line86)"></a>constructors <font color=Red>::</font> <font color=Red>[</font><font color=Cyan>(</font>String<font color=Cyan>,</font>TextParser a<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> TextParser a-<a name="(line87)"></a>constructors cs <font color=Red>=</font> oneOf' <font color=Cyan>(</font>map cons cs<font color=Cyan>)</font>-<a name="(line88)"></a> <font color=Green><u>where</u></font> cons <font color=Cyan>(</font>name<font color=Cyan>,</font>p<font color=Cyan>)</font> <font color=Red>=</font>-<a name="(line89)"></a> <font color=Cyan>(</font> name-<a name="(line90)"></a> <font color=Cyan>,</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord name-<a name="(line91)"></a> <font color=Cyan>;</font> p <font color=Cyan>`adjustErrBad`</font> <font color=Cyan>(</font><font color=Cyan>(</font><font color=Magenta>"got constructor, but within "</font>-<a name="(line92)"></a> <font color=Cyan>++</font>name<font color=Cyan>++</font><font color=Magenta>",\n"</font><font color=Cyan>)</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line93)"></a> <font color=Cyan>}</font>-<a name="(line94)"></a> <font color=Cyan>)</font>-<a name="(line95)"></a>-<a name="(line96)"></a><a name="enumeration"></a><font color=Blue>-- | Parse one of the given nullary constructors (an enumeration).</font>-<a name="(line97)"></a><font color=Blue>-- The string argument is the name of the type, and the list argument</font>-<a name="(line98)"></a><font color=Blue>-- should contain all of the possible enumeration values.</font>-<a name="(line99)"></a>enumeration <font color=Red>::</font> <font color=Cyan>(</font>Show a<font color=Cyan>)</font> <font color=Red>=></font> String <font color=Red>-></font> <font color=Red>[</font>a<font color=Red>]</font> <font color=Red>-></font> TextParser a-<a name="(line100)"></a>enumeration typ cs <font color=Red>=</font> oneOf <font color=Cyan>(</font>map <font color=Cyan>(</font><font color=Red>\</font>c<font color=Red>-></font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord <font color=Cyan>(</font>show c<font color=Cyan>)</font><font color=Cyan>;</font> return c <font color=Cyan>}</font><font color=Cyan>)</font> cs<font color=Cyan>)</font>-<a name="(line101)"></a> <font color=Cyan>`adjustErr`</font>-<a name="(line102)"></a> <font color=Cyan>(</font><font color=Cyan>++</font><font color=Cyan>(</font><font color=Magenta>"\n expected "</font><font color=Cyan>++</font>typ<font color=Cyan>++</font><font color=Magenta>" value ("</font><font color=Cyan>++</font>e<font color=Cyan>++</font><font color=Magenta>")"</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line103)"></a> <font color=Green><u>where</u></font> e <font color=Red>=</font> concat <font color=Cyan>(</font>intersperse <font color=Magenta>", "</font> <font color=Cyan>(</font>map show <font color=Cyan>(</font>init cs<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line104)"></a> <font color=Cyan>++</font> <font color=Magenta>", or "</font> <font color=Cyan>++</font> show <font color=Cyan>(</font>last cs<font color=Cyan>)</font>-<a name="(line105)"></a>-<a name="(line106)"></a><font color=Blue>------------------------------------------------------------------------</font>-<a name="(line107)"></a><font color=Blue>-- Instances for all the Standard Prelude types.</font>-<a name="(line108)"></a>-<a name="(line109)"></a><font color=Blue>-- Basic types</font>-<a name="(line110)"></a><font color=Green><u>instance</u></font> Parse Int <font color=Green><u>where</u></font>-<a name="(line111)"></a> parse <font color=Red>=</font> parseByRead <font color=Magenta>"Int"</font>-<a name="(line112)"></a><font color=Green><u>instance</u></font> Parse Integer <font color=Green><u>where</u></font>-<a name="(line113)"></a> parse <font color=Red>=</font> parseByRead <font color=Magenta>"Integer"</font>-<a name="(line114)"></a><font color=Green><u>instance</u></font> Parse Float <font color=Green><u>where</u></font>-<a name="(line115)"></a> parse <font color=Red>=</font> parseByRead <font color=Magenta>"Float"</font>-<a name="(line116)"></a><font color=Green><u>instance</u></font> Parse Double <font color=Green><u>where</u></font>-<a name="(line117)"></a> parse <font color=Red>=</font> parseByRead <font color=Magenta>"Double"</font>-<a name="(line118)"></a><font color=Green><u>instance</u></font> Parse Char <font color=Green><u>where</u></font>-<a name="(line119)"></a> parse <font color=Red>=</font> parseByRead <font color=Magenta>"Char"</font>-<a name="(line120)"></a> <font color=Blue>-- parseList = bracket (isWord "\"") (satisfy (=='"'))</font>-<a name="(line121)"></a> <font color=Blue>-- (many (satisfy (/='"')))</font>-<a name="(line122)"></a> <font color=Blue>-- not totally correct for strings...</font>-<a name="(line123)"></a> parseList <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> w <font color=Red><-</font> word<font color=Cyan>;</font> <font color=Green><u>if</u></font> head w <font color=Cyan>==</font> <font color=Magenta>'"'</font> <font color=Green><u>then</u></font> return <font color=Cyan>(</font>init <font color=Cyan>(</font>tail w<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line124)"></a> <font color=Green><u>else</u></font> fail <font color=Magenta>"not a string"</font> <font color=Cyan>}</font>-<a name="(line125)"></a>-<a name="(line126)"></a><font color=Green><u>instance</u></font> Parse Bool <font color=Green><u>where</u></font>-<a name="(line127)"></a> parse <font color=Red>=</font> enumeration <font color=Magenta>"Bool"</font> <font color=Red>[</font>False<font color=Cyan>,</font>True<font color=Red>]</font>-<a name="(line128)"></a>-<a name="(line129)"></a><font color=Green><u>instance</u></font> Parse Ordering <font color=Green><u>where</u></font>-<a name="(line130)"></a> parse <font color=Red>=</font> enumeration <font color=Magenta>"Ordering"</font> <font color=Red>[</font>LT<font color=Cyan>,</font>EQ<font color=Cyan>,</font>GT<font color=Red>]</font>-<a name="(line131)"></a>-<a name="(line132)"></a><font color=Blue>-- Structural types</font>-<a name="(line133)"></a><font color=Green><u>instance</u></font> Parse () <font color=Green><u>where</u></font>-<a name="(line134)"></a> parse <font color=Red>=</font> P p-<a name="(line135)"></a> <font color=Green><u>where</u></font> p [] <font color=Red>=</font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>False<font color=Cyan>,</font><font color=Magenta>"no input: expected a ()"</font><font color=Cyan>)</font><font color=Cyan>,</font> []<font color=Cyan>)</font>-<a name="(line136)"></a> p <font color=Cyan>(</font><font color=Magenta>'('</font><font color=Red><b>:</b></font>cs<font color=Cyan>)</font> <font color=Red>=</font> <font color=Green><u>case</u></font> dropWhile isSpace cs <font color=Green><u>of</u></font>-<a name="(line137)"></a> <font color=Cyan>(</font><font color=Magenta>')'</font><font color=Red><b>:</b></font>s<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Right ()<font color=Cyan>,</font> s<font color=Cyan>)</font>-<a name="(line138)"></a> <font color=Green><u>_</u></font> <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>False<font color=Cyan>,</font><font color=Magenta>"Expected ) after ("</font><font color=Cyan>)</font><font color=Cyan>,</font> cs<font color=Cyan>)</font>-<a name="(line139)"></a> p <font color=Cyan>(</font>c<font color=Red><b>:</b></font>cs<font color=Cyan>)</font> <font color=Red>|</font> isSpace c <font color=Red>=</font> p cs-<a name="(line140)"></a> <font color=Red>|</font> otherwise <font color=Red>=</font> <font color=Cyan>(</font> Left <font color=Cyan>(</font>False<font color=Cyan>,</font><font color=Magenta>"Expected a (), got "</font><font color=Cyan>++</font>show c<font color=Cyan>)</font>-<a name="(line141)"></a> <font color=Cyan>,</font> <font color=Cyan>(</font>c<font color=Red><b>:</b></font>cs<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line142)"></a>-<a name="(line143)"></a><font color=Green><u>instance</u></font> <font color=Cyan>(</font>Parse a<font color=Cyan>,</font> Parse b<font color=Cyan>)</font> <font color=Red>=></font> Parse <font color=Cyan>(</font>a<font color=Cyan>,</font>b<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line144)"></a> parse <font color=Red>=</font> <font color=Green><u>do</u></font><font color=Cyan>{</font> isWord <font color=Magenta>"("</font> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Opening a 2-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line145)"></a> <font color=Cyan>;</font> x <font color=Red><-</font> parse <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"In 1st item of a 2-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line146)"></a> <font color=Cyan>;</font> isWord <font color=Magenta>","</font> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Separating a 2-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line147)"></a> <font color=Cyan>;</font> y <font color=Red><-</font> parse <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"In 2nd item of a 2-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line148)"></a> <font color=Cyan>;</font> isWord <font color=Magenta>")"</font> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Closing a 2-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line149)"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Cyan>,</font>y<font color=Cyan>)</font> <font color=Cyan>}</font>-<a name="(line150)"></a>-<a name="(line151)"></a><font color=Green><u>instance</u></font> <font color=Cyan>(</font>Parse a<font color=Cyan>,</font> Parse b<font color=Cyan>,</font> Parse c<font color=Cyan>)</font> <font color=Red>=></font> Parse <font color=Cyan>(</font>a<font color=Cyan>,</font>b<font color=Cyan>,</font>c<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line152)"></a> parse <font color=Red>=</font> <font color=Green><u>do</u></font><font color=Cyan>{</font> isWord <font color=Magenta>"("</font> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Opening a 3-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line153)"></a> <font color=Cyan>;</font> x <font color=Red><-</font> parse <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"In 1st item of a 3-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line154)"></a> <font color=Cyan>;</font> isWord <font color=Magenta>","</font> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Separating(1) a 3-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line155)"></a> <font color=Cyan>;</font> y <font color=Red><-</font> parse <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"In 2nd item of a 3-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line156)"></a> <font color=Cyan>;</font> isWord <font color=Magenta>","</font> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Separating(2) a 3-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line157)"></a> <font color=Cyan>;</font> z <font color=Red><-</font> parse <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"In 3rd item of a 3-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line158)"></a> <font color=Cyan>;</font> isWord <font color=Magenta>")"</font> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Closing a 3-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line159)"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Cyan>,</font>y<font color=Cyan>,</font>z<font color=Cyan>)</font> <font color=Cyan>}</font>-<a name="(line160)"></a>-<a name="(line161)"></a><font color=Green><u>instance</u></font> Parse a <font color=Red>=></font> Parse <font color=Cyan>(</font>Maybe a<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line162)"></a> parse <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord <font color=Magenta>"Nothing"</font><font color=Cyan>;</font> return Nothing <font color=Cyan>}</font>-<a name="(line163)"></a> <font color=Cyan>`onFail`</font>-<a name="(line164)"></a> <font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord <font color=Magenta>"Just"</font>-<a name="(line165)"></a> <font color=Cyan>;</font> fmap Just <font color=Cyan>$</font> optionalParens parse-<a name="(line166)"></a> <font color=Cyan>`adjustErrBad`</font> <font color=Cyan>(</font><font color=Magenta>"but within Just, "</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line167)"></a> <font color=Cyan>}</font>-<a name="(line168)"></a> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Cyan>(</font><font color=Magenta>"expected a Maybe (Just or Nothing)\n"</font><font color=Cyan>++</font><font color=Cyan>)</font><font color=Cyan>.</font>indent <font color=Magenta>2</font><font color=Cyan>)</font>-<a name="(line169)"></a>-<a name="(line170)"></a><font color=Green><u>instance</u></font> <font color=Cyan>(</font>Parse a<font color=Cyan>,</font> Parse b<font color=Cyan>)</font> <font color=Red>=></font> Parse <font color=Cyan>(</font>Either a b<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line171)"></a> parse <font color=Red>=</font> constructors <font color=Red>[</font> <font color=Cyan>(</font><font color=Magenta>"Left"</font><font color=Cyan>,</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> fmap Left <font color=Cyan>$</font> optionalParens parse <font color=Cyan>}</font> <font color=Cyan>)</font>-<a name="(line172)"></a> <font color=Cyan>,</font> <font color=Cyan>(</font><font color=Magenta>"Right"</font><font color=Cyan>,</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> fmap Right <font color=Cyan>$</font> optionalParens parse <font color=Cyan>}</font> <font color=Cyan>)</font>-<a name="(line173)"></a> <font color=Red>]</font>-<a name="(line174)"></a>-<a name="(line175)"></a><font color=Green><u>instance</u></font> Parse a <font color=Red>=></font> Parse <font color=Red>[</font>a<font color=Red>]</font> <font color=Green><u>where</u></font>-<a name="(line176)"></a> parse <font color=Red>=</font> parseList-<a name="(line177)"></a>-<a name="(line178)"></a><font color=Blue>------------------------------------------------------------------------</font>+<head>+<!-- Generated by HsColour, http://www.cs.york.ac.uk/fp/darcs/hscolour/ -->+<title>src/Text/Parse.hs</title>+</head>+<body>+<pre><a name="line-1"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>Parse+<a name="line-2"></a> <font color=Cyan>(</font> <font color=Blue>-- * The Parse class is a replacement for the standard Read class. </font>+<a name="line-3"></a> <font color=Blue>-- $parser</font>+<a name="line-4"></a> TextParser <font color=Blue>-- synonym for Parser Char, i.e. string input, no state</font>+<a name="line-5"></a> <font color=Cyan>,</font> Parse<font color=Cyan>(</font><font color=Red>..</font><font color=Cyan>)</font> <font color=Blue>-- instances: (), (a,b), (a,b,c), Maybe a, Either a, [a],</font>+<a name="line-6"></a> <font color=Blue>-- Int, Integer, Float, Double, Char, Bool</font>+<a name="line-7"></a> <font color=Cyan>,</font> parseByRead <font color=Blue>-- :: Read a => String -> TextParser a</font>+<a name="line-8"></a> <font color=Blue>-- ** Combinators specific to string input, lexed haskell-style</font>+<a name="line-9"></a> <font color=Cyan>,</font> word <font color=Blue>-- :: TextParser String</font>+<a name="line-10"></a> <font color=Cyan>,</font> isWord <font color=Blue>-- :: String -> TextParser ()</font>+<a name="line-11"></a> <font color=Cyan>,</font> optionalParens <font color=Blue>-- :: TextParser a -> TextParser a</font>+<a name="line-12"></a> <font color=Cyan>,</font> parens <font color=Blue>-- :: Bool -> TextParser a -> TextParser a</font>+<a name="line-13"></a> <font color=Cyan>,</font> field <font color=Blue>-- :: Parse a => String -> TextParser a</font>+<a name="line-14"></a> <font color=Cyan>,</font> constructors<font color=Blue>-- :: [(String,TextParser a)] -> TextParser a</font>+<a name="line-15"></a> <font color=Cyan>,</font> enumeration <font color=Blue>-- :: Show a => String -> [a] -> TextParser a</font>+<a name="line-16"></a> <font color=Blue>-- ** Parsers for literal numerics and characters</font>+<a name="line-17"></a> <font color=Cyan>,</font> parseSigned+<a name="line-18"></a> <font color=Cyan>,</font> parseInt+<a name="line-19"></a> <font color=Cyan>,</font> parseDec+<a name="line-20"></a> <font color=Cyan>,</font> parseOct+<a name="line-21"></a> <font color=Cyan>,</font> parseHex+<a name="line-22"></a> <font color=Cyan>,</font> parseFloat+<a name="line-23"></a> <font color=Cyan>,</font> parseLitChar+<a name="line-24"></a> <font color=Blue>-- ** Re-export all the more general combinators from Poly too</font>+<a name="line-25"></a> <font color=Cyan>,</font> <font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly+<a name="line-26"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-27"></a>+<a name="line-28"></a><font color=Green><u>import</u></font> Char <font color=Cyan>(</font>isSpace<font color=Cyan>,</font>toLower<font color=Cyan>,</font>isUpper<font color=Cyan>,</font>isDigit<font color=Cyan>,</font>isOctDigit<font color=Cyan>,</font>isHexDigit<font color=Cyan>,</font>digitToInt+<a name="line-29"></a> <font color=Cyan>,</font>ord<font color=Cyan>,</font>chr<font color=Cyan>)</font>+<a name="line-30"></a><font color=Green><u>import</u></font> List <font color=Cyan>(</font>intersperse<font color=Cyan>)</font>+<a name="line-31"></a><font color=Green><u>import</u></font> Ratio+<a name="line-32"></a><font color=Green><u>import</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly+<a name="line-33"></a>+<a name="line-34"></a><font color=Blue>------------------------------------------------------------------------</font>+<a name="line-35"></a><font color=Blue>-- $parser</font>+<a name="line-36"></a><font color=Blue>-- The Parse class is a replacement for the standard Read class. It is a</font>+<a name="line-37"></a><font color=Blue>-- specialisation of the (poly) Parser monad for String input.</font>+<a name="line-38"></a><font color=Blue>-- There are instances defined for all Prelude types.</font>+<a name="line-39"></a><font color=Blue>-- For user-defined types, you can write your own instance, or use</font>+<a name="line-40"></a><font color=Blue>-- DrIFT to generate them automatically, e.g. {-! derive : Parse !-}</font>+<a name="line-41"></a>+<a name="line-42"></a><a name="TextParser"></a><font color=Blue>-- | A synonym for Parser Char, i.e. string input (no state)</font>+<a name="line-43"></a><a name="TextParser"></a><font color=Green><u>type</u></font> TextParser a <font color=Red>=</font> Parser Char a+<a name="line-44"></a>+<a name="line-45"></a><a name="Parse"></a><font color=Blue>-- | The class @Parse@ is a replacement for @Read@, operating over String input.</font>+<a name="line-46"></a><a name="Parse"></a><font color=Blue>-- Essentially, it permits better error messages for why something failed to</font>+<a name="line-47"></a><a name="Parse"></a><font color=Blue>-- parse. It is rather important that @parse@ can read back exactly what</font>+<a name="line-48"></a><a name="Parse"></a><font color=Blue>-- is generated by the corresponding instance of @show@. To apply a parser</font>+<a name="line-49"></a><a name="Parse"></a><font color=Blue>-- to some text, use @runParser@.</font>+<a name="line-50"></a><a name="Parse"></a><font color=Green><u>class</u></font> Parse a <font color=Green><u>where</u></font>+<a name="line-51"></a> <font color=Blue>-- | A straightforward parser for an item. (A minimal definition of</font>+<a name="line-52"></a> <font color=Blue>-- a class instance requires either |parse| or |parsePrec|.)</font>+<a name="line-53"></a> parse <font color=Red>::</font> TextParser a+<a name="line-54"></a> parse <font color=Red>=</font> parsePrec <font color=Magenta>0</font>+<a name="line-55"></a> <font color=Blue>-- | A straightforward parser for an item, given the precedence of</font>+<a name="line-56"></a> <font color=Blue>-- any surrounding expression. (Precedence determines whether</font>+<a name="line-57"></a> <font color=Blue>-- parentheses are mandatory or optional.)</font>+<a name="line-58"></a> parsePrec <font color=Red>::</font> Int <font color=Red>-></font> TextParser a+<a name="line-59"></a> parsePrec <font color=Green><u>_</u></font> <font color=Red>=</font> parens False parse+<a name="line-60"></a> <font color=Blue>-- | Parsing a list of items by default accepts the [] and comma syntax,</font>+<a name="line-61"></a> <font color=Blue>-- except when the list is really a character string using \"\".</font>+<a name="line-62"></a> parseList <font color=Red>::</font> TextParser <font color=Red>[</font>a<font color=Red>]</font> <font color=Blue>-- only to distinguish [] and ""</font>+<a name="line-63"></a> parseList <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord <font color=Magenta>"[]"</font><font color=Cyan>;</font> return [] <font color=Cyan>}</font>+<a name="line-64"></a> <font color=Cyan>`onFail`</font>+<a name="line-65"></a> <font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord <font color=Magenta>"["</font><font color=Cyan>;</font> isWord <font color=Magenta>"]"</font><font color=Cyan>;</font> return [] <font color=Cyan>}</font>+<a name="line-66"></a> <font color=Cyan>`onFail`</font>+<a name="line-67"></a> bracketSep <font color=Cyan>(</font>isWord <font color=Magenta>"["</font><font color=Cyan>)</font> <font color=Cyan>(</font>isWord <font color=Magenta>","</font><font color=Cyan>)</font> <font color=Cyan>(</font>isWord <font color=Magenta>"]"</font><font color=Cyan>)</font> parse+<a name="line-68"></a> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Expected a list, but\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-69"></a>+<a name="line-70"></a><a name="parseByRead"></a><font color=Blue>-- | If there already exists a Read instance for a type, then we can make</font>+<a name="line-71"></a><font color=Blue>-- a Parser for it, but with only poor error-reporting. The string argument</font>+<a name="line-72"></a><font color=Blue>-- is the expected type or value (for error-reporting only).</font>+<a name="line-73"></a><font color=Blue>parseByRead</font> <font color=Red>::</font> Read a <font color=Red>=></font> String <font color=Red>-></font> TextParser a+<a name="line-74"></a><font color=Blue>parseByRead</font> name <font color=Red>=</font>+<a name="line-75"></a> P <font color=Cyan>(</font><font color=Red>\</font>s<font color=Red>-></font> <font color=Green><u>case</u></font> reads s <font color=Green><u>of</u></font>+<a name="line-76"></a> [] <font color=Red>-></font> Failure s <font color=Cyan>(</font><font color=Magenta>"no parse, expected a "</font><font color=Cyan>++</font>name<font color=Cyan>)</font>+<a name="line-77"></a> <font color=Red>[</font><font color=Cyan>(</font>a<font color=Cyan>,</font>s'<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> Success s' a+<a name="line-78"></a> <font color=Green><u>_</u></font> <font color=Red>-></font> Failure s <font color=Cyan>(</font><font color=Magenta>"ambiguous parse, expected a "</font><font color=Cyan>++</font>name<font color=Cyan>)</font>+<a name="line-79"></a> <font color=Cyan>)</font>+<a name="line-80"></a>+<a name="line-81"></a><a name="word"></a><font color=Blue>-- | One lexical chunk (Haskell-style lexing).</font>+<a name="line-82"></a><font color=Blue>word</font> <font color=Red>::</font> TextParser String+<a name="line-83"></a><font color=Blue>word</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s<font color=Red>-></font> <font color=Green><u>case</u></font> lex s <font color=Green><u>of</u></font>+<a name="line-84"></a> [] <font color=Red>-></font> Failure s <font color=Cyan>(</font><font color=Magenta>"no input? (impossible)"</font><font color=Cyan>)</font>+<a name="line-85"></a> <font color=Red>[</font><font color=Cyan>(</font><font color=Magenta>""</font><font color=Cyan>,</font><font color=Magenta>""</font><font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> Failure <font color=Magenta>""</font> <font color=Cyan>(</font><font color=Magenta>"no input?"</font><font color=Cyan>)</font>+<a name="line-86"></a> <font color=Red>[</font><font color=Cyan>(</font><font color=Magenta>""</font><font color=Cyan>,</font>s'<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> Failure s <font color=Cyan>(</font><font color=Magenta>"lexing failed?"</font><font color=Cyan>)</font>+<a name="line-87"></a> <font color=Cyan>(</font><font color=Cyan>(</font>x<font color=Cyan>,</font>s'<font color=Cyan>)</font><font color=Red><b>:</b></font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> Success s' x+<a name="line-88"></a> <font color=Cyan>)</font>+<a name="line-89"></a>+<a name="line-90"></a><a name="isWord"></a><font color=Blue>-- | Ensure that the next input word is the given string. (Note the input</font>+<a name="line-91"></a><font color=Blue>-- is lexed as haskell, so wordbreaks at spaces, symbols, etc.)</font>+<a name="line-92"></a><font color=Blue>isWord</font> <font color=Red>::</font> String <font color=Red>-></font> TextParser String+<a name="line-93"></a><font color=Blue>isWord</font> w <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> w' <font color=Red><-</font> word+<a name="line-94"></a> <font color=Cyan>;</font> <font color=Green><u>if</u></font> w'<font color=Cyan>==</font>w <font color=Green><u>then</u></font> return w <font color=Green><u>else</u></font> fail <font color=Cyan>(</font><font color=Magenta>"expected "</font><font color=Cyan>++</font>w<font color=Cyan>++</font><font color=Magenta>" got "</font><font color=Cyan>++</font>w'<font color=Cyan>)</font>+<a name="line-95"></a> <font color=Cyan>}</font>+<a name="line-96"></a>+<a name="line-97"></a><a name="optionalParens"></a><font color=Blue>-- | Allow true string parens around an item.</font>+<a name="line-98"></a><font color=Blue>optionalParens</font> <font color=Red>::</font> TextParser a <font color=Red>-></font> TextParser a+<a name="line-99"></a><font color=Blue>optionalParens</font> p <font color=Red>=</font> bracket <font color=Cyan>(</font>isWord <font color=Magenta>"("</font><font color=Cyan>)</font> <font color=Cyan>(</font>isWord <font color=Magenta>")"</font><font color=Cyan>)</font> p <font color=Cyan>`onFail`</font> p+<a name="line-100"></a>+<a name="line-101"></a><a name="parens"></a><font color=Blue>-- | Allow nested parens around an item (one set required when Bool is True).</font>+<a name="line-102"></a><font color=Blue>parens</font> <font color=Red>::</font> Bool <font color=Red>-></font> TextParser a <font color=Red>-></font> TextParser a+<a name="line-103"></a><font color=Blue>parens</font> True p <font color=Red>=</font> bracket <font color=Cyan>(</font>isWord <font color=Magenta>"("</font><font color=Cyan>)</font> <font color=Cyan>(</font>isWord <font color=Magenta>")"</font><font color=Cyan>)</font> <font color=Cyan>(</font>parens False p<font color=Cyan>)</font>+<a name="line-104"></a><font color=Blue>parens</font> False p <font color=Red>=</font> parens True p <font color=Cyan>`onFail`</font> p+<a name="line-105"></a>+<a name="line-106"></a><a name="field"></a><font color=Blue>-- | Deal with named field syntax. The string argument is the field name,</font>+<a name="line-107"></a><font color=Blue>-- and the parser returns the value of the field.</font>+<a name="line-108"></a><font color=Blue>field</font> <font color=Red>::</font> Parse a <font color=Red>=></font> String <font color=Red>-></font> TextParser a+<a name="line-109"></a><font color=Blue>field</font> name <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord name<font color=Cyan>;</font> commit <font color=Cyan>$</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord <font color=Magenta>"="</font><font color=Cyan>;</font> parse <font color=Cyan>}</font> <font color=Cyan>}</font>+<a name="line-110"></a>+<a name="line-111"></a><a name="constructors"></a><font color=Blue>-- | Parse one of a bunch of alternative constructors. In the list argument,</font>+<a name="line-112"></a><font color=Blue>-- the first element of the pair is the constructor name, and</font>+<a name="line-113"></a><font color=Blue>-- the second is the parser for the rest of the value. The first matching</font>+<a name="line-114"></a><font color=Blue>-- parse is returned.</font>+<a name="line-115"></a><font color=Blue>constructors</font> <font color=Red>::</font> <font color=Red>[</font><font color=Cyan>(</font>String<font color=Cyan>,</font>TextParser a<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> TextParser a+<a name="line-116"></a><font color=Blue>constructors</font> cs <font color=Red>=</font> oneOf' <font color=Cyan>(</font>map cons cs<font color=Cyan>)</font>+<a name="line-117"></a> <font color=Green><u>where</u></font> cons <font color=Cyan>(</font>name<font color=Cyan>,</font>p<font color=Cyan>)</font> <font color=Red>=</font>+<a name="line-118"></a> <font color=Cyan>(</font> name+<a name="line-119"></a> <font color=Cyan>,</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord name+<a name="line-120"></a> <font color=Cyan>;</font> p <font color=Cyan>`adjustErrBad`</font> <font color=Cyan>(</font><font color=Cyan>(</font><font color=Magenta>"got constructor, but within "</font>+<a name="line-121"></a> <font color=Cyan>++</font>name<font color=Cyan>++</font><font color=Magenta>",\n"</font><font color=Cyan>)</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-122"></a> <font color=Cyan>}</font>+<a name="line-123"></a> <font color=Cyan>)</font>+<a name="line-124"></a>+<a name="line-125"></a><font color=Blue>{-+<a name="line-126"></a>-- | Parse an infix constructor.+<a name="line-127"></a>infixConstructor :: (Parse a, Parse b) =>+<a name="line-128"></a> String -> Int -> (a->b->c) -> Int -> TextParser c+<a name="line-129"></a>infixConstructor name prec cons = \d->+<a name="line-130"></a> parens (prec<d) (do a <- parsePrec (prec+1)+<a name="line-131"></a> isWord name `adjustErr`+<a name="line-132"></a> (++("expected infix constructor "++name))+<a name="line-133"></a> b <- parsePrec (prec+1)+<a name="line-134"></a> return (cons a b) )+<a name="line-135"></a>+<a name="line-136"></a>--infixLeftAssoc :: (Parse a, Parse b) =>+<a name="line-137"></a>-- String -> Int -> (a->b->a) -> Int -> TextParser a+<a name="line-138"></a>--infixLeftAssoc name prec cons = \d->+<a name="line-139"></a>-- parens (prec<d) (do a <- +<a name="line-140"></a>-}</font>+<a name="line-141"></a>+<a name="line-142"></a><a name="enumeration"></a><font color=Blue>-- | Parse one of the given nullary constructors (an enumeration).</font>+<a name="line-143"></a><font color=Blue>-- The string argument is the name of the type, and the list argument</font>+<a name="line-144"></a><font color=Blue>-- should contain all of the possible enumeration values.</font>+<a name="line-145"></a><font color=Blue>enumeration</font> <font color=Red>::</font> <font color=Cyan>(</font>Show a<font color=Cyan>)</font> <font color=Red>=></font> String <font color=Red>-></font> <font color=Red>[</font>a<font color=Red>]</font> <font color=Red>-></font> TextParser a+<a name="line-146"></a><font color=Blue>enumeration</font> typ cs <font color=Red>=</font> oneOf <font color=Cyan>(</font>map <font color=Cyan>(</font><font color=Red>\</font>c<font color=Red>-></font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord <font color=Cyan>(</font>show c<font color=Cyan>)</font><font color=Cyan>;</font> return c <font color=Cyan>}</font><font color=Cyan>)</font> cs<font color=Cyan>)</font>+<a name="line-147"></a> <font color=Cyan>`adjustErr`</font>+<a name="line-148"></a> <font color=Cyan>(</font><font color=Cyan>++</font><font color=Cyan>(</font><font color=Magenta>"\n expected "</font><font color=Cyan>++</font>typ<font color=Cyan>++</font><font color=Magenta>" value ("</font><font color=Cyan>++</font>e<font color=Cyan>++</font><font color=Magenta>")"</font><font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-149"></a> <font color=Green><u>where</u></font> e <font color=Red>=</font> concat <font color=Cyan>(</font>intersperse <font color=Magenta>", "</font> <font color=Cyan>(</font>map show <font color=Cyan>(</font>init cs<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-150"></a> <font color=Cyan>++</font> <font color=Magenta>", or "</font> <font color=Cyan>++</font> show <font color=Cyan>(</font>last cs<font color=Cyan>)</font>+<a name="line-151"></a>+<a name="line-152"></a><font color=Blue>------------------------------------------------------------------------</font>+<a name="line-153"></a><font color=Blue>-- Instances for all the Standard Prelude types.</font>+<a name="line-154"></a>+<a name="line-155"></a><a name="parseSigned"></a><font color=Blue>-- Numeric types</font>+<a name="line-156"></a><font color=Blue>parseSigned</font> <font color=Red>::</font> Real a <font color=Red>=></font> TextParser a <font color=Red>-></font> TextParser a+<a name="line-157"></a><font color=Blue>parseSigned</font> p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'-'</font> <font color=Red><-</font> next<font color=Cyan>;</font> commit <font color=Cyan>(</font>fmap negate p<font color=Cyan>)</font>+<a name="line-158"></a> <font color=Cyan>`onFail`</font>+<a name="line-159"></a> <font color=Green><u>do</u></font> p+<a name="line-160"></a>+<a name="line-161"></a><a name="parseInt"></a><font color=Blue>parseInt</font> <font color=Red>::</font> <font color=Cyan>(</font>Integral a<font color=Cyan>)</font> <font color=Red>=></font> String <font color=Red>-></font>+<a name="line-162"></a> a <font color=Red>-></font> <font color=Cyan>(</font>Char <font color=Red>-></font> Bool<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Char <font color=Red>-></font> Int<font color=Cyan>)</font> <font color=Red>-></font>+<a name="line-163"></a> a <font color=Red>-></font> TextParser a+<a name="line-164"></a><font color=Blue>parseInt</font> base radix isDigit digitToInt n <font color=Red>=</font> go n+<a name="line-165"></a> <font color=Green><u>where</u></font> go acc <font color=Red>=</font> <font color=Green><u>do</u></font> cs <font color=Red><-</font> many1 <font color=Cyan>(</font>satisfy isDigit<font color=Cyan>)</font>+<a name="line-166"></a> return <font color=Cyan>(</font>foldl1 <font color=Cyan>(</font><font color=Red>\</font>n d<font color=Red>-></font> n<font color=Cyan>*</font>radix<font color=Cyan>+</font>d<font color=Cyan>)</font>+<a name="line-167"></a> <font color=Cyan>(</font>map <font color=Cyan>(</font>fromIntegral<font color=Cyan>.</font>digitToInt<font color=Cyan>)</font> cs<font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-168"></a> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Cyan>++</font><font color=Cyan>(</font><font color=Magenta>"\nexpected one or more "</font><font color=Cyan>++</font>base<font color=Cyan>++</font><font color=Magenta>" digits"</font><font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-169"></a><a name="parseDec"></a><font color=Blue>parseDec</font><font color=Cyan>,</font> parseOct<font color=Cyan>,</font> parseHex <font color=Red>::</font> <font color=Cyan>(</font>Integral a<font color=Cyan>)</font> <font color=Red>=></font> a <font color=Red>-></font> TextParser a+<a name="line-170"></a><font color=Blue>parseDec</font> <font color=Red>=</font> parseInt <font color=Magenta>"decimal"</font> <font color=Magenta>10</font> Char<font color=Cyan>.</font>isDigit Char<font color=Cyan>.</font>digitToInt+<a name="line-171"></a><a name="parseOct"></a><font color=Blue>parseOct</font> <font color=Red>=</font> parseInt <font color=Magenta>"octal"</font> <font color=Magenta>8</font> Char<font color=Cyan>.</font>isOctDigit Char<font color=Cyan>.</font>digitToInt+<a name="line-172"></a><a name="parseHex"></a><font color=Blue>parseHex</font> <font color=Red>=</font> parseInt <font color=Magenta>"hex"</font> <font color=Magenta>16</font> Char<font color=Cyan>.</font>isHexDigit Char<font color=Cyan>.</font>digitToInt+<a name="line-173"></a>+<a name="line-174"></a><a name="parseFloat"></a><font color=Blue>parseFloat</font> <font color=Red>::</font> <font color=Cyan>(</font>RealFrac a<font color=Cyan>)</font> <font color=Red>=></font> TextParser a+<a name="line-175"></a><font color=Blue>parseFloat</font> <font color=Red>=</font> <font color=Green><u>do</u></font> ds <font color=Red><-</font> many1 <font color=Cyan>(</font>satisfy isDigit<font color=Cyan>)</font>+<a name="line-176"></a> frac <font color=Red><-</font> <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Magenta>'.'</font> <font color=Red><-</font> next+<a name="line-177"></a> many <font color=Cyan>(</font>satisfy isDigit<font color=Cyan>)</font>+<a name="line-178"></a> <font color=Cyan>`adjustErrBad`</font> <font color=Cyan>(</font><font color=Cyan>++</font><font color=Magenta>"expected digit after ."</font><font color=Cyan>)</font>+<a name="line-179"></a> <font color=Cyan>`onFail`</font> return [] <font color=Cyan>)</font>+<a name="line-180"></a> exp <font color=Red><-</font> <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Magenta>'e'</font> <font color=Red><-</font> fmap toLower next+<a name="line-181"></a> commit <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Magenta>'+'</font> <font color=Red><-</font> next<font color=Cyan>;</font> parseDec <font color=Magenta>0</font>+<a name="line-182"></a> <font color=Cyan>`onFail`</font>+<a name="line-183"></a> parseSigned <font color=Cyan>(</font>parseDec <font color=Magenta>0</font><font color=Cyan>)</font> <font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-184"></a> <font color=Cyan>(</font> return <font color=Cyan>.</font> fromRational <font color=Cyan>.</font> <font color=Cyan>(</font><font color=Cyan>*</font> <font color=Cyan>(</font><font color=Magenta>10</font><font color=Cyan>^^</font><font color=Cyan>(</font>exp <font color=Blue>-</font> length frac<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-185"></a> <font color=Cyan>.</font> <font color=Cyan>(</font><font color=Cyan>%</font><font color=Magenta>1</font><font color=Cyan>)</font> <font color=Cyan>.</font> <font color=Cyan>(</font><font color=Red>\</font> <font color=Cyan>(</font>Right x<font color=Cyan>)</font><font color=Red>-></font>x<font color=Cyan>)</font> <font color=Cyan>.</font> fst+<a name="line-186"></a> <font color=Cyan>.</font> runParser <font color=Cyan>(</font>parseDec <font color=Magenta>0</font><font color=Cyan>)</font> <font color=Cyan>)</font> <font color=Cyan>(</font>ds<font color=Cyan>++</font>frac<font color=Cyan>)</font>+<a name="line-187"></a> <font color=Cyan>`onFail`</font>+<a name="line-188"></a> <font color=Green><u>do</u></font> w <font color=Red><-</font> many <font color=Cyan>(</font>satisfy <font color=Cyan>(</font>not<font color=Cyan>.</font>isSpace<font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-189"></a> <font color=Green><u>case</u></font> map toLower w <font color=Green><u>of</u></font>+<a name="line-190"></a> <font color=Magenta>"nan"</font> <font color=Red>-></font> return <font color=Cyan>(</font><font color=Magenta>0</font><font color=Cyan>/</font><font color=Magenta>0</font><font color=Cyan>)</font>+<a name="line-191"></a> <font color=Magenta>"infinity"</font> <font color=Red>-></font> return <font color=Cyan>(</font><font color=Magenta>1</font><font color=Cyan>/</font><font color=Magenta>0</font><font color=Cyan>)</font>+<a name="line-192"></a> <font color=Green><u>_</u></font> <font color=Red>-></font> fail <font color=Magenta>"expected a floating point number"</font>+<a name="line-193"></a>+<a name="line-194"></a><a name="parseLitChar"></a><font color=Blue>parseLitChar</font> <font color=Red>::</font> TextParser Char+<a name="line-195"></a><font color=Blue>parseLitChar</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'\''</font> <font color=Red><-</font> next <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Cyan>++</font><font color=Magenta>"expected a literal char"</font><font color=Cyan>)</font>+<a name="line-196"></a> c <font color=Red><-</font> next+<a name="line-197"></a> char <font color=Red><-</font> <font color=Green><u>case</u></font> c <font color=Green><u>of</u></font>+<a name="line-198"></a> <font color=Magenta>'\\'</font> <font color=Red>-></font> next <font color=Cyan>>>=</font> escape+<a name="line-199"></a> <font color=Magenta>'\''</font> <font color=Red>-></font> fail <font color=Magenta>"expected a literal char, got ''"</font>+<a name="line-200"></a> <font color=Green><u>_</u></font> <font color=Red>-></font> return c+<a name="line-201"></a> <font color=Magenta>'\''</font> <font color=Red><-</font> next <font color=Cyan>`adjustErrBad`</font> <font color=Cyan>(</font><font color=Cyan>++</font><font color=Magenta>"literal char has no final '"</font><font color=Cyan>)</font>+<a name="line-202"></a> return char+<a name="line-203"></a> <font color=Green><u>where</u></font>+<a name="line-204"></a> escape <font color=Magenta>'a'</font> <font color=Red>=</font> return <font color=Magenta>'\a'</font>+<a name="line-205"></a> escape <font color=Magenta>'b'</font> <font color=Red>=</font> return <font color=Magenta>'\b'</font>+<a name="line-206"></a> escape <font color=Magenta>'f'</font> <font color=Red>=</font> return <font color=Magenta>'\f'</font>+<a name="line-207"></a> escape <font color=Magenta>'n'</font> <font color=Red>=</font> return <font color=Magenta>'\n'</font>+<a name="line-208"></a> escape <font color=Magenta>'r'</font> <font color=Red>=</font> return <font color=Magenta>'\r'</font>+<a name="line-209"></a> escape <font color=Magenta>'t'</font> <font color=Red>=</font> return <font color=Magenta>'\t'</font>+<a name="line-210"></a> escape <font color=Magenta>'v'</font> <font color=Red>=</font> return <font color=Magenta>'\v'</font>+<a name="line-211"></a> escape <font color=Magenta>'\\'</font> <font color=Red>=</font> return <font color=Magenta>'\\'</font>+<a name="line-212"></a> escape <font color=Magenta>'"'</font> <font color=Red>=</font> return <font color=Magenta>'"'</font>+<a name="line-213"></a> escape <font color=Magenta>'\''</font> <font color=Red>=</font> return <font color=Magenta>'\''</font>+<a name="line-214"></a> escape <font color=Magenta>'^'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> ctrl <font color=Red><-</font> next+<a name="line-215"></a> <font color=Green><u>if</u></font> ctrl <font color=Cyan>>=</font> <font color=Magenta>'@'</font> <font color=Cyan>&&</font> ctrl <font color=Cyan><=</font> <font color=Magenta>'_'</font>+<a name="line-216"></a> <font color=Green><u>then</u></font> return <font color=Cyan>(</font>chr <font color=Cyan>(</font>ord ctrl <font color=Blue>-</font> ord <font color=Magenta>'@'</font><font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-217"></a> <font color=Green><u>else</u></font> fail <font color=Cyan>(</font><font color=Magenta>"literal char ctrl-escape malformed: \\^"</font>+<a name="line-218"></a> <font color=Cyan>++</font><font color=Red>[</font>ctrl<font color=Red>]</font><font color=Cyan>)</font>+<a name="line-219"></a> escape d <font color=Red>|</font> isDigit d+<a name="line-220"></a> <font color=Red>=</font> fmap chr <font color=Cyan>$</font> parseDec <font color=Cyan>(</font>Char<font color=Cyan>.</font>digitToInt d<font color=Cyan>)</font>+<a name="line-221"></a> escape <font color=Magenta>'o'</font> <font color=Red>=</font> fmap chr <font color=Cyan>$</font> parseOct <font color=Magenta>0</font>+<a name="line-222"></a> escape <font color=Magenta>'x'</font> <font color=Red>=</font> fmap chr <font color=Cyan>$</font> parseHex <font color=Magenta>0</font>+<a name="line-223"></a> escape c <font color=Red>|</font> isUpper c+<a name="line-224"></a> <font color=Red>=</font> mnemonic c+<a name="line-225"></a> escape c <font color=Red>=</font> fail <font color=Cyan>(</font><font color=Magenta>"unrecognised escape sequence in literal char: \\"</font><font color=Cyan>++</font><font color=Red>[</font>c<font color=Red>]</font><font color=Cyan>)</font>+<a name="line-226"></a>+<a name="line-227"></a> mnemonic <font color=Magenta>'A'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'C'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'K'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\ACK'</font>+<a name="line-228"></a> <font color=Cyan>`wrap`</font> <font color=Magenta>"'\\ACK'"</font>+<a name="line-229"></a> mnemonic <font color=Magenta>'B'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'E'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'L'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\BEL'</font>+<a name="line-230"></a> <font color=Cyan>`onFail`</font>+<a name="line-231"></a> <font color=Green><u>do</u></font> <font color=Magenta>'S'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\BS'</font>+<a name="line-232"></a> <font color=Cyan>`wrap`</font> <font color=Magenta>"'\\BEL' or '\\BS'"</font>+<a name="line-233"></a> mnemonic <font color=Magenta>'C'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'R'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\CR'</font>+<a name="line-234"></a> <font color=Cyan>`onFail`</font>+<a name="line-235"></a> <font color=Green><u>do</u></font> <font color=Magenta>'A'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'N'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\CAN'</font>+<a name="line-236"></a> <font color=Cyan>`wrap`</font> <font color=Magenta>"'\\CR' or '\\CAN'"</font>+<a name="line-237"></a> mnemonic <font color=Magenta>'D'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'E'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'L'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\DEL'</font>+<a name="line-238"></a> <font color=Cyan>`onFail`</font>+<a name="line-239"></a> <font color=Green><u>do</u></font> <font color=Magenta>'L'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'E'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\DLE'</font>+<a name="line-240"></a> <font color=Cyan>`onFail`</font>+<a name="line-241"></a> <font color=Green><u>do</u></font> <font color=Magenta>'C'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Cyan>(</font> <font color=Green><u>do</u></font> <font color=Magenta>'1'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\DC1'</font>+<a name="line-242"></a> <font color=Cyan>`onFail`</font>+<a name="line-243"></a> <font color=Green><u>do</u></font> <font color=Magenta>'2'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\DC2'</font>+<a name="line-244"></a> <font color=Cyan>`onFail`</font>+<a name="line-245"></a> <font color=Green><u>do</u></font> <font color=Magenta>'3'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\DC3'</font>+<a name="line-246"></a> <font color=Cyan>`onFail`</font>+<a name="line-247"></a> <font color=Green><u>do</u></font> <font color=Magenta>'4'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\DC4'</font> <font color=Cyan>)</font>+<a name="line-248"></a> <font color=Cyan>`wrap`</font> <font color=Magenta>"'\\DEL' or '\\DLE' or '\\DC[1..4]'"</font>+<a name="line-249"></a> mnemonic <font color=Magenta>'E'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'T'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'X'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\ETX'</font>+<a name="line-250"></a> <font color=Cyan>`onFail`</font>+<a name="line-251"></a> <font color=Green><u>do</u></font> <font color=Magenta>'O'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'T'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\EOT'</font>+<a name="line-252"></a> <font color=Cyan>`onFail`</font>+<a name="line-253"></a> <font color=Green><u>do</u></font> <font color=Magenta>'N'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'Q'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\ENQ'</font>+<a name="line-254"></a> <font color=Cyan>`onFail`</font>+<a name="line-255"></a> <font color=Green><u>do</u></font> <font color=Magenta>'T'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'B'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\ETB'</font>+<a name="line-256"></a> <font color=Cyan>`onFail`</font>+<a name="line-257"></a> <font color=Green><u>do</u></font> <font color=Magenta>'M'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\EM'</font>+<a name="line-258"></a> <font color=Cyan>`onFail`</font>+<a name="line-259"></a> <font color=Green><u>do</u></font> <font color=Magenta>'S'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'C'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\ESC'</font>+<a name="line-260"></a> <font color=Cyan>`wrap`</font> <font color=Magenta>"one of '\\ETX' '\\EOT' '\\ENQ' '\\ETB' '\\EM' or '\\ESC'"</font>+<a name="line-261"></a> mnemonic <font color=Magenta>'F'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'F'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\FF'</font>+<a name="line-262"></a> <font color=Cyan>`onFail`</font>+<a name="line-263"></a> <font color=Green><u>do</u></font> <font color=Magenta>'S'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\FS'</font>+<a name="line-264"></a> <font color=Cyan>`wrap`</font> <font color=Magenta>"'\\FF' or '\\FS'"</font>+<a name="line-265"></a> mnemonic <font color=Magenta>'G'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'S'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\GS'</font>+<a name="line-266"></a> <font color=Cyan>`wrap`</font> <font color=Magenta>"'\\GS'"</font>+<a name="line-267"></a> mnemonic <font color=Magenta>'H'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'T'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\HT'</font>+<a name="line-268"></a> <font color=Cyan>`wrap`</font> <font color=Magenta>"'\\HT'"</font>+<a name="line-269"></a> mnemonic <font color=Magenta>'L'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'F'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\LF'</font>+<a name="line-270"></a> <font color=Cyan>`wrap`</font> <font color=Magenta>"'\\LF'"</font>+<a name="line-271"></a> mnemonic <font color=Magenta>'N'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'U'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'L'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\NUL'</font>+<a name="line-272"></a> <font color=Cyan>`onFail`</font>+<a name="line-273"></a> <font color=Green><u>do</u></font> <font color=Magenta>'A'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'K'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\NAK'</font>+<a name="line-274"></a> <font color=Cyan>`wrap`</font> <font color=Magenta>"'\\NUL' or '\\NAK'"</font>+<a name="line-275"></a> mnemonic <font color=Magenta>'R'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'S'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\RS'</font>+<a name="line-276"></a> <font color=Cyan>`wrap`</font> <font color=Magenta>"'\\RS'"</font>+<a name="line-277"></a> mnemonic <font color=Magenta>'S'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'O'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'H'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\SOH'</font>+<a name="line-278"></a> <font color=Cyan>`onFail`</font>+<a name="line-279"></a> <font color=Green><u>do</u></font> <font color=Magenta>'O'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\SO'</font>+<a name="line-280"></a> <font color=Cyan>`onFail`</font>+<a name="line-281"></a> <font color=Green><u>do</u></font> <font color=Magenta>'T'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'X'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\STX'</font>+<a name="line-282"></a> <font color=Cyan>`onFail`</font>+<a name="line-283"></a> <font color=Green><u>do</u></font> <font color=Magenta>'I'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\SI'</font>+<a name="line-284"></a> <font color=Cyan>`onFail`</font>+<a name="line-285"></a> <font color=Green><u>do</u></font> <font color=Magenta>'Y'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'N'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\SYN'</font>+<a name="line-286"></a> <font color=Cyan>`onFail`</font>+<a name="line-287"></a> <font color=Green><u>do</u></font> <font color=Magenta>'U'</font> <font color=Red><-</font> next<font color=Cyan>;</font> <font color=Magenta>'B'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\SUB'</font>+<a name="line-288"></a> <font color=Cyan>`onFail`</font>+<a name="line-289"></a> <font color=Green><u>do</u></font> <font color=Magenta>'P'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\SP'</font>+<a name="line-290"></a> <font color=Cyan>`wrap`</font> <font color=Magenta>"'\\SOH' '\\SO' '\\STX' '\\SI' '\\SYN' '\\SUB' or '\\SP'"</font>+<a name="line-291"></a> mnemonic <font color=Magenta>'U'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'S'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\US'</font>+<a name="line-292"></a> <font color=Cyan>`wrap`</font> <font color=Magenta>"'\\US'"</font>+<a name="line-293"></a> mnemonic <font color=Magenta>'V'</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Magenta>'T'</font> <font color=Red><-</font> next<font color=Cyan>;</font> return <font color=Magenta>'\VT'</font>+<a name="line-294"></a> <font color=Cyan>`wrap`</font> <font color=Magenta>"'\\VT'"</font>+<a name="line-295"></a> wrap p s <font color=Red>=</font> p <font color=Cyan>`onFail`</font> fail <font color=Cyan>(</font><font color=Magenta>"expected literal char "</font><font color=Cyan>++</font>s<font color=Cyan>)</font>+<a name="line-296"></a>+<a name="line-297"></a><font color=Blue>-- Basic types</font>+<a name="line-298"></a><font color=Green><u>instance</u></font> Parse Int <font color=Green><u>where</u></font>+<a name="line-299"></a> <font color=Blue>-- parse = parseByRead "Int" -- convert from Integer, deals with minInt</font>+<a name="line-300"></a> parse <font color=Red>=</font> fmap fromInteger <font color=Cyan>$</font>+<a name="line-301"></a> <font color=Green><u>do</u></font> many <font color=Cyan>(</font>satisfy isSpace<font color=Cyan>)</font><font color=Cyan>;</font> parseSigned <font color=Cyan>(</font>parseDec <font color=Magenta>0</font><font color=Cyan>)</font>+<a name="line-302"></a><font color=Green><u>instance</u></font> Parse Integer <font color=Green><u>where</u></font>+<a name="line-303"></a> <font color=Blue>-- parse = parseByRead "Integer"</font>+<a name="line-304"></a> parse <font color=Red>=</font> <font color=Green><u>do</u></font> many <font color=Cyan>(</font>satisfy isSpace<font color=Cyan>)</font><font color=Cyan>;</font> parseSigned <font color=Cyan>(</font>parseDec <font color=Magenta>0</font><font color=Cyan>)</font>+<a name="line-305"></a><font color=Green><u>instance</u></font> Parse Float <font color=Green><u>where</u></font>+<a name="line-306"></a> <font color=Blue>-- parse = parseByRead "Float"</font>+<a name="line-307"></a> parse <font color=Red>=</font> <font color=Green><u>do</u></font> many <font color=Cyan>(</font>satisfy isSpace<font color=Cyan>)</font><font color=Cyan>;</font> parseSigned parseFloat+<a name="line-308"></a><font color=Green><u>instance</u></font> Parse Double <font color=Green><u>where</u></font>+<a name="line-309"></a> <font color=Blue>-- parse = parseByRead "Double"</font>+<a name="line-310"></a> parse <font color=Red>=</font> <font color=Green><u>do</u></font> many <font color=Cyan>(</font>satisfy isSpace<font color=Cyan>)</font><font color=Cyan>;</font> parseSigned parseFloat+<a name="line-311"></a><font color=Green><u>instance</u></font> Parse Char <font color=Green><u>where</u></font>+<a name="line-312"></a><font color=Blue>-- parse = parseByRead "Char"</font>+<a name="line-313"></a> parse <font color=Red>=</font> <font color=Green><u>do</u></font> many <font color=Cyan>(</font>satisfy isSpace<font color=Cyan>)</font><font color=Cyan>;</font> parseLitChar+<a name="line-314"></a> <font color=Blue>-- parse = do { w <- word; if head w == '\'' then readLitChar (tail w)</font>+<a name="line-315"></a> <font color=Blue>-- else fail "expected a char" }</font>+<a name="line-316"></a> <font color=Blue>-- parseList = bracket (isWord "\"") (satisfy (=='"'))</font>+<a name="line-317"></a> <font color=Blue>-- (many (satisfy (/='"')))</font>+<a name="line-318"></a> <font color=Blue>-- not totally correct for strings...</font>+<a name="line-319"></a> parseList <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> w <font color=Red><-</font> word<font color=Cyan>;</font> <font color=Green><u>if</u></font> head w <font color=Cyan>==</font> <font color=Magenta>'"'</font> <font color=Green><u>then</u></font> return <font color=Cyan>(</font>init <font color=Cyan>(</font>tail w<font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-320"></a> <font color=Green><u>else</u></font> fail <font color=Magenta>"not a string"</font> <font color=Cyan>}</font>+<a name="line-321"></a>+<a name="line-322"></a><font color=Green><u>instance</u></font> Parse Bool <font color=Green><u>where</u></font>+<a name="line-323"></a> parse <font color=Red>=</font> enumeration <font color=Magenta>"Bool"</font> <font color=Red>[</font>False<font color=Cyan>,</font>True<font color=Red>]</font>+<a name="line-324"></a>+<a name="line-325"></a><font color=Green><u>instance</u></font> Parse Ordering <font color=Green><u>where</u></font>+<a name="line-326"></a> parse <font color=Red>=</font> enumeration <font color=Magenta>"Ordering"</font> <font color=Red>[</font>LT<font color=Cyan>,</font>EQ<font color=Cyan>,</font>GT<font color=Red>]</font>+<a name="line-327"></a>+<a name="line-328"></a><font color=Blue>-- Structural types</font>+<a name="line-329"></a><font color=Green><u>instance</u></font> Parse () <font color=Green><u>where</u></font>+<a name="line-330"></a> parse <font color=Red>=</font> P p+<a name="line-331"></a> <font color=Green><u>where</u></font> p [] <font color=Red>=</font> Failure [] <font color=Magenta>"no input: expected a ()"</font>+<a name="line-332"></a> p <font color=Cyan>(</font><font color=Magenta>'('</font><font color=Red><b>:</b></font>cs<font color=Cyan>)</font> <font color=Red>=</font> <font color=Green><u>case</u></font> dropWhile isSpace cs <font color=Green><u>of</u></font>+<a name="line-333"></a> <font color=Cyan>(</font><font color=Magenta>')'</font><font color=Red><b>:</b></font>s<font color=Cyan>)</font> <font color=Red>-></font> Success s ()+<a name="line-334"></a> <font color=Green><u>_</u></font> <font color=Red>-></font> Failure cs <font color=Magenta>"Expected ) after ("</font>+<a name="line-335"></a> p <font color=Cyan>(</font>c<font color=Red><b>:</b></font>cs<font color=Cyan>)</font> <font color=Red>|</font> isSpace c <font color=Red>=</font> p cs+<a name="line-336"></a> <font color=Red>|</font> otherwise <font color=Red>=</font> Failure <font color=Cyan>(</font>c<font color=Red><b>:</b></font>cs<font color=Cyan>)</font> <font color=Cyan>(</font><font color=Magenta>"Expected a (), got "</font><font color=Cyan>++</font>show c<font color=Cyan>)</font>+<a name="line-337"></a>+<a name="line-338"></a><font color=Green><u>instance</u></font> <font color=Cyan>(</font>Parse a<font color=Cyan>,</font> Parse b<font color=Cyan>)</font> <font color=Red>=></font> Parse <font color=Cyan>(</font>a<font color=Cyan>,</font>b<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-339"></a> parse <font color=Red>=</font> <font color=Green><u>do</u></font><font color=Cyan>{</font> isWord <font color=Magenta>"("</font> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Opening a 2-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-340"></a> <font color=Cyan>;</font> x <font color=Red><-</font> parse <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"In 1st item of a 2-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-341"></a> <font color=Cyan>;</font> isWord <font color=Magenta>","</font> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Separating a 2-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-342"></a> <font color=Cyan>;</font> y <font color=Red><-</font> parse <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"In 2nd item of a 2-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-343"></a> <font color=Cyan>;</font> isWord <font color=Magenta>")"</font> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Closing a 2-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-344"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Cyan>,</font>y<font color=Cyan>)</font> <font color=Cyan>}</font>+<a name="line-345"></a>+<a name="line-346"></a><font color=Green><u>instance</u></font> <font color=Cyan>(</font>Parse a<font color=Cyan>,</font> Parse b<font color=Cyan>,</font> Parse c<font color=Cyan>)</font> <font color=Red>=></font> Parse <font color=Cyan>(</font>a<font color=Cyan>,</font>b<font color=Cyan>,</font>c<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-347"></a> parse <font color=Red>=</font> <font color=Green><u>do</u></font><font color=Cyan>{</font> isWord <font color=Magenta>"("</font> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Opening a 3-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-348"></a> <font color=Cyan>;</font> x <font color=Red><-</font> parse <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"In 1st item of a 3-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-349"></a> <font color=Cyan>;</font> isWord <font color=Magenta>","</font> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Separating(1) a 3-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-350"></a> <font color=Cyan>;</font> y <font color=Red><-</font> parse <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"In 2nd item of a 3-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-351"></a> <font color=Cyan>;</font> isWord <font color=Magenta>","</font> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Separating(2) a 3-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-352"></a> <font color=Cyan>;</font> z <font color=Red><-</font> parse <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"In 3rd item of a 3-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-353"></a> <font color=Cyan>;</font> isWord <font color=Magenta>")"</font> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Closing a 3-tuple\n"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-354"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Cyan>,</font>y<font color=Cyan>,</font>z<font color=Cyan>)</font> <font color=Cyan>}</font>+<a name="line-355"></a>+<a name="line-356"></a><font color=Green><u>instance</u></font> Parse a <font color=Red>=></font> Parse <font color=Cyan>(</font>Maybe a<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-357"></a> parsePrec p <font color=Red>=</font>+<a name="line-358"></a> parens False <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord <font color=Magenta>"Nothing"</font><font color=Cyan>;</font> return Nothing <font color=Cyan>}</font><font color=Cyan>)</font>+<a name="line-359"></a> <font color=Cyan>`onFail`</font>+<a name="line-360"></a> parens <font color=Cyan>(</font>p<font color=Cyan>></font><font color=Magenta>9</font><font color=Cyan>)</font> <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Cyan>{</font> isWord <font color=Magenta>"Just"</font>+<a name="line-361"></a> <font color=Cyan>;</font> fmap Just <font color=Cyan>$</font> parsePrec <font color=Magenta>10</font>+<a name="line-362"></a> <font color=Cyan>`adjustErrBad`</font> <font color=Cyan>(</font><font color=Magenta>"but within Just, "</font><font color=Cyan>++</font><font color=Cyan>)</font> <font color=Cyan>}</font><font color=Cyan>)</font>+<a name="line-363"></a> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Cyan>(</font><font color=Magenta>"expected a Maybe (Just or Nothing)\n"</font><font color=Cyan>++</font><font color=Cyan>)</font><font color=Cyan>.</font>indent <font color=Magenta>2</font><font color=Cyan>)</font>+<a name="line-364"></a>+<a name="line-365"></a><font color=Green><u>instance</u></font> <font color=Cyan>(</font>Parse a<font color=Cyan>,</font> Parse b<font color=Cyan>)</font> <font color=Red>=></font> Parse <font color=Cyan>(</font>Either a b<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-366"></a> parsePrec p <font color=Red>=</font>+<a name="line-367"></a> parens <font color=Cyan>(</font>p<font color=Cyan>></font><font color=Magenta>9</font><font color=Cyan>)</font> <font color=Cyan>$</font>+<a name="line-368"></a> constructors <font color=Red>[</font> <font color=Cyan>(</font><font color=Magenta>"Left"</font><font color=Cyan>,</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> fmap Left <font color=Cyan>$</font> parsePrec <font color=Magenta>10</font> <font color=Cyan>}</font> <font color=Cyan>)</font>+<a name="line-369"></a> <font color=Cyan>,</font> <font color=Cyan>(</font><font color=Magenta>"Right"</font><font color=Cyan>,</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> fmap Right <font color=Cyan>$</font> parsePrec <font color=Magenta>10</font> <font color=Cyan>}</font> <font color=Cyan>)</font>+<a name="line-370"></a> <font color=Red>]</font>+<a name="line-371"></a>+<a name="line-372"></a><font color=Green><u>instance</u></font> Parse a <font color=Red>=></font> Parse <font color=Red>[</font>a<font color=Red>]</font> <font color=Green><u>where</u></font>+<a name="line-373"></a> parse <font color=Red>=</font> parseList+<a name="line-374"></a>+<a name="line-375"></a><font color=Blue>------------------------------------------------------------------------</font> </pre>+</body> </html>
docs/haddock/src/Text/ParserCombinators/HuttonMeijer.html view
@@ -1,222 +1,228 @@ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"> <html>-<pre><a name="(line1)"></a><font color=Blue>-----------------------------------------------------------------------------</font>-<a name="(line2)"></a><font color=Blue>-- |</font>-<a name="(line3)"></a><font color=Blue>-- Module : Text.ParserCombinators.HuttonMeijer</font>-<a name="(line4)"></a><font color=Blue>-- Copyright : Graham Hutton (University of Nottingham), Erik Meijer (University of Utrecht)</font>-<a name="(line5)"></a><font color=Blue>-- Licence : BSD</font>-<a name="(line6)"></a><font color=Blue>-- </font>-<a name="(line7)"></a><font color=Blue>-- Maintainer : Malcolm Wallace <Malcolm.Wallace@cs.york.ac.uk></font>-<a name="(line8)"></a><font color=Blue>-- Stability : Stable</font>-<a name="(line9)"></a><font color=Blue>-- Portability : All</font>-<a name="(line10)"></a><font color=Blue>--</font>-<a name="(line11)"></a><font color=Blue>-- A LIBRARY OF MONADIC PARSER COMBINATORS</font>-<a name="(line12)"></a><font color=Blue>-- </font>-<a name="(line13)"></a><font color=Blue>-- 29th July 1996</font>-<a name="(line14)"></a><font color=Blue>-- </font>-<a name="(line15)"></a><font color=Blue>-- Graham Hutton Erik Meijer</font>-<a name="(line16)"></a><font color=Blue>-- University of Nottingham University of Utrecht</font>-<a name="(line17)"></a><font color=Blue>-- </font>-<a name="(line18)"></a><font color=Blue>-- This Haskell script defines a library of parser combinators, and is</font>-<a name="(line19)"></a><font color=Blue>-- taken from sections 1-6 of our article "Monadic Parser Combinators".</font>-<a name="(line20)"></a><font color=Blue>-- Some changes to the library have been made in the move from Gofer</font>-<a name="(line21)"></a><font color=Blue>-- to Haskell:</font>-<a name="(line22)"></a><font color=Blue>-- </font>-<a name="(line23)"></a><font color=Blue>-- * Do notation is used in place of monad comprehension notation;</font>-<a name="(line24)"></a><font color=Blue>-- </font>-<a name="(line25)"></a><font color=Blue>-- * The parser datatype is defined using "newtype", to avoid the overhead</font>-<a name="(line26)"></a><font color=Blue>-- of tagging and untagging parsers with the P constructor.</font>-<a name="(line27)"></a><font color=Blue>-----------------------------------------------------------------------------</font>-<a name="(line28)"></a>-<a name="(line29)"></a>-<a name="(line30)"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>HuttonMeijer-<a name="(line31)"></a> <font color=Cyan>(</font>Parser<font color=Cyan>(</font><font color=Red>..</font><font color=Cyan>)</font><font color=Cyan>,</font> item<font color=Cyan>,</font> first<font color=Cyan>,</font> papply<font color=Cyan>,</font> <font color=Cyan>(</font><font color=Cyan>+++</font><font color=Cyan>)</font><font color=Cyan>,</font> sat<font color=Cyan>,</font> <font color=Blue>{-tok,-}</font> many<font color=Cyan>,</font> many1<font color=Cyan>,</font>-<a name="(line32)"></a> sepby<font color=Cyan>,</font> sepby1<font color=Cyan>,</font> chainl<font color=Cyan>,</font>-<a name="(line33)"></a> chainl1<font color=Cyan>,</font> chainr<font color=Cyan>,</font> chainr1<font color=Cyan>,</font> ops<font color=Cyan>,</font> bracket<font color=Cyan>,</font> char<font color=Cyan>,</font> digit<font color=Cyan>,</font> lower<font color=Cyan>,</font> upper<font color=Cyan>,</font>-<a name="(line34)"></a> letter<font color=Cyan>,</font> alphanum<font color=Cyan>,</font> string<font color=Cyan>,</font> ident<font color=Cyan>,</font> nat<font color=Cyan>,</font> int<font color=Cyan>,</font> spaces<font color=Cyan>,</font> comment<font color=Cyan>,</font> junk<font color=Cyan>,</font>-<a name="(line35)"></a> skip<font color=Cyan>,</font> token<font color=Cyan>,</font> natural<font color=Cyan>,</font> integer<font color=Cyan>,</font> symbol<font color=Cyan>,</font> identifier<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line36)"></a>-<a name="(line37)"></a><font color=Green><u>import</u></font> Char-<a name="(line38)"></a><font color=Green><u>import</u></font> Monad-<a name="(line39)"></a>-<a name="(line40)"></a><font color=Green><u>infixr</u></font> <font color=Magenta>5</font> <font color=Cyan>+++</font>-<a name="(line41)"></a>-<a name="(line42)"></a><a name="Token"></a><font color=Green><u>type</u></font> Token <font color=Red>=</font> Char-<a name="(line43)"></a>-<a name="(line44)"></a><font color=Blue>---------------------------------------------------------</font>-<a name="(line45)"></a><font color=Blue>-- | The parser monad</font>-<a name="(line46)"></a>-<a name="(line47)"></a><a name="Parser"></a><font color=Green><u>newtype</u></font> Parser a <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>[</font>Token<font color=Red>]</font> <font color=Red>-></font> <font color=Red>[</font><font color=Cyan>(</font>a<font color=Cyan>,</font><font color=Red>[</font>Token<font color=Red>]</font><font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>-<a name="(line48)"></a>-<a name="(line49)"></a><font color=Green><u>instance</u></font> Functor Parser <font color=Green><u>where</u></font>-<a name="(line50)"></a> <font color=Blue>-- map :: (a -> b) -> (Parser a -> Parser b)</font>-<a name="(line51)"></a> fmap f <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp <font color=Red>-></font> <font color=Red>[</font><font color=Cyan>(</font>f v<font color=Cyan>,</font> out<font color=Cyan>)</font> <font color=Red>|</font> <font color=Cyan>(</font>v<font color=Cyan>,</font>out<font color=Cyan>)</font> <font color=Red><-</font> p inp<font color=Red>]</font><font color=Cyan>)</font>-<a name="(line52)"></a>-<a name="(line53)"></a><font color=Green><u>instance</u></font> Monad Parser <font color=Green><u>where</u></font>-<a name="(line54)"></a> <font color=Blue>-- return :: a -> Parser a</font>-<a name="(line55)"></a> return v <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp <font color=Red>-></font> <font color=Red>[</font><font color=Cyan>(</font>v<font color=Cyan>,</font>inp<font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>-<a name="(line56)"></a>-<a name="(line57)"></a> <font color=Blue>-- >>= :: Parser a -> (a -> Parser b) -> Parser b</font>-<a name="(line58)"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>>>=</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp <font color=Red>-></font> concat <font color=Red>[</font>papply <font color=Cyan>(</font>f v<font color=Cyan>)</font> out <font color=Red>|</font> <font color=Cyan>(</font>v<font color=Cyan>,</font>out<font color=Cyan>)</font> <font color=Red><-</font> p inp<font color=Red>]</font><font color=Cyan>)</font>-<a name="(line59)"></a>-<a name="(line60)"></a> <font color=Blue>-- fail :: String -> Parser a</font>-<a name="(line61)"></a> fail <font color=Green><u>_</u></font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font><font color=Green><u>_</u></font> <font color=Red>-></font> []<font color=Cyan>)</font>-<a name="(line62)"></a>-<a name="(line63)"></a><font color=Green><u>instance</u></font> MonadPlus Parser <font color=Green><u>where</u></font>-<a name="(line64)"></a> <font color=Blue>-- mzero :: Parser a</font>-<a name="(line65)"></a> mzero <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font><font color=Green><u>_</u></font> <font color=Red>-></font> []<font color=Cyan>)</font>-<a name="(line66)"></a>-<a name="(line67)"></a> <font color=Blue>-- mplus :: Parser a -> Parser a -> Parser a</font>-<a name="(line68)"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`mplus`</font> <font color=Cyan>(</font>P q<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp <font color=Red>-></font> <font color=Cyan>(</font>p inp <font color=Cyan>++</font> q inp<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line69)"></a>-<a name="(line70)"></a><font color=Blue>-- ------------------------------------------------------------</font>-<a name="(line71)"></a><font color=Blue>-- * Other primitive parser combinators</font>-<a name="(line72)"></a><font color=Blue>-- ------------------------------------------------------------</font>-<a name="(line73)"></a>-<a name="(line74)"></a><a name="item"></a>item <font color=Red>::</font> Parser Token-<a name="(line75)"></a>item <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp <font color=Red>-></font> <font color=Green><u>case</u></font> inp <font color=Green><u>of</u></font>-<a name="(line76)"></a> [] <font color=Red>-></font> []-<a name="(line77)"></a> <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font> <font color=Red>-></font> <font color=Red>[</font><font color=Cyan>(</font>x<font color=Cyan>,</font>xs<font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>-<a name="(line78)"></a>-<a name="(line79)"></a><a name="first"></a>first <font color=Red>::</font> Parser a <font color=Red>-></font> Parser a-<a name="(line80)"></a>first <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp <font color=Red>-></font> <font color=Green><u>case</u></font> p inp <font color=Green><u>of</u></font>-<a name="(line81)"></a> [] <font color=Red>-></font> []-<a name="(line82)"></a> <font color=Cyan>(</font>x<font color=Red><b>:</b></font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> <font color=Red>[</font>x<font color=Red>]</font><font color=Cyan>)</font>-<a name="(line83)"></a>-<a name="(line84)"></a><a name="papply"></a>papply <font color=Red>::</font> Parser a <font color=Red>-></font> <font color=Red>[</font>Token<font color=Red>]</font> <font color=Red>-></font> <font color=Red>[</font><font color=Cyan>(</font>a<font color=Cyan>,</font><font color=Red>[</font>Token<font color=Red>]</font><font color=Cyan>)</font><font color=Red>]</font>-<a name="(line85)"></a>papply <font color=Cyan>(</font>P p<font color=Cyan>)</font> inp <font color=Red>=</font> p inp-<a name="(line86)"></a>-<a name="(line87)"></a><font color=Blue>-- ------------------------------------------------------------</font>-<a name="(line88)"></a><font color=Blue>-- * Derived combinators</font>-<a name="(line89)"></a><font color=Blue>-- ------------------------------------------------------------</font>-<a name="(line90)"></a>-<a name="(line91)"></a><a name="+++"></a><font color=Cyan>(</font><font color=Cyan>+++</font><font color=Cyan>)</font> <font color=Red>::</font> Parser a <font color=Red>-></font> Parser a <font color=Red>-></font> Parser a-<a name="(line92)"></a><a name="p"></a>p <font color=Cyan>+++</font> q <font color=Red>=</font> first <font color=Cyan>(</font>p <font color=Cyan>`mplus`</font> q<font color=Cyan>)</font>-<a name="(line93)"></a>-<a name="(line94)"></a><a name="sat"></a>sat <font color=Red>::</font> <font color=Cyan>(</font>Token <font color=Red>-></font> Bool<font color=Cyan>)</font> <font color=Red>-></font> Parser Token-<a name="(line95)"></a>sat p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> item<font color=Cyan>;</font> <font color=Green><u>if</u></font> p x <font color=Green><u>then</u></font> return x <font color=Green><u>else</u></font> mzero<font color=Cyan>}</font>-<a name="(line96)"></a>-<a name="(line97)"></a><font color=Blue>--tok :: Token -> Parser Token</font>-<a name="(line98)"></a><font color=Blue>--tok t = do {x <- item; if t==snd x then return t else mzero}</font>-<a name="(line99)"></a>-<a name="(line100)"></a><a name="many"></a>many <font color=Red>::</font> Parser a <font color=Red>-></font> Parser <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line101)"></a>many p <font color=Red>=</font> many1 p <font color=Cyan>+++</font> return []-<a name="(line102)"></a><font color=Blue>--many p = force (many1 p +++ return [])</font>-<a name="(line103)"></a>-<a name="(line104)"></a><a name="many1"></a>many1 <font color=Red>::</font> Parser a <font color=Red>-></font> Parser <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line105)"></a>many1 p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> xs <font color=Red><-</font> many p<font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font><font color=Cyan>}</font>-<a name="(line106)"></a>-<a name="(line107)"></a><a name="sepby"></a>sepby <font color=Red>::</font> Parser a <font color=Red>-></font> Parser b <font color=Red>-></font> Parser <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line108)"></a><a name="sepby"></a>p <font color=Cyan>`sepby`</font> sep <font color=Red>=</font> <font color=Cyan>(</font>p <font color=Cyan>`sepby1`</font> sep<font color=Cyan>)</font> <font color=Cyan>+++</font> return []-<a name="(line109)"></a>-<a name="(line110)"></a><a name="sepby1"></a>sepby1 <font color=Red>::</font> Parser a <font color=Red>-></font> Parser b <font color=Red>-></font> Parser <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line111)"></a><a name="sepby1"></a>p <font color=Cyan>`sepby1`</font> sep <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> xs <font color=Red><-</font> many <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>sep<font color=Cyan>;</font> p<font color=Cyan>}</font><font color=Cyan>)</font><font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font><font color=Cyan>}</font>-<a name="(line112)"></a>-<a name="(line113)"></a><a name="chainl"></a>chainl <font color=Red>::</font> Parser a <font color=Red>-></font> Parser <font color=Cyan>(</font>a <font color=Red>-></font> a <font color=Red>-></font> a<font color=Cyan>)</font> <font color=Red>-></font> a <font color=Red>-></font> Parser a-<a name="(line114)"></a>chainl p op v <font color=Red>=</font> <font color=Cyan>(</font>p <font color=Cyan>`chainl1`</font> op<font color=Cyan>)</font> <font color=Cyan>+++</font> return v-<a name="(line115)"></a>-<a name="(line116)"></a><a name="chainl1"></a>chainl1 <font color=Red>::</font> Parser a <font color=Red>-></font> Parser <font color=Cyan>(</font>a <font color=Red>-></font> a <font color=Red>-></font> a<font color=Cyan>)</font> <font color=Red>-></font> Parser a-<a name="(line117)"></a><a name="chainl1"></a>p <font color=Cyan>`chainl1`</font> op <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> rest x<font color=Cyan>}</font>-<a name="(line118)"></a> <font color=Green><u>where</u></font>-<a name="(line119)"></a> rest x <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>f <font color=Red><-</font> op<font color=Cyan>;</font> y <font color=Red><-</font> p<font color=Cyan>;</font> rest <font color=Cyan>(</font>f x y<font color=Cyan>)</font><font color=Cyan>}</font>-<a name="(line120)"></a> <font color=Cyan>+++</font> return x-<a name="(line121)"></a>-<a name="(line122)"></a><a name="chainr"></a>chainr <font color=Red>::</font> Parser a <font color=Red>-></font> Parser <font color=Cyan>(</font>a <font color=Red>-></font> a <font color=Red>-></font> a<font color=Cyan>)</font> <font color=Red>-></font> a <font color=Red>-></font> Parser a-<a name="(line123)"></a>chainr p op v <font color=Red>=</font> <font color=Cyan>(</font>p <font color=Cyan>`chainr1`</font> op<font color=Cyan>)</font> <font color=Cyan>+++</font> return v-<a name="(line124)"></a>-<a name="(line125)"></a><a name="chainr1"></a>chainr1 <font color=Red>::</font> Parser a <font color=Red>-></font> Parser <font color=Cyan>(</font>a <font color=Red>-></font> a <font color=Red>-></font> a<font color=Cyan>)</font> <font color=Red>-></font> Parser a-<a name="(line126)"></a><a name="chainr1"></a>p <font color=Cyan>`chainr1`</font> op <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> rest x<font color=Cyan>}</font>-<a name="(line127)"></a> <font color=Green><u>where</u></font>-<a name="(line128)"></a> rest x <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>f <font color=Red><-</font> op<font color=Cyan>;</font> y <font color=Red><-</font> p <font color=Cyan>`chainr1`</font> op<font color=Cyan>;</font> return <font color=Cyan>(</font>f x y<font color=Cyan>)</font><font color=Cyan>}</font>-<a name="(line129)"></a> <font color=Cyan>+++</font> return x-<a name="(line130)"></a>-<a name="(line131)"></a><a name="ops"></a>ops <font color=Red>::</font> <font color=Red>[</font><font color=Cyan>(</font>Parser a<font color=Cyan>,</font> b<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> Parser b-<a name="(line132)"></a>ops xs <font color=Red>=</font> foldr1 <font color=Cyan>(</font><font color=Cyan>+++</font><font color=Cyan>)</font> <font color=Red>[</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>p<font color=Cyan>;</font> return op<font color=Cyan>}</font> <font color=Red>|</font> <font color=Cyan>(</font>p<font color=Cyan>,</font>op<font color=Cyan>)</font> <font color=Red><-</font> xs<font color=Red>]</font>-<a name="(line133)"></a>-<a name="(line134)"></a><a name="bracket"></a>bracket <font color=Red>::</font> Parser a <font color=Red>-></font> Parser b <font color=Red>-></font> Parser c <font color=Red>-></font> Parser b-<a name="(line135)"></a>bracket open p close <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>open<font color=Cyan>;</font> x <font color=Red><-</font> p<font color=Cyan>;</font> close<font color=Cyan>;</font> return x<font color=Cyan>}</font>-<a name="(line136)"></a>-<a name="(line137)"></a><font color=Blue>-- ------------------------------------------------------------</font>-<a name="(line138)"></a><font color=Blue>-- * Useful parsers</font>-<a name="(line139)"></a><font color=Blue>-- ------------------------------------------------------------</font>-<a name="(line140)"></a>-<a name="(line141)"></a><a name="char"></a>char <font color=Red>::</font> Char <font color=Red>-></font> Parser Char-<a name="(line142)"></a>char x <font color=Red>=</font> sat <font color=Cyan>(</font><font color=Red>\</font>y <font color=Red>-></font> x <font color=Cyan>==</font> y<font color=Cyan>)</font>-<a name="(line143)"></a>-<a name="(line144)"></a><a name="digit"></a>digit <font color=Red>::</font> Parser Char-<a name="(line145)"></a>digit <font color=Red>=</font> sat isDigit-<a name="(line146)"></a>-<a name="(line147)"></a><a name="lower"></a>lower <font color=Red>::</font> Parser Char-<a name="(line148)"></a>lower <font color=Red>=</font> sat isLower-<a name="(line149)"></a>-<a name="(line150)"></a><a name="upper"></a>upper <font color=Red>::</font> Parser Char-<a name="(line151)"></a>upper <font color=Red>=</font> sat isUpper-<a name="(line152)"></a>-<a name="(line153)"></a><a name="letter"></a>letter <font color=Red>::</font> Parser Char-<a name="(line154)"></a>letter <font color=Red>=</font> sat isAlpha-<a name="(line155)"></a>-<a name="(line156)"></a><a name="alphanum"></a>alphanum <font color=Red>::</font> Parser Char-<a name="(line157)"></a>alphanum <font color=Red>=</font> sat isAlphaNum <font color=Cyan>+++</font> char <font color=Magenta>'_'</font>-<a name="(line158)"></a>-<a name="(line159)"></a><a name="string"></a>string <font color=Red>::</font> String <font color=Red>-></font> Parser String-<a name="(line160)"></a>string <font color=Magenta>""</font> <font color=Red>=</font> return <font color=Magenta>""</font>-<a name="(line161)"></a>string <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>char x<font color=Cyan>;</font> string xs<font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font><font color=Cyan>}</font>-<a name="(line162)"></a>-<a name="(line163)"></a><a name="ident"></a>ident <font color=Red>::</font> Parser String-<a name="(line164)"></a>ident <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> lower<font color=Cyan>;</font> xs <font color=Red><-</font> many alphanum<font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font><font color=Cyan>}</font>-<a name="(line165)"></a>-<a name="(line166)"></a><a name="nat"></a>nat <font color=Red>::</font> Parser Int-<a name="(line167)"></a>nat <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> digit<font color=Cyan>;</font> return <font color=Cyan>(</font>fromEnum x <font color=Blue>-</font> fromEnum <font color=Magenta>'0'</font><font color=Cyan>)</font><font color=Cyan>}</font> <font color=Cyan>`chainl1`</font> return op-<a name="(line168)"></a> <font color=Green><u>where</u></font>-<a name="(line169)"></a> m <font color=Cyan>`op`</font> n <font color=Red>=</font> <font color=Magenta>10</font><font color=Cyan>*</font>m <font color=Cyan>+</font> n-<a name="(line170)"></a>-<a name="(line171)"></a><a name="int"></a>int <font color=Red>::</font> Parser Int-<a name="(line172)"></a>int <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>char <font color=Magenta>'-'</font><font color=Cyan>;</font> n <font color=Red><-</font> nat<font color=Cyan>;</font> return <font color=Cyan>(</font><font color=Blue>-</font>n<font color=Cyan>)</font><font color=Cyan>}</font> <font color=Cyan>+++</font> nat-<a name="(line173)"></a>-<a name="(line174)"></a><font color=Blue>-- ------------------------------------------------------------</font>-<a name="(line175)"></a><font color=Blue>-- * Lexical combinators</font>-<a name="(line176)"></a><font color=Blue>-- ------------------------------------------------------------</font>-<a name="(line177)"></a>-<a name="(line178)"></a><a name="spaces"></a>spaces <font color=Red>::</font> Parser ()-<a name="(line179)"></a>spaces <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>many1 <font color=Cyan>(</font>sat isSpace<font color=Cyan>)</font><font color=Cyan>;</font> return ()<font color=Cyan>}</font>-<a name="(line180)"></a>-<a name="(line181)"></a><a name="comment"></a>comment <font color=Red>::</font> Parser ()-<a name="(line182)"></a><font color=Blue>--comment = do {string "--"; many (sat (\x -> x /= '\n')); return ()}</font>-<a name="(line183)"></a><font color=Blue>--comment = do </font>-<a name="(line184)"></a><font color=Blue>-- _ <- string "--"</font>-<a name="(line185)"></a><font color=Blue>-- _ <- many (sat (\x -> x /= '\n'))</font>-<a name="(line186)"></a><font color=Blue>-- return ()</font>-<a name="(line187)"></a>comment <font color=Red>=</font> <font color=Green><u>do</u></font>-<a name="(line188)"></a> bracket <font color=Cyan>(</font>string <font color=Magenta>"/*"</font><font color=Cyan>)</font> <font color=Cyan>(</font>many item<font color=Cyan>)</font> <font color=Cyan>(</font>string <font color=Magenta>"*/"</font><font color=Cyan>)</font>-<a name="(line189)"></a> return ()-<a name="(line190)"></a>-<a name="(line191)"></a><a name="junk"></a>junk <font color=Red>::</font> Parser ()-<a name="(line192)"></a>junk <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>many <font color=Cyan>(</font>spaces <font color=Cyan>+++</font> comment<font color=Cyan>)</font><font color=Cyan>;</font> return ()<font color=Cyan>}</font>-<a name="(line193)"></a>-<a name="(line194)"></a><a name="skip"></a>skip <font color=Red>::</font> Parser a <font color=Red>-></font> Parser a-<a name="(line195)"></a>skip p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>junk<font color=Cyan>;</font> p<font color=Cyan>}</font>-<a name="(line196)"></a>-<a name="(line197)"></a><a name="token"></a>token <font color=Red>::</font> Parser a <font color=Red>-></font> Parser a-<a name="(line198)"></a>token p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>v <font color=Red><-</font> p<font color=Cyan>;</font> junk<font color=Cyan>;</font> return v<font color=Cyan>}</font>-<a name="(line199)"></a>-<a name="(line200)"></a><font color=Blue>-- ------------------------------------------------------------</font>-<a name="(line201)"></a><font color=Blue>-- * Token parsers</font>-<a name="(line202)"></a><font color=Blue>-- ------------------------------------------------------------</font>-<a name="(line203)"></a>-<a name="(line204)"></a><a name="natural"></a>natural <font color=Red>::</font> Parser Int-<a name="(line205)"></a>natural <font color=Red>=</font> token nat-<a name="(line206)"></a>-<a name="(line207)"></a><a name="integer"></a>integer <font color=Red>::</font> Parser Int-<a name="(line208)"></a>integer <font color=Red>=</font> token int-<a name="(line209)"></a>-<a name="(line210)"></a><a name="symbol"></a>symbol <font color=Red>::</font> String <font color=Red>-></font> Parser String-<a name="(line211)"></a>symbol xs <font color=Red>=</font> token <font color=Cyan>(</font>string xs<font color=Cyan>)</font>-<a name="(line212)"></a>-<a name="(line213)"></a><a name="identifier"></a>identifier <font color=Red>::</font> <font color=Red>[</font>String<font color=Red>]</font> <font color=Red>-></font> Parser String-<a name="(line214)"></a>identifier ks <font color=Red>=</font> token <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> ident<font color=Cyan>;</font>-<a name="(line215)"></a> <font color=Green><u>if</u></font> not <font color=Cyan>(</font>elem x ks<font color=Cyan>)</font> <font color=Green><u>then</u></font> return x-<a name="(line216)"></a> <font color=Green><u>else</u></font> return mzero<font color=Cyan>}</font><font color=Cyan>)</font>-<a name="(line217)"></a>-<a name="(line218)"></a><font color=Blue>------------------------------------------------------------------------------</font>+<head>+<!-- Generated by HsColour, http://www.cs.york.ac.uk/fp/darcs/hscolour/ -->+<title>src/Text/ParserCombinators/HuttonMeijer.hs</title>+</head>+<body>+<pre><a name="line-1"></a><font color=Blue>-----------------------------------------------------------------------------</font>+<a name="line-2"></a><font color=Blue>-- |</font>+<a name="line-3"></a><font color=Blue>-- Module : Text.ParserCombinators.HuttonMeijer</font>+<a name="line-4"></a><font color=Blue>-- Copyright : Graham Hutton (University of Nottingham), Erik Meijer (University of Utrecht)</font>+<a name="line-5"></a><font color=Blue>-- Licence : BSD</font>+<a name="line-6"></a><font color=Blue>-- </font>+<a name="line-7"></a><font color=Blue>-- Maintainer : Malcolm Wallace <Malcolm.Wallace@cs.york.ac.uk></font>+<a name="line-8"></a><font color=Blue>-- Stability : Stable</font>+<a name="line-9"></a><font color=Blue>-- Portability : All</font>+<a name="line-10"></a><font color=Blue>--</font>+<a name="line-11"></a><font color=Blue>-- A LIBRARY OF MONADIC PARSER COMBINATORS</font>+<a name="line-12"></a><font color=Blue>-- </font>+<a name="line-13"></a><font color=Blue>-- 29th July 1996</font>+<a name="line-14"></a><font color=Blue>-- </font>+<a name="line-15"></a><font color=Blue>-- Graham Hutton Erik Meijer</font>+<a name="line-16"></a><font color=Blue>-- University of Nottingham University of Utrecht</font>+<a name="line-17"></a><font color=Blue>-- </font>+<a name="line-18"></a><font color=Blue>-- This Haskell script defines a library of parser combinators, and is</font>+<a name="line-19"></a><font color=Blue>-- taken from sections 1-6 of our article "Monadic Parser Combinators".</font>+<a name="line-20"></a><font color=Blue>-- Some changes to the library have been made in the move from Gofer</font>+<a name="line-21"></a><font color=Blue>-- to Haskell:</font>+<a name="line-22"></a><font color=Blue>-- </font>+<a name="line-23"></a><font color=Blue>-- * Do notation is used in place of monad comprehension notation;</font>+<a name="line-24"></a><font color=Blue>-- </font>+<a name="line-25"></a><font color=Blue>-- * The parser datatype is defined using "newtype", to avoid the overhead</font>+<a name="line-26"></a><font color=Blue>-- of tagging and untagging parsers with the P constructor.</font>+<a name="line-27"></a><font color=Blue>-----------------------------------------------------------------------------</font>+<a name="line-28"></a>+<a name="line-29"></a>+<a name="line-30"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>HuttonMeijer+<a name="line-31"></a> <font color=Cyan>(</font>Parser<font color=Cyan>(</font><font color=Red>..</font><font color=Cyan>)</font><font color=Cyan>,</font> item<font color=Cyan>,</font> first<font color=Cyan>,</font> papply<font color=Cyan>,</font> <font color=Cyan>(</font><font color=Cyan>+++</font><font color=Cyan>)</font><font color=Cyan>,</font> sat<font color=Cyan>,</font> <font color=Blue>{-tok,-}</font> many<font color=Cyan>,</font> many1<font color=Cyan>,</font>+<a name="line-32"></a> sepby<font color=Cyan>,</font> sepby1<font color=Cyan>,</font> chainl<font color=Cyan>,</font>+<a name="line-33"></a> chainl1<font color=Cyan>,</font> chainr<font color=Cyan>,</font> chainr1<font color=Cyan>,</font> ops<font color=Cyan>,</font> bracket<font color=Cyan>,</font> char<font color=Cyan>,</font> digit<font color=Cyan>,</font> lower<font color=Cyan>,</font> upper<font color=Cyan>,</font>+<a name="line-34"></a> letter<font color=Cyan>,</font> alphanum<font color=Cyan>,</font> string<font color=Cyan>,</font> ident<font color=Cyan>,</font> nat<font color=Cyan>,</font> int<font color=Cyan>,</font> spaces<font color=Cyan>,</font> comment<font color=Cyan>,</font> junk<font color=Cyan>,</font>+<a name="line-35"></a> skip<font color=Cyan>,</font> token<font color=Cyan>,</font> natural<font color=Cyan>,</font> integer<font color=Cyan>,</font> symbol<font color=Cyan>,</font> identifier<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-36"></a>+<a name="line-37"></a><font color=Green><u>import</u></font> Char+<a name="line-38"></a><font color=Green><u>import</u></font> Monad+<a name="line-39"></a>+<a name="line-40"></a><font color=Green><u>infixr</u></font> <font color=Magenta>5</font> <font color=Cyan>+++</font>+<a name="line-41"></a>+<a name="line-42"></a><a name="Token"></a><font color=Green><u>type</u></font> Token <font color=Red>=</font> Char+<a name="line-43"></a>+<a name="line-44"></a><font color=Blue>---------------------------------------------------------</font>+<a name="line-45"></a><font color=Blue>-- | The parser monad</font>+<a name="line-46"></a>+<a name="line-47"></a><a name="Parser"></a><font color=Green><u>newtype</u></font> Parser a <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>[</font>Token<font color=Red>]</font> <font color=Red>-></font> <font color=Red>[</font><font color=Cyan>(</font>a<font color=Cyan>,</font><font color=Red>[</font>Token<font color=Red>]</font><font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>+<a name="line-48"></a>+<a name="line-49"></a><font color=Green><u>instance</u></font> Functor Parser <font color=Green><u>where</u></font>+<a name="line-50"></a> <font color=Blue>-- map :: (a -> b) -> (Parser a -> Parser b)</font>+<a name="line-51"></a> fmap f <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp <font color=Red>-></font> <font color=Red>[</font><font color=Cyan>(</font>f v<font color=Cyan>,</font> out<font color=Cyan>)</font> <font color=Red>|</font> <font color=Cyan>(</font>v<font color=Cyan>,</font>out<font color=Cyan>)</font> <font color=Red><-</font> p inp<font color=Red>]</font><font color=Cyan>)</font>+<a name="line-52"></a>+<a name="line-53"></a><font color=Green><u>instance</u></font> Monad Parser <font color=Green><u>where</u></font>+<a name="line-54"></a> <font color=Blue>-- return :: a -> Parser a</font>+<a name="line-55"></a> return v <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp <font color=Red>-></font> <font color=Red>[</font><font color=Cyan>(</font>v<font color=Cyan>,</font>inp<font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>+<a name="line-56"></a>+<a name="line-57"></a> <font color=Blue>-- >>= :: Parser a -> (a -> Parser b) -> Parser b</font>+<a name="line-58"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>>>=</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp <font color=Red>-></font> concat <font color=Red>[</font>papply <font color=Cyan>(</font>f v<font color=Cyan>)</font> out <font color=Red>|</font> <font color=Cyan>(</font>v<font color=Cyan>,</font>out<font color=Cyan>)</font> <font color=Red><-</font> p inp<font color=Red>]</font><font color=Cyan>)</font>+<a name="line-59"></a>+<a name="line-60"></a> <font color=Blue>-- fail :: String -> Parser a</font>+<a name="line-61"></a> fail <font color=Green><u>_</u></font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font><font color=Green><u>_</u></font> <font color=Red>-></font> []<font color=Cyan>)</font>+<a name="line-62"></a>+<a name="line-63"></a><font color=Green><u>instance</u></font> MonadPlus Parser <font color=Green><u>where</u></font>+<a name="line-64"></a> <font color=Blue>-- mzero :: Parser a</font>+<a name="line-65"></a> mzero <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font><font color=Green><u>_</u></font> <font color=Red>-></font> []<font color=Cyan>)</font>+<a name="line-66"></a>+<a name="line-67"></a> <font color=Blue>-- mplus :: Parser a -> Parser a -> Parser a</font>+<a name="line-68"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`mplus`</font> <font color=Cyan>(</font>P q<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp <font color=Red>-></font> <font color=Cyan>(</font>p inp <font color=Cyan>++</font> q inp<font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-69"></a>+<a name="line-70"></a><font color=Blue>-- ------------------------------------------------------------</font>+<a name="line-71"></a><font color=Blue>-- * Other primitive parser combinators</font>+<a name="line-72"></a><font color=Blue>-- ------------------------------------------------------------</font>+<a name="line-73"></a>+<a name="line-74"></a><a name="item"></a><font color=Blue>item</font> <font color=Red>::</font> Parser Token+<a name="line-75"></a><font color=Blue>item</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp <font color=Red>-></font> <font color=Green><u>case</u></font> inp <font color=Green><u>of</u></font>+<a name="line-76"></a> [] <font color=Red>-></font> []+<a name="line-77"></a> <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font> <font color=Red>-></font> <font color=Red>[</font><font color=Cyan>(</font>x<font color=Cyan>,</font>xs<font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>+<a name="line-78"></a>+<a name="line-79"></a><a name="first"></a><font color=Blue>first</font> <font color=Red>::</font> Parser a <font color=Red>-></font> Parser a+<a name="line-80"></a><font color=Blue>first</font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp <font color=Red>-></font> <font color=Green><u>case</u></font> p inp <font color=Green><u>of</u></font>+<a name="line-81"></a> [] <font color=Red>-></font> []+<a name="line-82"></a> <font color=Cyan>(</font>x<font color=Red><b>:</b></font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> <font color=Red>[</font>x<font color=Red>]</font><font color=Cyan>)</font>+<a name="line-83"></a>+<a name="line-84"></a><a name="papply"></a><font color=Blue>papply</font> <font color=Red>::</font> Parser a <font color=Red>-></font> <font color=Red>[</font>Token<font color=Red>]</font> <font color=Red>-></font> <font color=Red>[</font><font color=Cyan>(</font>a<font color=Cyan>,</font><font color=Red>[</font>Token<font color=Red>]</font><font color=Cyan>)</font><font color=Red>]</font>+<a name="line-85"></a><font color=Blue>papply</font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> inp <font color=Red>=</font> p inp+<a name="line-86"></a>+<a name="line-87"></a><font color=Blue>-- ------------------------------------------------------------</font>+<a name="line-88"></a><font color=Blue>-- * Derived combinators</font>+<a name="line-89"></a><font color=Blue>-- ------------------------------------------------------------</font>+<a name="line-90"></a>+<a name="line-91"></a><a name="+++"></a><font color=Cyan>(</font><font color=Cyan>+++</font><font color=Cyan>)</font> <font color=Red>::</font> Parser a <font color=Red>-></font> Parser a <font color=Red>-></font> Parser a+<a name="line-92"></a><a name="p"></a><font color=Blue>p</font> <font color=Cyan>+++</font> q <font color=Red>=</font> first <font color=Cyan>(</font>p <font color=Cyan>`mplus`</font> q<font color=Cyan>)</font>+<a name="line-93"></a>+<a name="line-94"></a><a name="sat"></a><font color=Blue>sat</font> <font color=Red>::</font> <font color=Cyan>(</font>Token <font color=Red>-></font> Bool<font color=Cyan>)</font> <font color=Red>-></font> Parser Token+<a name="line-95"></a><font color=Blue>sat</font> p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> item<font color=Cyan>;</font> <font color=Green><u>if</u></font> p x <font color=Green><u>then</u></font> return x <font color=Green><u>else</u></font> mzero<font color=Cyan>}</font>+<a name="line-96"></a>+<a name="line-97"></a><font color=Blue>--tok :: Token -> Parser Token</font>+<a name="line-98"></a><font color=Blue>--tok t = do {x <- item; if t==snd x then return t else mzero}</font>+<a name="line-99"></a>+<a name="line-100"></a><a name="many"></a><font color=Blue>many</font> <font color=Red>::</font> Parser a <font color=Red>-></font> Parser <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-101"></a><font color=Blue>many</font> p <font color=Red>=</font> many1 p <font color=Cyan>+++</font> return []+<a name="line-102"></a><font color=Blue>--many p = force (many1 p +++ return [])</font>+<a name="line-103"></a>+<a name="line-104"></a><a name="many1"></a><font color=Blue>many1</font> <font color=Red>::</font> Parser a <font color=Red>-></font> Parser <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-105"></a><font color=Blue>many1</font> p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> xs <font color=Red><-</font> many p<font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font><font color=Cyan>}</font>+<a name="line-106"></a>+<a name="line-107"></a><a name="sepby"></a><font color=Blue>sepby</font> <font color=Red>::</font> Parser a <font color=Red>-></font> Parser b <font color=Red>-></font> Parser <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-108"></a><a name="sepby"></a><font color=Blue>p</font> <font color=Cyan>`sepby`</font> sep <font color=Red>=</font> <font color=Cyan>(</font>p <font color=Cyan>`sepby1`</font> sep<font color=Cyan>)</font> <font color=Cyan>+++</font> return []+<a name="line-109"></a>+<a name="line-110"></a><a name="sepby1"></a><font color=Blue>sepby1</font> <font color=Red>::</font> Parser a <font color=Red>-></font> Parser b <font color=Red>-></font> Parser <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-111"></a><a name="sepby1"></a><font color=Blue>p</font> <font color=Cyan>`sepby1`</font> sep <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> xs <font color=Red><-</font> many <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>sep<font color=Cyan>;</font> p<font color=Cyan>}</font><font color=Cyan>)</font><font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font><font color=Cyan>}</font>+<a name="line-112"></a>+<a name="line-113"></a><a name="chainl"></a><font color=Blue>chainl</font> <font color=Red>::</font> Parser a <font color=Red>-></font> Parser <font color=Cyan>(</font>a <font color=Red>-></font> a <font color=Red>-></font> a<font color=Cyan>)</font> <font color=Red>-></font> a <font color=Red>-></font> Parser a+<a name="line-114"></a><font color=Blue>chainl</font> p op v <font color=Red>=</font> <font color=Cyan>(</font>p <font color=Cyan>`chainl1`</font> op<font color=Cyan>)</font> <font color=Cyan>+++</font> return v+<a name="line-115"></a>+<a name="line-116"></a><a name="chainl1"></a><font color=Blue>chainl1</font> <font color=Red>::</font> Parser a <font color=Red>-></font> Parser <font color=Cyan>(</font>a <font color=Red>-></font> a <font color=Red>-></font> a<font color=Cyan>)</font> <font color=Red>-></font> Parser a+<a name="line-117"></a><a name="chainl1"></a><font color=Blue>p</font> <font color=Cyan>`chainl1`</font> op <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> rest x<font color=Cyan>}</font>+<a name="line-118"></a> <font color=Green><u>where</u></font>+<a name="line-119"></a> rest x <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>f <font color=Red><-</font> op<font color=Cyan>;</font> y <font color=Red><-</font> p<font color=Cyan>;</font> rest <font color=Cyan>(</font>f x y<font color=Cyan>)</font><font color=Cyan>}</font>+<a name="line-120"></a> <font color=Cyan>+++</font> return x+<a name="line-121"></a>+<a name="line-122"></a><a name="chainr"></a><font color=Blue>chainr</font> <font color=Red>::</font> Parser a <font color=Red>-></font> Parser <font color=Cyan>(</font>a <font color=Red>-></font> a <font color=Red>-></font> a<font color=Cyan>)</font> <font color=Red>-></font> a <font color=Red>-></font> Parser a+<a name="line-123"></a><font color=Blue>chainr</font> p op v <font color=Red>=</font> <font color=Cyan>(</font>p <font color=Cyan>`chainr1`</font> op<font color=Cyan>)</font> <font color=Cyan>+++</font> return v+<a name="line-124"></a>+<a name="line-125"></a><a name="chainr1"></a><font color=Blue>chainr1</font> <font color=Red>::</font> Parser a <font color=Red>-></font> Parser <font color=Cyan>(</font>a <font color=Red>-></font> a <font color=Red>-></font> a<font color=Cyan>)</font> <font color=Red>-></font> Parser a+<a name="line-126"></a><a name="chainr1"></a><font color=Blue>p</font> <font color=Cyan>`chainr1`</font> op <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> rest x<font color=Cyan>}</font>+<a name="line-127"></a> <font color=Green><u>where</u></font>+<a name="line-128"></a> rest x <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>f <font color=Red><-</font> op<font color=Cyan>;</font> y <font color=Red><-</font> p <font color=Cyan>`chainr1`</font> op<font color=Cyan>;</font> return <font color=Cyan>(</font>f x y<font color=Cyan>)</font><font color=Cyan>}</font>+<a name="line-129"></a> <font color=Cyan>+++</font> return x+<a name="line-130"></a>+<a name="line-131"></a><a name="ops"></a><font color=Blue>ops</font> <font color=Red>::</font> <font color=Red>[</font><font color=Cyan>(</font>Parser a<font color=Cyan>,</font> b<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> Parser b+<a name="line-132"></a><font color=Blue>ops</font> xs <font color=Red>=</font> foldr1 <font color=Cyan>(</font><font color=Cyan>+++</font><font color=Cyan>)</font> <font color=Red>[</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>p<font color=Cyan>;</font> return op<font color=Cyan>}</font> <font color=Red>|</font> <font color=Cyan>(</font>p<font color=Cyan>,</font>op<font color=Cyan>)</font> <font color=Red><-</font> xs<font color=Red>]</font>+<a name="line-133"></a>+<a name="line-134"></a><a name="bracket"></a><font color=Blue>bracket</font> <font color=Red>::</font> Parser a <font color=Red>-></font> Parser b <font color=Red>-></font> Parser c <font color=Red>-></font> Parser b+<a name="line-135"></a><font color=Blue>bracket</font> open p close <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>open<font color=Cyan>;</font> x <font color=Red><-</font> p<font color=Cyan>;</font> close<font color=Cyan>;</font> return x<font color=Cyan>}</font>+<a name="line-136"></a>+<a name="line-137"></a><font color=Blue>-- ------------------------------------------------------------</font>+<a name="line-138"></a><font color=Blue>-- * Useful parsers</font>+<a name="line-139"></a><font color=Blue>-- ------------------------------------------------------------</font>+<a name="line-140"></a>+<a name="line-141"></a><a name="char"></a><font color=Blue>char</font> <font color=Red>::</font> Char <font color=Red>-></font> Parser Char+<a name="line-142"></a><font color=Blue>char</font> x <font color=Red>=</font> sat <font color=Cyan>(</font><font color=Red>\</font>y <font color=Red>-></font> x <font color=Cyan>==</font> y<font color=Cyan>)</font>+<a name="line-143"></a>+<a name="line-144"></a><a name="digit"></a><font color=Blue>digit</font> <font color=Red>::</font> Parser Char+<a name="line-145"></a><font color=Blue>digit</font> <font color=Red>=</font> sat isDigit+<a name="line-146"></a>+<a name="line-147"></a><a name="lower"></a><font color=Blue>lower</font> <font color=Red>::</font> Parser Char+<a name="line-148"></a><font color=Blue>lower</font> <font color=Red>=</font> sat isLower+<a name="line-149"></a>+<a name="line-150"></a><a name="upper"></a><font color=Blue>upper</font> <font color=Red>::</font> Parser Char+<a name="line-151"></a><font color=Blue>upper</font> <font color=Red>=</font> sat isUpper+<a name="line-152"></a>+<a name="line-153"></a><a name="letter"></a><font color=Blue>letter</font> <font color=Red>::</font> Parser Char+<a name="line-154"></a><font color=Blue>letter</font> <font color=Red>=</font> sat isAlpha+<a name="line-155"></a>+<a name="line-156"></a><a name="alphanum"></a><font color=Blue>alphanum</font> <font color=Red>::</font> Parser Char+<a name="line-157"></a><font color=Blue>alphanum</font> <font color=Red>=</font> sat isAlphaNum <font color=Cyan>+++</font> char <font color=Magenta>'_'</font>+<a name="line-158"></a>+<a name="line-159"></a><a name="string"></a><font color=Blue>string</font> <font color=Red>::</font> String <font color=Red>-></font> Parser String+<a name="line-160"></a><font color=Blue>string</font> <font color=Magenta>""</font> <font color=Red>=</font> return <font color=Magenta>""</font>+<a name="line-161"></a><font color=Blue>string</font> <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>char x<font color=Cyan>;</font> string xs<font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font><font color=Cyan>}</font>+<a name="line-162"></a>+<a name="line-163"></a><a name="ident"></a><font color=Blue>ident</font> <font color=Red>::</font> Parser String+<a name="line-164"></a><font color=Blue>ident</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> lower<font color=Cyan>;</font> xs <font color=Red><-</font> many alphanum<font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font><font color=Cyan>}</font>+<a name="line-165"></a>+<a name="line-166"></a><a name="nat"></a><font color=Blue>nat</font> <font color=Red>::</font> Parser Int+<a name="line-167"></a><font color=Blue>nat</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> digit<font color=Cyan>;</font> return <font color=Cyan>(</font>fromEnum x <font color=Blue>-</font> fromEnum <font color=Magenta>'0'</font><font color=Cyan>)</font><font color=Cyan>}</font> <font color=Cyan>`chainl1`</font> return op+<a name="line-168"></a> <font color=Green><u>where</u></font>+<a name="line-169"></a> m <font color=Cyan>`op`</font> n <font color=Red>=</font> <font color=Magenta>10</font><font color=Cyan>*</font>m <font color=Cyan>+</font> n+<a name="line-170"></a>+<a name="line-171"></a><a name="int"></a><font color=Blue>int</font> <font color=Red>::</font> Parser Int+<a name="line-172"></a><font color=Blue>int</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>char <font color=Magenta>'-'</font><font color=Cyan>;</font> n <font color=Red><-</font> nat<font color=Cyan>;</font> return <font color=Cyan>(</font><font color=Blue>-</font>n<font color=Cyan>)</font><font color=Cyan>}</font> <font color=Cyan>+++</font> nat+<a name="line-173"></a>+<a name="line-174"></a><font color=Blue>-- ------------------------------------------------------------</font>+<a name="line-175"></a><font color=Blue>-- * Lexical combinators</font>+<a name="line-176"></a><font color=Blue>-- ------------------------------------------------------------</font>+<a name="line-177"></a>+<a name="line-178"></a><a name="spaces"></a><font color=Blue>spaces</font> <font color=Red>::</font> Parser ()+<a name="line-179"></a><font color=Blue>spaces</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>many1 <font color=Cyan>(</font>sat isSpace<font color=Cyan>)</font><font color=Cyan>;</font> return ()<font color=Cyan>}</font>+<a name="line-180"></a>+<a name="line-181"></a><a name="comment"></a><font color=Blue>comment</font> <font color=Red>::</font> Parser ()+<a name="line-182"></a><font color=Blue>--comment = do {string "--"; many (sat (\x -> x /= '\n')); return ()}</font>+<a name="line-183"></a><font color=Blue>--comment = do </font>+<a name="line-184"></a><font color=Blue>-- _ <- string "--"</font>+<a name="line-185"></a><font color=Blue>-- _ <- many (sat (\x -> x /= '\n'))</font>+<a name="line-186"></a><font color=Blue>-- return ()</font>+<a name="line-187"></a><font color=Blue>comment</font> <font color=Red>=</font> <font color=Green><u>do</u></font>+<a name="line-188"></a> bracket <font color=Cyan>(</font>string <font color=Magenta>"/*"</font><font color=Cyan>)</font> <font color=Cyan>(</font>many item<font color=Cyan>)</font> <font color=Cyan>(</font>string <font color=Magenta>"*/"</font><font color=Cyan>)</font>+<a name="line-189"></a> return ()+<a name="line-190"></a>+<a name="line-191"></a><a name="junk"></a><font color=Blue>junk</font> <font color=Red>::</font> Parser ()+<a name="line-192"></a><font color=Blue>junk</font> <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>many <font color=Cyan>(</font>spaces <font color=Cyan>+++</font> comment<font color=Cyan>)</font><font color=Cyan>;</font> return ()<font color=Cyan>}</font>+<a name="line-193"></a>+<a name="line-194"></a><a name="skip"></a><font color=Blue>skip</font> <font color=Red>::</font> Parser a <font color=Red>-></font> Parser a+<a name="line-195"></a><font color=Blue>skip</font> p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>junk<font color=Cyan>;</font> p<font color=Cyan>}</font>+<a name="line-196"></a>+<a name="line-197"></a><a name="token"></a><font color=Blue>token</font> <font color=Red>::</font> Parser a <font color=Red>-></font> Parser a+<a name="line-198"></a><font color=Blue>token</font> p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>v <font color=Red><-</font> p<font color=Cyan>;</font> junk<font color=Cyan>;</font> return v<font color=Cyan>}</font>+<a name="line-199"></a>+<a name="line-200"></a><font color=Blue>-- ------------------------------------------------------------</font>+<a name="line-201"></a><font color=Blue>-- * Token parsers</font>+<a name="line-202"></a><font color=Blue>-- ------------------------------------------------------------</font>+<a name="line-203"></a>+<a name="line-204"></a><a name="natural"></a><font color=Blue>natural</font> <font color=Red>::</font> Parser Int+<a name="line-205"></a><font color=Blue>natural</font> <font color=Red>=</font> token nat+<a name="line-206"></a>+<a name="line-207"></a><a name="integer"></a><font color=Blue>integer</font> <font color=Red>::</font> Parser Int+<a name="line-208"></a><font color=Blue>integer</font> <font color=Red>=</font> token int+<a name="line-209"></a>+<a name="line-210"></a><a name="symbol"></a><font color=Blue>symbol</font> <font color=Red>::</font> String <font color=Red>-></font> Parser String+<a name="line-211"></a><font color=Blue>symbol</font> xs <font color=Red>=</font> token <font color=Cyan>(</font>string xs<font color=Cyan>)</font>+<a name="line-212"></a>+<a name="line-213"></a><a name="identifier"></a><font color=Blue>identifier</font> <font color=Red>::</font> <font color=Red>[</font>String<font color=Red>]</font> <font color=Red>-></font> Parser String+<a name="line-214"></a><font color=Blue>identifier</font> ks <font color=Red>=</font> token <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> ident<font color=Cyan>;</font>+<a name="line-215"></a> <font color=Green><u>if</u></font> not <font color=Cyan>(</font>elem x ks<font color=Cyan>)</font> <font color=Green><u>then</u></font> return x+<a name="line-216"></a> <font color=Green><u>else</u></font> return mzero<font color=Cyan>}</font><font color=Cyan>)</font>+<a name="line-217"></a>+<a name="line-218"></a><font color=Blue>------------------------------------------------------------------------------</font> </pre>+</body> </html>
docs/haddock/src/Text/ParserCombinators/HuttonMeijerWallace.html view
@@ -1,301 +1,307 @@ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"> <html>-<pre><a name="(line1)"></a><font color=Blue>{------------------------------------------------------------------------------<a name="(line2)"></a>-<a name="(line3)"></a> A LIBRARY OF MONADIC PARSER COMBINATORS-<a name="(line4)"></a>-<a name="(line5)"></a> 29th July 1996-<a name="(line6)"></a>-<a name="(line7)"></a> Graham Hutton Erik Meijer-<a name="(line8)"></a> University of Nottingham University of Utrecht-<a name="(line9)"></a>-<a name="(line10)"></a>This Haskell 1.3 script defines a library of parser combinators, and is taken-<a name="(line11)"></a>from sections 1-6 of our article "Monadic Parser Combinators". Some changes-<a name="(line12)"></a>to the library have been made in the move from Gofer to Haskell:-<a name="(line13)"></a>-<a name="(line14)"></a> * Do notation is used in place of monad comprehension notation;-<a name="(line15)"></a>-<a name="(line16)"></a> * The parser datatype is defined using "newtype", to avoid the overhead-<a name="(line17)"></a> of tagging and untagging parsers with the P constructor.-<a name="(line18)"></a>-<a name="(line19)"></a>-------------------------------------------------------------------------------<a name="(line20)"></a>** Extended to allow a symbol table/state to be threaded through the monad.-<a name="(line21)"></a>** Extended to allow a parameterised token type, rather than just strings.-<a name="(line22)"></a>** Extended to allow error-reporting.-<a name="(line23)"></a>-<a name="(line24)"></a>(Extensions: 1998-2000 Malcolm.Wallace@cs.york.ac.uk)-<a name="(line25)"></a>(More extensions: 2004 gk-haskell@ninebynine.org)-<a name="(line26)"></a>-<a name="(line27)"></a>------------------------------------------------------------------------------}</font>-<a name="(line28)"></a>-<a name="(line29)"></a><font color=Blue>-- | This library of monadic parser combinators is based on the ones</font>-<a name="(line30)"></a><font color=Blue>-- defined by Graham Hutton and Erik Meijer. It has been extended by</font>-<a name="(line31)"></a><font color=Blue>-- Malcolm Wallace to use an abstract token type (no longer just a</font>-<a name="(line32)"></a><font color=Blue>-- string) as input, and to incorporate state in the monad, useful</font>-<a name="(line33)"></a><font color=Blue>-- for symbol tables, macros, and so on. Basic facilities for error</font>-<a name="(line34)"></a><font color=Blue>-- reporting have also been added, and later extended by Graham Klyne</font>-<a name="(line35)"></a><font color=Blue>-- to return the errors through an @Either@ type, rather than just</font>-<a name="(line36)"></a><font color=Blue>-- calling @error@.</font>-<a name="(line37)"></a>-<a name="(line38)"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>HuttonMeijerWallace-<a name="(line39)"></a> <font color=Cyan>(</font>-<a name="(line40)"></a> <font color=Blue>-- * The parser monad</font>-<a name="(line41)"></a> Parser<font color=Cyan>(</font><font color=Red>..</font><font color=Cyan>)</font>-<a name="(line42)"></a> <font color=Blue>-- * Primitive parser combinators</font>-<a name="(line43)"></a> <font color=Cyan>,</font> item<font color=Cyan>,</font> eof<font color=Cyan>,</font> papply<font color=Cyan>,</font> papply'-<a name="(line44)"></a> <font color=Blue>-- * Derived combinators</font>-<a name="(line45)"></a> <font color=Cyan>,</font> <font color=Cyan>(</font><font color=Cyan>+++</font><font color=Cyan>)</font><font color=Cyan>,</font> <font color=Blue>{-sat,-}</font> tok<font color=Cyan>,</font> nottok<font color=Cyan>,</font> many<font color=Cyan>,</font> many1-<a name="(line46)"></a> <font color=Cyan>,</font> sepby<font color=Cyan>,</font> sepby1<font color=Cyan>,</font> chainl<font color=Cyan>,</font> chainl1<font color=Cyan>,</font> chainr<font color=Cyan>,</font> chainr1<font color=Cyan>,</font> ops<font color=Cyan>,</font> bracket-<a name="(line47)"></a> <font color=Cyan>,</font> toEOF-<a name="(line48)"></a> <font color=Blue>-- * Error handling</font>-<a name="(line49)"></a> <font color=Cyan>,</font> elserror-<a name="(line50)"></a> <font color=Blue>-- * State handling</font>-<a name="(line51)"></a> <font color=Cyan>,</font> stupd<font color=Cyan>,</font> stquery<font color=Cyan>,</font> stget-<a name="(line52)"></a> <font color=Blue>-- * Re-parsing</font>-<a name="(line53)"></a> <font color=Cyan>,</font> reparse-<a name="(line54)"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line55)"></a>-<a name="(line56)"></a><font color=Green><u>import</u></font> Char-<a name="(line57)"></a><font color=Green><u>import</u></font> Monad-<a name="(line58)"></a>-<a name="(line59)"></a><font color=Green><u>infixr</u></font> <font color=Magenta>5</font> <font color=Cyan>+++</font>-<a name="(line60)"></a>-<a name="(line61)"></a><font color=Blue>--- The parser monad ---------------------------------------------------------</font>-<a name="(line62)"></a>-<a name="(line63)"></a><a name="ParseResult"></a><font color=Green><u>type</u></font> ParseResult s t e a <font color=Red>=</font> Either e <font color=Red>[</font><font color=Cyan>(</font>a<font color=Cyan>,</font>s<font color=Cyan>,</font><font color=Red>[</font>Either e t<font color=Red>]</font><font color=Cyan>)</font><font color=Red>]</font>-<a name="(line64)"></a>-<a name="(line65)"></a><a name="Parser"></a><font color=Green><u>newtype</u></font> Parser s t e a <font color=Red>=</font> P <font color=Cyan>(</font> s <font color=Red>-></font> <font color=Red>[</font>Either e t<font color=Red>]</font> <font color=Red>-></font> ParseResult s t e a <font color=Cyan>)</font>-<a name="(line66)"></a> <font color=Blue>-- ^ The parser type is parametrised on the types of the state @s@,</font>-<a name="(line67)"></a> <font color=Blue>-- the input tokens @t@, error-type @e@, and the result value @a@.</font>-<a name="(line68)"></a> <font color=Blue>-- The state and remaining input are threaded through the monad.</font>-<a name="(line69)"></a>-<a name="(line70)"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Parser s t e<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line71)"></a> <font color=Blue>-- fmap :: (a -> b) -> (Parser s t e a -> Parser s t e b)</font>-<a name="(line72)"></a> fmap f <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> <font color=Green><u>case</u></font> p st inp <font color=Green><u>of</u></font>-<a name="(line73)"></a> Right res <font color=Red>-></font> Right <font color=Red>[</font><font color=Cyan>(</font>f v<font color=Cyan>,</font> s<font color=Cyan>,</font> out<font color=Cyan>)</font> <font color=Red>|</font> <font color=Cyan>(</font>v<font color=Cyan>,</font>s<font color=Cyan>,</font>out<font color=Cyan>)</font> <font color=Red><-</font> res<font color=Red>]</font>-<a name="(line74)"></a> Left err <font color=Red>-></font> Left err-<a name="(line75)"></a> <font color=Cyan>)</font>-<a name="(line76)"></a>-<a name="(line77)"></a><font color=Green><u>instance</u></font> Monad <font color=Cyan>(</font>Parser s t e<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line78)"></a> <font color=Blue>-- return :: a -> Parser s t e a</font>-<a name="(line79)"></a> return v <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> Right <font color=Red>[</font><font color=Cyan>(</font>v<font color=Cyan>,</font>st<font color=Cyan>,</font>inp<font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>-<a name="(line80)"></a> <font color=Blue>-- >>= :: Parser s t e a -> (a -> Parser s t e b) -> Parser s t e b</font>-<a name="(line81)"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>>>=</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> <font color=Green><u>case</u></font> p st inp <font color=Green><u>of</u></font>-<a name="(line82)"></a> Right res <font color=Red>-></font> foldr joinresults <font color=Cyan>(</font>Right []<font color=Cyan>)</font>-<a name="(line83)"></a> <font color=Red>[</font> papply' <font color=Cyan>(</font>f v<font color=Cyan>)</font> s out <font color=Red>|</font> <font color=Cyan>(</font>v<font color=Cyan>,</font>s<font color=Cyan>,</font>out<font color=Cyan>)</font> <font color=Red><-</font> res <font color=Red>]</font>-<a name="(line84)"></a> Left err <font color=Red>-></font> Left err-<a name="(line85)"></a> <font color=Cyan>)</font>-<a name="(line86)"></a> <font color=Blue>-- fail :: String -> Parser s t e a</font>-<a name="(line87)"></a> fail err <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> Right []<font color=Cyan>)</font>-<a name="(line88)"></a> <font color=Blue>-- I know it's counterintuitive, but we want no-parse, not an error.</font>-<a name="(line89)"></a>-<a name="(line90)"></a><font color=Green><u>instance</u></font> MonadPlus <font color=Cyan>(</font>Parser s t e<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line91)"></a> <font color=Blue>-- mzero :: Parser s t e a</font>-<a name="(line92)"></a> mzero <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> Right []<font color=Cyan>)</font>-<a name="(line93)"></a> <font color=Blue>-- mplus :: Parser s t e a -> Parser s t e a -> Parser s t e a</font>-<a name="(line94)"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`mplus`</font> <font color=Cyan>(</font>P q<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> joinresults <font color=Cyan>(</font>p st inp<font color=Cyan>)</font> <font color=Cyan>(</font>q st inp<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line95)"></a>-<a name="(line96)"></a><a name="joinresults"></a><font color=Blue>-- joinresults ensures that explicitly raised errors are dominant,</font>-<a name="(line97)"></a><font color=Blue>-- provided no parse has yet been found. The commented out code is</font>-<a name="(line98)"></a><font color=Blue>-- a slightly stricter specification of the real code.</font>-<a name="(line99)"></a>joinresults <font color=Red>::</font> ParseResult s t e a <font color=Red>-></font> ParseResult s t e a <font color=Red>-></font> ParseResult s t e a-<a name="(line100)"></a><font color=Blue>{--<a name="(line101)"></a>joinresults (Left p) (Left q) = Left p-<a name="(line102)"></a>joinresults (Left p) (Right _) = Left p-<a name="(line103)"></a>joinresults (Right []) (Left q) = Left q-<a name="(line104)"></a>joinresults (Right p) (Left q) = Right p-<a name="(line105)"></a>joinresults (Right p) (Right q) = Right (p++q)-<a name="(line106)"></a>-}</font>-<a name="(line107)"></a>joinresults <font color=Cyan>(</font>Left p<font color=Cyan>)</font> q <font color=Red>=</font> Left p-<a name="(line108)"></a>joinresults <font color=Cyan>(</font>Right []<font color=Cyan>)</font> q <font color=Red>=</font> q-<a name="(line109)"></a>joinresults <font color=Cyan>(</font>Right p<font color=Cyan>)</font> q <font color=Red>=</font> Right <font color=Cyan>(</font>p<font color=Cyan>++</font> <font color=Green><u>case</u></font> q <font color=Green><u>of</u></font> Left <font color=Green><u>_</u></font> <font color=Red>-></font> []-<a name="(line110)"></a> Right r <font color=Red>-></font> r<font color=Cyan>)</font>-<a name="(line111)"></a>-<a name="(line112)"></a>-<a name="(line113)"></a><font color=Blue>--- Primitive parser combinators ---------------------------------------------</font>-<a name="(line114)"></a>-<a name="(line115)"></a><a name="item"></a><font color=Blue>-- | Deliver the first remaining token.</font>-<a name="(line116)"></a>item <font color=Red>::</font> Parser s t e t-<a name="(line117)"></a>item <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> <font color=Green><u>case</u></font> inp <font color=Green><u>of</u></font>-<a name="(line118)"></a> [] <font color=Red>-></font> Right []-<a name="(line119)"></a> <font color=Cyan>(</font>Left e<font color=Red><b>:</b></font> <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> Left e-<a name="(line120)"></a> <font color=Cyan>(</font>Right x<font color=Red><b>:</b></font> xs<font color=Cyan>)</font> <font color=Red>-></font> Right <font color=Red>[</font><font color=Cyan>(</font>x<font color=Cyan>,</font>st<font color=Cyan>,</font>xs<font color=Cyan>)</font><font color=Red>]</font>-<a name="(line121)"></a> <font color=Cyan>)</font>-<a name="(line122)"></a>-<a name="(line123)"></a><a name="eof"></a><font color=Blue>-- | Fail if end of input is not reached</font>-<a name="(line124)"></a>eof <font color=Red>::</font> Show p <font color=Red>=></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> String ()-<a name="(line125)"></a>eof <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> <font color=Green><u>case</u></font> inp <font color=Green><u>of</u></font>-<a name="(line126)"></a> [] <font color=Red>-></font> Right <font color=Red>[</font><font color=Cyan>(</font>()<font color=Cyan>,</font>st<font color=Cyan>,</font>[]<font color=Cyan>)</font><font color=Red>]</font>-<a name="(line127)"></a> <font color=Cyan>(</font>Left e<font color=Red><b>:</b></font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> Left e-<a name="(line128)"></a> <font color=Cyan>(</font>Right <font color=Cyan>(</font>p<font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>)</font><font color=Red><b>:</b></font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> Left <font color=Cyan>(</font><font color=Magenta>"End of input expected at "</font>-<a name="(line129)"></a> <font color=Cyan>++</font>show p<font color=Cyan>++</font><font color=Magenta>"\n but found text"</font><font color=Cyan>)</font>-<a name="(line130)"></a> <font color=Cyan>)</font>-<a name="(line131)"></a>-<a name="(line132)"></a><font color=Blue>{--<a name="(line133)"></a>-- | Ensure the value delivered by the parser is evaluated to WHNF.-<a name="(line134)"></a>force :: Parser s t e a -> Parser s t e a-<a name="(line135)"></a>force (P p) = P (\st inp -> let Right xs = p st inp-<a name="(line136)"></a> h = head xs in-<a name="(line137)"></a> h `seq` Right (h: tail xs)-<a name="(line138)"></a> )-<a name="(line139)"></a>-- [[[GK]]] ^^^^^^-<a name="(line140)"></a>-- WHNF = Weak Head Normal Form, meaning that it has no top-level redex.-<a name="(line141)"></a>-- In this case, I think that means that the first element of the list-<a name="(line142)"></a>-- is fully evaluated.-<a name="(line143)"></a>---<a name="(line144)"></a>-- NOTE: the original form of this function fails if there is no parse-<a name="(line145)"></a>-- result for p st inp (head xs fails if xs is null), so the modified-<a name="(line146)"></a>-- form can assume a Right value only.-<a name="(line147)"></a>---<a name="(line148)"></a>-- Why is this needed?-<a name="(line149)"></a>-- It's not exported, and the only use of this I see is commented out.-<a name="(line150)"></a>----------------------------------------<a name="(line151)"></a>-}</font>-<a name="(line152)"></a>-<a name="(line153)"></a>-<a name="(line154)"></a><a name="first"></a><font color=Blue>-- | Deliver the first parse result only, eliminating any backtracking.</font>-<a name="(line155)"></a>first <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e a-<a name="(line156)"></a>first <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> <font color=Green><u>case</u></font> p st inp <font color=Green><u>of</u></font>-<a name="(line157)"></a> Right <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font> <font color=Red>-></font> Right <font color=Red>[</font>x<font color=Red>]</font>-<a name="(line158)"></a> otherwise <font color=Red>-></font> otherwise-<a name="(line159)"></a> <font color=Cyan>)</font>-<a name="(line160)"></a>-<a name="(line161)"></a><a name="papply"></a><font color=Blue>-- | Apply the parser to some real input, given an initial state value.</font>-<a name="(line162)"></a><font color=Blue>-- If the parser fails, raise 'error' to halt the program.</font>-<a name="(line163)"></a><font color=Blue>-- (This is the original exported behaviour - to allow the caller to</font>-<a name="(line164)"></a><font color=Blue>-- deal with the error differently, see @papply'@.)</font>-<a name="(line165)"></a>papply <font color=Red>::</font> Parser s t String a <font color=Red>-></font> s <font color=Red>-></font> <font color=Red>[</font>Either String t<font color=Red>]</font>-<a name="(line166)"></a> <font color=Red>-></font> <font color=Red>[</font><font color=Cyan>(</font>a<font color=Cyan>,</font>s<font color=Cyan>,</font><font color=Red>[</font>Either String t<font color=Red>]</font><font color=Cyan>)</font><font color=Red>]</font>-<a name="(line167)"></a>papply <font color=Cyan>(</font>P p<font color=Cyan>)</font> st inp <font color=Red>=</font> either error id <font color=Cyan>(</font>p st inp<font color=Cyan>)</font>-<a name="(line168)"></a>-<a name="(line169)"></a><a name="papply'"></a><font color=Blue>-- | Apply the parser to some real input, given an initial state value.</font>-<a name="(line170)"></a><font color=Blue>-- If the parser fails, return a diagnostic message to the caller.</font>-<a name="(line171)"></a>papply' <font color=Red>::</font> Parser s t e a <font color=Red>-></font> s <font color=Red>-></font> <font color=Red>[</font>Either e t<font color=Red>]</font>-<a name="(line172)"></a> <font color=Red>-></font> Either e <font color=Red>[</font><font color=Cyan>(</font>a<font color=Cyan>,</font>s<font color=Cyan>,</font><font color=Red>[</font>Either e t<font color=Red>]</font><font color=Cyan>)</font><font color=Red>]</font>-<a name="(line173)"></a>papply' <font color=Cyan>(</font>P p<font color=Cyan>)</font> st inp <font color=Red>=</font> p st inp-<a name="(line174)"></a>-<a name="(line175)"></a><font color=Blue>--- Derived combinators ------------------------------------------------------</font>-<a name="(line176)"></a>-<a name="(line177)"></a><a name="+++"></a><font color=Blue>-- | A choice between parsers. Keep only the first success.</font>-<a name="(line178)"></a><font color=Cyan>(</font><font color=Cyan>+++</font><font color=Cyan>)</font> <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e a <font color=Red>-></font> Parser s t e a-<a name="(line179)"></a><a name="p"></a>p <font color=Cyan>+++</font> q <font color=Red>=</font> first <font color=Cyan>(</font>p <font color=Cyan>`mplus`</font> q<font color=Cyan>)</font>-<a name="(line180)"></a>-<a name="(line181)"></a><a name="sat"></a><font color=Blue>-- | Deliver the first token if it satisfies a predicate.</font>-<a name="(line182)"></a>sat <font color=Red>::</font> <font color=Cyan>(</font>t <font color=Red>-></font> Bool<font color=Cyan>)</font> <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> e t-<a name="(line183)"></a>sat p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>x<font color=Cyan>)</font> <font color=Red><-</font> item<font color=Cyan>;</font> <font color=Green><u>if</u></font> p x <font color=Green><u>then</u></font> return x <font color=Green><u>else</u></font> mzero<font color=Cyan>}</font>-<a name="(line184)"></a>-<a name="(line185)"></a><a name="tok"></a><font color=Blue>-- | Deliver the first token if it equals the argument.</font>-<a name="(line186)"></a>tok <font color=Red>::</font> Eq t <font color=Red>=></font> t <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> e t-<a name="(line187)"></a>tok t <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>x<font color=Cyan>)</font> <font color=Red><-</font> item<font color=Cyan>;</font> <font color=Green><u>if</u></font> x<font color=Cyan>==</font>t <font color=Green><u>then</u></font> return t <font color=Green><u>else</u></font> mzero<font color=Cyan>}</font>-<a name="(line188)"></a>-<a name="(line189)"></a><a name="nottok"></a><font color=Blue>-- | Deliver the first token if it does not equal the argument.</font>-<a name="(line190)"></a>nottok <font color=Red>::</font> Eq t <font color=Red>=></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> e t-<a name="(line191)"></a>nottok ts <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>x<font color=Cyan>)</font> <font color=Red><-</font> item<font color=Cyan>;</font> <font color=Green><u>if</u></font> x <font color=Cyan>`notElem`</font> ts <font color=Green><u>then</u></font> return x-<a name="(line192)"></a> <font color=Green><u>else</u></font> mzero<font color=Cyan>}</font>-<a name="(line193)"></a>-<a name="(line194)"></a><a name="many"></a><font color=Blue>-- | Deliver zero or more values of @a@.</font>-<a name="(line195)"></a>many <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line196)"></a>many p <font color=Red>=</font> many1 p <font color=Cyan>+++</font> return []-<a name="(line197)"></a><font color=Blue>--many p = force (many1 p +++ return [])</font>-<a name="(line198)"></a>-<a name="(line199)"></a><a name="many1"></a><font color=Blue>-- | Deliver one or more values of @a@.</font>-<a name="(line200)"></a>many1 <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line201)"></a>many1 p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> xs <font color=Red><-</font> many p<font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font><font color=Cyan>}</font>-<a name="(line202)"></a>-<a name="(line203)"></a><a name="sepby"></a><font color=Blue>-- | Deliver zero or more values of @a@ separated by @b@'s.</font>-<a name="(line204)"></a>sepby <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e b <font color=Red>-></font> Parser s t e <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line205)"></a><a name="sepby"></a>p <font color=Cyan>`sepby`</font> sep <font color=Red>=</font> <font color=Cyan>(</font>p <font color=Cyan>`sepby1`</font> sep<font color=Cyan>)</font> <font color=Cyan>+++</font> return []-<a name="(line206)"></a>-<a name="(line207)"></a><a name="sepby1"></a><font color=Blue>-- | Deliver one or more values of @a@ separated by @b@'s.</font>-<a name="(line208)"></a>sepby1 <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e b <font color=Red>-></font> Parser s t e <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line209)"></a><a name="sepby1"></a>p <font color=Cyan>`sepby1`</font> sep <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> xs <font color=Red><-</font> many <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>sep<font color=Cyan>;</font> p<font color=Cyan>}</font><font color=Cyan>)</font><font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font><font color=Cyan>}</font>-<a name="(line210)"></a>-<a name="(line211)"></a><a name="chainl"></a>chainl <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e <font color=Cyan>(</font>a<font color=Red>-></font>a<font color=Red>-></font>a<font color=Cyan>)</font> <font color=Red>-></font> a-<a name="(line212)"></a> <font color=Red>-></font> Parser s t e a-<a name="(line213)"></a>chainl p op v <font color=Red>=</font> <font color=Cyan>(</font>p <font color=Cyan>`chainl1`</font> op<font color=Cyan>)</font> <font color=Cyan>+++</font> return v-<a name="(line214)"></a>-<a name="(line215)"></a><a name="chainl1"></a>chainl1 <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e <font color=Cyan>(</font>a<font color=Red>-></font>a<font color=Red>-></font>a<font color=Cyan>)</font> <font color=Red>-></font> Parser s t e a-<a name="(line216)"></a><a name="chainl1"></a>p <font color=Cyan>`chainl1`</font> op <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> rest x<font color=Cyan>}</font>-<a name="(line217)"></a> <font color=Green><u>where</u></font>-<a name="(line218)"></a> rest x <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>f <font color=Red><-</font> op<font color=Cyan>;</font> y <font color=Red><-</font> p<font color=Cyan>;</font> rest <font color=Cyan>(</font>f x y<font color=Cyan>)</font><font color=Cyan>}</font>-<a name="(line219)"></a> <font color=Cyan>+++</font> return x-<a name="(line220)"></a>-<a name="(line221)"></a><a name="chainr"></a>chainr <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e <font color=Cyan>(</font>a<font color=Red>-></font>a<font color=Red>-></font>a<font color=Cyan>)</font> <font color=Red>-></font> a-<a name="(line222)"></a> <font color=Red>-></font> Parser s t e a-<a name="(line223)"></a>chainr p op v <font color=Red>=</font> <font color=Cyan>(</font>p <font color=Cyan>`chainr1`</font> op<font color=Cyan>)</font> <font color=Cyan>+++</font> return v-<a name="(line224)"></a>-<a name="(line225)"></a><a name="chainr1"></a>chainr1 <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e <font color=Cyan>(</font>a<font color=Red>-></font>a<font color=Red>-></font>a<font color=Cyan>)</font> <font color=Red>-></font> Parser s t e a-<a name="(line226)"></a><a name="chainr1"></a>p <font color=Cyan>`chainr1`</font> op <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> rest x<font color=Cyan>}</font>-<a name="(line227)"></a> <font color=Green><u>where</u></font>-<a name="(line228)"></a> rest x <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> f <font color=Red><-</font> op-<a name="(line229)"></a> <font color=Cyan>;</font> y <font color=Red><-</font> p <font color=Cyan>`chainr1`</font> op-<a name="(line230)"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>f x y<font color=Cyan>)</font>-<a name="(line231)"></a> <font color=Cyan>}</font>-<a name="(line232)"></a> <font color=Cyan>+++</font> return x-<a name="(line233)"></a>-<a name="(line234)"></a><a name="ops"></a>ops <font color=Red>::</font> <font color=Red>[</font><font color=Cyan>(</font>Parser s t e a<font color=Cyan>,</font> b<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> Parser s t e b-<a name="(line235)"></a>ops xs <font color=Red>=</font> foldr1 <font color=Cyan>(</font><font color=Cyan>+++</font><font color=Cyan>)</font> <font color=Red>[</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>p<font color=Cyan>;</font> return op<font color=Cyan>}</font> <font color=Red>|</font> <font color=Cyan>(</font>p<font color=Cyan>,</font>op<font color=Cyan>)</font> <font color=Red><-</font> xs<font color=Red>]</font>-<a name="(line236)"></a>-<a name="(line237)"></a><a name="bracket"></a>bracket <font color=Red>::</font> <font color=Cyan>(</font>Show p<font color=Cyan>,</font>Show t<font color=Cyan>)</font> <font color=Red>=></font>-<a name="(line238)"></a> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> e a <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> e b <font color=Red>-></font>-<a name="(line239)"></a> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> e c <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> e b-<a name="(line240)"></a>bracket open p close <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> open-<a name="(line241)"></a> <font color=Cyan>;</font> x <font color=Red><-</font> p-<a name="(line242)"></a> <font color=Cyan>;</font> close <font color=Blue>-- `elserror` "improperly matched construct";</font>-<a name="(line243)"></a> <font color=Cyan>;</font> return x-<a name="(line244)"></a> <font color=Cyan>}</font>-<a name="(line245)"></a>-<a name="(line246)"></a><a name="toEOF"></a><font color=Blue>-- | Accept a complete parse of the input only, no partial parses.</font>-<a name="(line247)"></a>toEOF <font color=Red>::</font> Show p <font color=Red>=></font>-<a name="(line248)"></a> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> String a <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> String a-<a name="(line249)"></a>toEOF p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> p<font color=Cyan>;</font> eof<font color=Cyan>;</font> return x <font color=Cyan>}</font>-<a name="(line250)"></a>-<a name="(line251)"></a>-<a name="(line252)"></a><font color=Blue>--- Error handling -----------------------------------------------------------</font>-<a name="(line253)"></a>-<a name="(line254)"></a><a name="parseerror"></a><font color=Blue>-- | Return an error using the supplied diagnostic string, and a token type</font>-<a name="(line255)"></a><font color=Blue>-- which includes position information.</font>-<a name="(line256)"></a>parseerror <font color=Red>::</font> <font color=Cyan>(</font>Show p<font color=Cyan>,</font>Show t<font color=Cyan>)</font> <font color=Red>=></font> String <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> String a-<a name="(line257)"></a>parseerror err <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font>-<a name="(line258)"></a> <font color=Green><u>case</u></font> inp <font color=Green><u>of</u></font>-<a name="(line259)"></a> [] <font color=Red>-></font> Left <font color=Magenta>"Parse error: unexpected EOF\n"</font>-<a name="(line260)"></a> <font color=Cyan>(</font>Left e<font color=Red><b>:</b></font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> Left <font color=Cyan>(</font><font color=Magenta>"Lexical error: "</font><font color=Cyan>++</font>e<font color=Cyan>)</font>-<a name="(line261)"></a> <font color=Cyan>(</font>Right <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font><font color=Red><b>:</b></font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font>-<a name="(line262)"></a> Left <font color=Cyan>(</font><font color=Magenta>"Parse error: in "</font><font color=Cyan>++</font>show p<font color=Cyan>++</font><font color=Magenta>"\n "</font>-<a name="(line263)"></a> <font color=Cyan>++</font>err<font color=Cyan>++</font><font color=Magenta>"\n "</font><font color=Cyan>++</font><font color=Magenta>"Found "</font><font color=Cyan>++</font>show t<font color=Cyan>)</font>-<a name="(line264)"></a> <font color=Cyan>)</font>-<a name="(line265)"></a>-<a name="(line266)"></a>-<a name="(line267)"></a><a name="elserror"></a><font color=Blue>-- | If the parser fails, generate an error message.</font>-<a name="(line268)"></a>elserror <font color=Red>::</font> <font color=Cyan>(</font>Show p<font color=Cyan>,</font>Show t<font color=Cyan>)</font> <font color=Red>=></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> String a <font color=Red>-></font> String-<a name="(line269)"></a> <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> String a-<a name="(line270)"></a><a name="elserror"></a>p <font color=Cyan>`elserror`</font> s <font color=Red>=</font> p <font color=Cyan>+++</font> parseerror s-<a name="(line271)"></a>-<a name="(line272)"></a><font color=Blue>--- State handling -----------------------------------------------------------</font>-<a name="(line273)"></a>-<a name="(line274)"></a><a name="stupd"></a><font color=Blue>-- | Update the internal state.</font>-<a name="(line275)"></a>stupd <font color=Red>::</font> <font color=Cyan>(</font>s<font color=Red>-></font>s<font color=Cyan>)</font> <font color=Red>-></font> Parser s t e ()-<a name="(line276)"></a>stupd f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp<font color=Red>-></font> <font color=Blue>{-let newst = f st in newst `seq`-}</font>-<a name="(line277)"></a> Right <font color=Red>[</font><font color=Cyan>(</font>()<font color=Cyan>,</font> f st<font color=Cyan>,</font> inp<font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>-<a name="(line278)"></a>-<a name="(line279)"></a><a name="stquery"></a><font color=Blue>-- | Query the internal state.</font>-<a name="(line280)"></a>stquery <font color=Red>::</font> <font color=Cyan>(</font>s<font color=Red>-></font>a<font color=Cyan>)</font> <font color=Red>-></font> Parser s t e a-<a name="(line281)"></a>stquery f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp<font color=Red>-></font> Right <font color=Red>[</font><font color=Cyan>(</font>f st<font color=Cyan>,</font> st<font color=Cyan>,</font> inp<font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>-<a name="(line282)"></a>-<a name="(line283)"></a><a name="stget"></a><font color=Blue>-- | Deliver the entire internal state.</font>-<a name="(line284)"></a>stget <font color=Red>::</font> Parser s t e s-<a name="(line285)"></a>stget <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp<font color=Red>-></font> Right <font color=Red>[</font><font color=Cyan>(</font>st<font color=Cyan>,</font> st<font color=Cyan>,</font> inp<font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>-<a name="(line286)"></a>-<a name="(line287)"></a>-<a name="(line288)"></a><font color=Blue>--- Push some tokens back onto the input stream and reparse ------------------</font>-<a name="(line289)"></a>-<a name="(line290)"></a><a name="reparse"></a><font color=Blue>-- | This is useful for recursively expanding macros. When the</font>-<a name="(line291)"></a><font color=Blue>-- user-parser recognises a macro use, it can lookup the macro</font>-<a name="(line292)"></a><font color=Blue>-- expansion from the parse state, lex it, and then stuff the</font>-<a name="(line293)"></a><font color=Blue>-- lexed expansion back down into the parser.</font>-<a name="(line294)"></a>reparse <font color=Red>::</font> <font color=Red>[</font>Either e t<font color=Red>]</font> <font color=Red>-></font> Parser s t e ()-<a name="(line295)"></a>reparse ts <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp<font color=Red>-></font> Right <font color=Red>[</font><font color=Cyan>(</font>()<font color=Cyan>,</font> st<font color=Cyan>,</font> ts<font color=Cyan>++</font>inp<font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>-<a name="(line296)"></a>-<a name="(line297)"></a><font color=Blue>------------------------------------------------------------------------------</font>+<head>+<!-- Generated by HsColour, http://www.cs.york.ac.uk/fp/darcs/hscolour/ -->+<title>src/Text/ParserCombinators/HuttonMeijerWallace.hs</title>+</head>+<body>+<pre><a name="line-1"></a><font color=Blue>{-----------------------------------------------------------------------------+<a name="line-2"></a>+<a name="line-3"></a> A LIBRARY OF MONADIC PARSER COMBINATORS+<a name="line-4"></a>+<a name="line-5"></a> 29th July 1996+<a name="line-6"></a>+<a name="line-7"></a> Graham Hutton Erik Meijer+<a name="line-8"></a> University of Nottingham University of Utrecht+<a name="line-9"></a>+<a name="line-10"></a>This Haskell 1.3 script defines a library of parser combinators, and is taken+<a name="line-11"></a>from sections 1-6 of our article "Monadic Parser Combinators". Some changes+<a name="line-12"></a>to the library have been made in the move from Gofer to Haskell:+<a name="line-13"></a>+<a name="line-14"></a> * Do notation is used in place of monad comprehension notation;+<a name="line-15"></a>+<a name="line-16"></a> * The parser datatype is defined using "newtype", to avoid the overhead+<a name="line-17"></a> of tagging and untagging parsers with the P constructor.+<a name="line-18"></a>+<a name="line-19"></a>------------------------------------------------------------------------------+<a name="line-20"></a>** Extended to allow a symbol table/state to be threaded through the monad.+<a name="line-21"></a>** Extended to allow a parameterised token type, rather than just strings.+<a name="line-22"></a>** Extended to allow error-reporting.+<a name="line-23"></a>+<a name="line-24"></a>(Extensions: 1998-2000 Malcolm.Wallace@cs.york.ac.uk)+<a name="line-25"></a>(More extensions: 2004 gk-haskell@ninebynine.org)+<a name="line-26"></a>+<a name="line-27"></a>------------------------------------------------------------------------------}</font>+<a name="line-28"></a>+<a name="line-29"></a><font color=Blue>-- | This library of monadic parser combinators is based on the ones</font>+<a name="line-30"></a><font color=Blue>-- defined by Graham Hutton and Erik Meijer. It has been extended by</font>+<a name="line-31"></a><font color=Blue>-- Malcolm Wallace to use an abstract token type (no longer just a</font>+<a name="line-32"></a><font color=Blue>-- string) as input, and to incorporate state in the monad, useful</font>+<a name="line-33"></a><font color=Blue>-- for symbol tables, macros, and so on. Basic facilities for error</font>+<a name="line-34"></a><font color=Blue>-- reporting have also been added, and later extended by Graham Klyne</font>+<a name="line-35"></a><font color=Blue>-- to return the errors through an @Either@ type, rather than just</font>+<a name="line-36"></a><font color=Blue>-- calling @error@.</font>+<a name="line-37"></a>+<a name="line-38"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>HuttonMeijerWallace+<a name="line-39"></a> <font color=Cyan>(</font>+<a name="line-40"></a> <font color=Blue>-- * The parser monad</font>+<a name="line-41"></a> Parser<font color=Cyan>(</font><font color=Red>..</font><font color=Cyan>)</font>+<a name="line-42"></a> <font color=Blue>-- * Primitive parser combinators</font>+<a name="line-43"></a> <font color=Cyan>,</font> item<font color=Cyan>,</font> eof<font color=Cyan>,</font> papply<font color=Cyan>,</font> papply'+<a name="line-44"></a> <font color=Blue>-- * Derived combinators</font>+<a name="line-45"></a> <font color=Cyan>,</font> <font color=Cyan>(</font><font color=Cyan>+++</font><font color=Cyan>)</font><font color=Cyan>,</font> <font color=Blue>{-sat,-}</font> tok<font color=Cyan>,</font> nottok<font color=Cyan>,</font> many<font color=Cyan>,</font> many1+<a name="line-46"></a> <font color=Cyan>,</font> sepby<font color=Cyan>,</font> sepby1<font color=Cyan>,</font> chainl<font color=Cyan>,</font> chainl1<font color=Cyan>,</font> chainr<font color=Cyan>,</font> chainr1<font color=Cyan>,</font> ops<font color=Cyan>,</font> bracket+<a name="line-47"></a> <font color=Cyan>,</font> toEOF+<a name="line-48"></a> <font color=Blue>-- * Error handling</font>+<a name="line-49"></a> <font color=Cyan>,</font> elserror+<a name="line-50"></a> <font color=Blue>-- * State handling</font>+<a name="line-51"></a> <font color=Cyan>,</font> stupd<font color=Cyan>,</font> stquery<font color=Cyan>,</font> stget+<a name="line-52"></a> <font color=Blue>-- * Re-parsing</font>+<a name="line-53"></a> <font color=Cyan>,</font> reparse+<a name="line-54"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-55"></a>+<a name="line-56"></a><font color=Green><u>import</u></font> Char+<a name="line-57"></a><font color=Green><u>import</u></font> Monad+<a name="line-58"></a>+<a name="line-59"></a><font color=Green><u>infixr</u></font> <font color=Magenta>5</font> <font color=Cyan>+++</font>+<a name="line-60"></a>+<a name="line-61"></a><font color=Blue>--- The parser monad ---------------------------------------------------------</font>+<a name="line-62"></a>+<a name="line-63"></a><a name="ParseResult"></a><font color=Green><u>type</u></font> ParseResult s t e a <font color=Red>=</font> Either e <font color=Red>[</font><font color=Cyan>(</font>a<font color=Cyan>,</font>s<font color=Cyan>,</font><font color=Red>[</font>Either e t<font color=Red>]</font><font color=Cyan>)</font><font color=Red>]</font>+<a name="line-64"></a>+<a name="line-65"></a><a name="Parser"></a><font color=Green><u>newtype</u></font> Parser s t e a <font color=Red>=</font> P <font color=Cyan>(</font> s <font color=Red>-></font> <font color=Red>[</font>Either e t<font color=Red>]</font> <font color=Red>-></font> ParseResult s t e a <font color=Cyan>)</font>+<a name="line-66"></a> <font color=Blue>-- ^ The parser type is parametrised on the types of the state @s@,</font>+<a name="line-67"></a> <font color=Blue>-- the input tokens @t@, error-type @e@, and the result value @a@.</font>+<a name="line-68"></a> <font color=Blue>-- The state and remaining input are threaded through the monad.</font>+<a name="line-69"></a>+<a name="line-70"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Parser s t e<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-71"></a> <font color=Blue>-- fmap :: (a -> b) -> (Parser s t e a -> Parser s t e b)</font>+<a name="line-72"></a> fmap f <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> <font color=Green><u>case</u></font> p st inp <font color=Green><u>of</u></font>+<a name="line-73"></a> Right res <font color=Red>-></font> Right <font color=Red>[</font><font color=Cyan>(</font>f v<font color=Cyan>,</font> s<font color=Cyan>,</font> out<font color=Cyan>)</font> <font color=Red>|</font> <font color=Cyan>(</font>v<font color=Cyan>,</font>s<font color=Cyan>,</font>out<font color=Cyan>)</font> <font color=Red><-</font> res<font color=Red>]</font>+<a name="line-74"></a> Left err <font color=Red>-></font> Left err+<a name="line-75"></a> <font color=Cyan>)</font>+<a name="line-76"></a>+<a name="line-77"></a><font color=Green><u>instance</u></font> Monad <font color=Cyan>(</font>Parser s t e<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-78"></a> <font color=Blue>-- return :: a -> Parser s t e a</font>+<a name="line-79"></a> return v <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> Right <font color=Red>[</font><font color=Cyan>(</font>v<font color=Cyan>,</font>st<font color=Cyan>,</font>inp<font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>+<a name="line-80"></a> <font color=Blue>-- >>= :: Parser s t e a -> (a -> Parser s t e b) -> Parser s t e b</font>+<a name="line-81"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>>>=</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> <font color=Green><u>case</u></font> p st inp <font color=Green><u>of</u></font>+<a name="line-82"></a> Right res <font color=Red>-></font> foldr joinresults <font color=Cyan>(</font>Right []<font color=Cyan>)</font>+<a name="line-83"></a> <font color=Red>[</font> papply' <font color=Cyan>(</font>f v<font color=Cyan>)</font> s out <font color=Red>|</font> <font color=Cyan>(</font>v<font color=Cyan>,</font>s<font color=Cyan>,</font>out<font color=Cyan>)</font> <font color=Red><-</font> res <font color=Red>]</font>+<a name="line-84"></a> Left err <font color=Red>-></font> Left err+<a name="line-85"></a> <font color=Cyan>)</font>+<a name="line-86"></a> <font color=Blue>-- fail :: String -> Parser s t e a</font>+<a name="line-87"></a> fail err <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> Right []<font color=Cyan>)</font>+<a name="line-88"></a> <font color=Blue>-- I know it's counterintuitive, but we want no-parse, not an error.</font>+<a name="line-89"></a>+<a name="line-90"></a><font color=Green><u>instance</u></font> MonadPlus <font color=Cyan>(</font>Parser s t e<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-91"></a> <font color=Blue>-- mzero :: Parser s t e a</font>+<a name="line-92"></a> mzero <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> Right []<font color=Cyan>)</font>+<a name="line-93"></a> <font color=Blue>-- mplus :: Parser s t e a -> Parser s t e a -> Parser s t e a</font>+<a name="line-94"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`mplus`</font> <font color=Cyan>(</font>P q<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> joinresults <font color=Cyan>(</font>p st inp<font color=Cyan>)</font> <font color=Cyan>(</font>q st inp<font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-95"></a>+<a name="line-96"></a><a name="joinresults"></a><font color=Blue>-- joinresults ensures that explicitly raised errors are dominant,</font>+<a name="line-97"></a><font color=Blue>-- provided no parse has yet been found. The commented out code is</font>+<a name="line-98"></a><font color=Blue>-- a slightly stricter specification of the real code.</font>+<a name="line-99"></a><font color=Blue>joinresults</font> <font color=Red>::</font> ParseResult s t e a <font color=Red>-></font> ParseResult s t e a <font color=Red>-></font> ParseResult s t e a+<a name="line-100"></a><font color=Blue>{-+<a name="line-101"></a>joinresults (Left p) (Left q) = Left p+<a name="line-102"></a>joinresults (Left p) (Right _) = Left p+<a name="line-103"></a>joinresults (Right []) (Left q) = Left q+<a name="line-104"></a>joinresults (Right p) (Left q) = Right p+<a name="line-105"></a>joinresults (Right p) (Right q) = Right (p++q)+<a name="line-106"></a>-}</font>+<a name="line-107"></a><font color=Blue>joinresults</font> <font color=Cyan>(</font>Left p<font color=Cyan>)</font> q <font color=Red>=</font> Left p+<a name="line-108"></a><font color=Blue>joinresults</font> <font color=Cyan>(</font>Right []<font color=Cyan>)</font> q <font color=Red>=</font> q+<a name="line-109"></a><font color=Blue>joinresults</font> <font color=Cyan>(</font>Right p<font color=Cyan>)</font> q <font color=Red>=</font> Right <font color=Cyan>(</font>p<font color=Cyan>++</font> <font color=Green><u>case</u></font> q <font color=Green><u>of</u></font> Left <font color=Green><u>_</u></font> <font color=Red>-></font> []+<a name="line-110"></a> Right r <font color=Red>-></font> r<font color=Cyan>)</font>+<a name="line-111"></a>+<a name="line-112"></a>+<a name="line-113"></a><font color=Blue>--- Primitive parser combinators ---------------------------------------------</font>+<a name="line-114"></a>+<a name="line-115"></a><a name="item"></a><font color=Blue>-- | Deliver the first remaining token.</font>+<a name="line-116"></a><font color=Blue>item</font> <font color=Red>::</font> Parser s t e t+<a name="line-117"></a><font color=Blue>item</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> <font color=Green><u>case</u></font> inp <font color=Green><u>of</u></font>+<a name="line-118"></a> [] <font color=Red>-></font> Right []+<a name="line-119"></a> <font color=Cyan>(</font>Left e<font color=Red><b>:</b></font> <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> Left e+<a name="line-120"></a> <font color=Cyan>(</font>Right x<font color=Red><b>:</b></font> xs<font color=Cyan>)</font> <font color=Red>-></font> Right <font color=Red>[</font><font color=Cyan>(</font>x<font color=Cyan>,</font>st<font color=Cyan>,</font>xs<font color=Cyan>)</font><font color=Red>]</font>+<a name="line-121"></a> <font color=Cyan>)</font>+<a name="line-122"></a>+<a name="line-123"></a><a name="eof"></a><font color=Blue>-- | Fail if end of input is not reached</font>+<a name="line-124"></a><font color=Blue>eof</font> <font color=Red>::</font> Show p <font color=Red>=></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> String ()+<a name="line-125"></a><font color=Blue>eof</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> <font color=Green><u>case</u></font> inp <font color=Green><u>of</u></font>+<a name="line-126"></a> [] <font color=Red>-></font> Right <font color=Red>[</font><font color=Cyan>(</font>()<font color=Cyan>,</font>st<font color=Cyan>,</font>[]<font color=Cyan>)</font><font color=Red>]</font>+<a name="line-127"></a> <font color=Cyan>(</font>Left e<font color=Red><b>:</b></font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> Left e+<a name="line-128"></a> <font color=Cyan>(</font>Right <font color=Cyan>(</font>p<font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>)</font><font color=Red><b>:</b></font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> Left <font color=Cyan>(</font><font color=Magenta>"End of input expected at "</font>+<a name="line-129"></a> <font color=Cyan>++</font>show p<font color=Cyan>++</font><font color=Magenta>"\n but found text"</font><font color=Cyan>)</font>+<a name="line-130"></a> <font color=Cyan>)</font>+<a name="line-131"></a>+<a name="line-132"></a><font color=Blue>{-+<a name="line-133"></a>-- | Ensure the value delivered by the parser is evaluated to WHNF.+<a name="line-134"></a>force :: Parser s t e a -> Parser s t e a+<a name="line-135"></a>force (P p) = P (\st inp -> let Right xs = p st inp+<a name="line-136"></a> h = head xs in+<a name="line-137"></a> h `seq` Right (h: tail xs)+<a name="line-138"></a> )+<a name="line-139"></a>-- [[[GK]]] ^^^^^^+<a name="line-140"></a>-- WHNF = Weak Head Normal Form, meaning that it has no top-level redex.+<a name="line-141"></a>-- In this case, I think that means that the first element of the list+<a name="line-142"></a>-- is fully evaluated.+<a name="line-143"></a>--+<a name="line-144"></a>-- NOTE: the original form of this function fails if there is no parse+<a name="line-145"></a>-- result for p st inp (head xs fails if xs is null), so the modified+<a name="line-146"></a>-- form can assume a Right value only.+<a name="line-147"></a>--+<a name="line-148"></a>-- Why is this needed?+<a name="line-149"></a>-- It's not exported, and the only use of this I see is commented out.+<a name="line-150"></a>---------------------------------------+<a name="line-151"></a>-}</font>+<a name="line-152"></a>+<a name="line-153"></a>+<a name="line-154"></a><a name="first"></a><font color=Blue>-- | Deliver the first parse result only, eliminating any backtracking.</font>+<a name="line-155"></a><font color=Blue>first</font> <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e a+<a name="line-156"></a><font color=Blue>first</font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font> <font color=Green><u>case</u></font> p st inp <font color=Green><u>of</u></font>+<a name="line-157"></a> Right <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font> <font color=Red>-></font> Right <font color=Red>[</font>x<font color=Red>]</font>+<a name="line-158"></a> otherwise <font color=Red>-></font> otherwise+<a name="line-159"></a> <font color=Cyan>)</font>+<a name="line-160"></a>+<a name="line-161"></a><a name="papply"></a><font color=Blue>-- | Apply the parser to some real input, given an initial state value.</font>+<a name="line-162"></a><font color=Blue>-- If the parser fails, raise 'error' to halt the program.</font>+<a name="line-163"></a><font color=Blue>-- (This is the original exported behaviour - to allow the caller to</font>+<a name="line-164"></a><font color=Blue>-- deal with the error differently, see @papply'@.)</font>+<a name="line-165"></a><font color=Blue>papply</font> <font color=Red>::</font> Parser s t String a <font color=Red>-></font> s <font color=Red>-></font> <font color=Red>[</font>Either String t<font color=Red>]</font>+<a name="line-166"></a> <font color=Red>-></font> <font color=Red>[</font><font color=Cyan>(</font>a<font color=Cyan>,</font>s<font color=Cyan>,</font><font color=Red>[</font>Either String t<font color=Red>]</font><font color=Cyan>)</font><font color=Red>]</font>+<a name="line-167"></a><font color=Blue>papply</font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> st inp <font color=Red>=</font> either error id <font color=Cyan>(</font>p st inp<font color=Cyan>)</font>+<a name="line-168"></a>+<a name="line-169"></a><a name="papply'"></a><font color=Blue>-- | Apply the parser to some real input, given an initial state value.</font>+<a name="line-170"></a><font color=Blue>-- If the parser fails, return a diagnostic message to the caller.</font>+<a name="line-171"></a><font color=Blue>papply'</font> <font color=Red>::</font> Parser s t e a <font color=Red>-></font> s <font color=Red>-></font> <font color=Red>[</font>Either e t<font color=Red>]</font>+<a name="line-172"></a> <font color=Red>-></font> Either e <font color=Red>[</font><font color=Cyan>(</font>a<font color=Cyan>,</font>s<font color=Cyan>,</font><font color=Red>[</font>Either e t<font color=Red>]</font><font color=Cyan>)</font><font color=Red>]</font>+<a name="line-173"></a><font color=Blue>papply'</font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> st inp <font color=Red>=</font> p st inp+<a name="line-174"></a>+<a name="line-175"></a><font color=Blue>--- Derived combinators ------------------------------------------------------</font>+<a name="line-176"></a>+<a name="line-177"></a><a name="+++"></a><font color=Blue>-- | A choice between parsers. Keep only the first success.</font>+<a name="line-178"></a><font color=Cyan>(</font><font color=Cyan>+++</font><font color=Cyan>)</font> <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e a <font color=Red>-></font> Parser s t e a+<a name="line-179"></a><a name="p"></a><font color=Blue>p</font> <font color=Cyan>+++</font> q <font color=Red>=</font> first <font color=Cyan>(</font>p <font color=Cyan>`mplus`</font> q<font color=Cyan>)</font>+<a name="line-180"></a>+<a name="line-181"></a><a name="sat"></a><font color=Blue>-- | Deliver the first token if it satisfies a predicate.</font>+<a name="line-182"></a><font color=Blue>sat</font> <font color=Red>::</font> <font color=Cyan>(</font>t <font color=Red>-></font> Bool<font color=Cyan>)</font> <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> e t+<a name="line-183"></a><font color=Blue>sat</font> p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>x<font color=Cyan>)</font> <font color=Red><-</font> item<font color=Cyan>;</font> <font color=Green><u>if</u></font> p x <font color=Green><u>then</u></font> return x <font color=Green><u>else</u></font> mzero<font color=Cyan>}</font>+<a name="line-184"></a>+<a name="line-185"></a><a name="tok"></a><font color=Blue>-- | Deliver the first token if it equals the argument.</font>+<a name="line-186"></a><font color=Blue>tok</font> <font color=Red>::</font> Eq t <font color=Red>=></font> t <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> e t+<a name="line-187"></a><font color=Blue>tok</font> t <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>x<font color=Cyan>)</font> <font color=Red><-</font> item<font color=Cyan>;</font> <font color=Green><u>if</u></font> x<font color=Cyan>==</font>t <font color=Green><u>then</u></font> return t <font color=Green><u>else</u></font> mzero<font color=Cyan>}</font>+<a name="line-188"></a>+<a name="line-189"></a><a name="nottok"></a><font color=Blue>-- | Deliver the first token if it does not equal the argument.</font>+<a name="line-190"></a><font color=Blue>nottok</font> <font color=Red>::</font> Eq t <font color=Red>=></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> e t+<a name="line-191"></a><font color=Blue>nottok</font> ts <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>x<font color=Cyan>)</font> <font color=Red><-</font> item<font color=Cyan>;</font> <font color=Green><u>if</u></font> x <font color=Cyan>`notElem`</font> ts <font color=Green><u>then</u></font> return x+<a name="line-192"></a> <font color=Green><u>else</u></font> mzero<font color=Cyan>}</font>+<a name="line-193"></a>+<a name="line-194"></a><a name="many"></a><font color=Blue>-- | Deliver zero or more values of @a@.</font>+<a name="line-195"></a><font color=Blue>many</font> <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-196"></a><font color=Blue>many</font> p <font color=Red>=</font> many1 p <font color=Cyan>+++</font> return []+<a name="line-197"></a><font color=Blue>--many p = force (many1 p +++ return [])</font>+<a name="line-198"></a>+<a name="line-199"></a><a name="many1"></a><font color=Blue>-- | Deliver one or more values of @a@.</font>+<a name="line-200"></a><font color=Blue>many1</font> <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-201"></a><font color=Blue>many1</font> p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> xs <font color=Red><-</font> many p<font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font><font color=Cyan>}</font>+<a name="line-202"></a>+<a name="line-203"></a><a name="sepby"></a><font color=Blue>-- | Deliver zero or more values of @a@ separated by @b@'s.</font>+<a name="line-204"></a><font color=Blue>sepby</font> <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e b <font color=Red>-></font> Parser s t e <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-205"></a><a name="sepby"></a><font color=Blue>p</font> <font color=Cyan>`sepby`</font> sep <font color=Red>=</font> <font color=Cyan>(</font>p <font color=Cyan>`sepby1`</font> sep<font color=Cyan>)</font> <font color=Cyan>+++</font> return []+<a name="line-206"></a>+<a name="line-207"></a><a name="sepby1"></a><font color=Blue>-- | Deliver one or more values of @a@ separated by @b@'s.</font>+<a name="line-208"></a><font color=Blue>sepby1</font> <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e b <font color=Red>-></font> Parser s t e <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-209"></a><a name="sepby1"></a><font color=Blue>p</font> <font color=Cyan>`sepby1`</font> sep <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> xs <font color=Red><-</font> many <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>sep<font color=Cyan>;</font> p<font color=Cyan>}</font><font color=Cyan>)</font><font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font><font color=Cyan>}</font>+<a name="line-210"></a>+<a name="line-211"></a><a name="chainl"></a><font color=Blue>chainl</font> <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e <font color=Cyan>(</font>a<font color=Red>-></font>a<font color=Red>-></font>a<font color=Cyan>)</font> <font color=Red>-></font> a+<a name="line-212"></a> <font color=Red>-></font> Parser s t e a+<a name="line-213"></a><font color=Blue>chainl</font> p op v <font color=Red>=</font> <font color=Cyan>(</font>p <font color=Cyan>`chainl1`</font> op<font color=Cyan>)</font> <font color=Cyan>+++</font> return v+<a name="line-214"></a>+<a name="line-215"></a><a name="chainl1"></a><font color=Blue>chainl1</font> <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e <font color=Cyan>(</font>a<font color=Red>-></font>a<font color=Red>-></font>a<font color=Cyan>)</font> <font color=Red>-></font> Parser s t e a+<a name="line-216"></a><a name="chainl1"></a><font color=Blue>p</font> <font color=Cyan>`chainl1`</font> op <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> rest x<font color=Cyan>}</font>+<a name="line-217"></a> <font color=Green><u>where</u></font>+<a name="line-218"></a> rest x <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>f <font color=Red><-</font> op<font color=Cyan>;</font> y <font color=Red><-</font> p<font color=Cyan>;</font> rest <font color=Cyan>(</font>f x y<font color=Cyan>)</font><font color=Cyan>}</font>+<a name="line-219"></a> <font color=Cyan>+++</font> return x+<a name="line-220"></a>+<a name="line-221"></a><a name="chainr"></a><font color=Blue>chainr</font> <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e <font color=Cyan>(</font>a<font color=Red>-></font>a<font color=Red>-></font>a<font color=Cyan>)</font> <font color=Red>-></font> a+<a name="line-222"></a> <font color=Red>-></font> Parser s t e a+<a name="line-223"></a><font color=Blue>chainr</font> p op v <font color=Red>=</font> <font color=Cyan>(</font>p <font color=Cyan>`chainr1`</font> op<font color=Cyan>)</font> <font color=Cyan>+++</font> return v+<a name="line-224"></a>+<a name="line-225"></a><a name="chainr1"></a><font color=Blue>chainr1</font> <font color=Red>::</font> Parser s t e a <font color=Red>-></font> Parser s t e <font color=Cyan>(</font>a<font color=Red>-></font>a<font color=Red>-></font>a<font color=Cyan>)</font> <font color=Red>-></font> Parser s t e a+<a name="line-226"></a><a name="chainr1"></a><font color=Blue>p</font> <font color=Cyan>`chainr1`</font> op <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font>x <font color=Red><-</font> p<font color=Cyan>;</font> rest x<font color=Cyan>}</font>+<a name="line-227"></a> <font color=Green><u>where</u></font>+<a name="line-228"></a> rest x <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> f <font color=Red><-</font> op+<a name="line-229"></a> <font color=Cyan>;</font> y <font color=Red><-</font> p <font color=Cyan>`chainr1`</font> op+<a name="line-230"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>f x y<font color=Cyan>)</font>+<a name="line-231"></a> <font color=Cyan>}</font>+<a name="line-232"></a> <font color=Cyan>+++</font> return x+<a name="line-233"></a>+<a name="line-234"></a><a name="ops"></a><font color=Blue>ops</font> <font color=Red>::</font> <font color=Red>[</font><font color=Cyan>(</font>Parser s t e a<font color=Cyan>,</font> b<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> Parser s t e b+<a name="line-235"></a><font color=Blue>ops</font> xs <font color=Red>=</font> foldr1 <font color=Cyan>(</font><font color=Cyan>+++</font><font color=Cyan>)</font> <font color=Red>[</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>p<font color=Cyan>;</font> return op<font color=Cyan>}</font> <font color=Red>|</font> <font color=Cyan>(</font>p<font color=Cyan>,</font>op<font color=Cyan>)</font> <font color=Red><-</font> xs<font color=Red>]</font>+<a name="line-236"></a>+<a name="line-237"></a><a name="bracket"></a><font color=Blue>bracket</font> <font color=Red>::</font> <font color=Cyan>(</font>Show p<font color=Cyan>,</font>Show t<font color=Cyan>)</font> <font color=Red>=></font>+<a name="line-238"></a> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> e a <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> e b <font color=Red>-></font>+<a name="line-239"></a> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> e c <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> e b+<a name="line-240"></a><font color=Blue>bracket</font> open p close <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> open+<a name="line-241"></a> <font color=Cyan>;</font> x <font color=Red><-</font> p+<a name="line-242"></a> <font color=Cyan>;</font> close <font color=Blue>-- `elserror` "improperly matched construct";</font>+<a name="line-243"></a> <font color=Cyan>;</font> return x+<a name="line-244"></a> <font color=Cyan>}</font>+<a name="line-245"></a>+<a name="line-246"></a><a name="toEOF"></a><font color=Blue>-- | Accept a complete parse of the input only, no partial parses.</font>+<a name="line-247"></a><font color=Blue>toEOF</font> <font color=Red>::</font> Show p <font color=Red>=></font>+<a name="line-248"></a> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> String a <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> String a+<a name="line-249"></a><font color=Blue>toEOF</font> p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> p<font color=Cyan>;</font> eof<font color=Cyan>;</font> return x <font color=Cyan>}</font>+<a name="line-250"></a>+<a name="line-251"></a>+<a name="line-252"></a><font color=Blue>--- Error handling -----------------------------------------------------------</font>+<a name="line-253"></a>+<a name="line-254"></a><a name="parseerror"></a><font color=Blue>-- | Return an error using the supplied diagnostic string, and a token type</font>+<a name="line-255"></a><font color=Blue>-- which includes position information.</font>+<a name="line-256"></a><font color=Blue>parseerror</font> <font color=Red>::</font> <font color=Cyan>(</font>Show p<font color=Cyan>,</font>Show t<font color=Cyan>)</font> <font color=Red>=></font> String <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> String a+<a name="line-257"></a><font color=Blue>parseerror</font> err <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp <font color=Red>-></font>+<a name="line-258"></a> <font color=Green><u>case</u></font> inp <font color=Green><u>of</u></font>+<a name="line-259"></a> [] <font color=Red>-></font> Left <font color=Magenta>"Parse error: unexpected EOF\n"</font>+<a name="line-260"></a> <font color=Cyan>(</font>Left e<font color=Red><b>:</b></font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> Left <font color=Cyan>(</font><font color=Magenta>"Lexical error: "</font><font color=Cyan>++</font>e<font color=Cyan>)</font>+<a name="line-261"></a> <font color=Cyan>(</font>Right <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font><font color=Red><b>:</b></font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font>+<a name="line-262"></a> Left <font color=Cyan>(</font><font color=Magenta>"Parse error: in "</font><font color=Cyan>++</font>show p<font color=Cyan>++</font><font color=Magenta>"\n "</font>+<a name="line-263"></a> <font color=Cyan>++</font>err<font color=Cyan>++</font><font color=Magenta>"\n "</font><font color=Cyan>++</font><font color=Magenta>"Found "</font><font color=Cyan>++</font>show t<font color=Cyan>)</font>+<a name="line-264"></a> <font color=Cyan>)</font>+<a name="line-265"></a>+<a name="line-266"></a>+<a name="line-267"></a><a name="elserror"></a><font color=Blue>-- | If the parser fails, generate an error message.</font>+<a name="line-268"></a><font color=Blue>elserror</font> <font color=Red>::</font> <font color=Cyan>(</font>Show p<font color=Cyan>,</font>Show t<font color=Cyan>)</font> <font color=Red>=></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> String a <font color=Red>-></font> String+<a name="line-269"></a> <font color=Red>-></font> Parser s <font color=Cyan>(</font>p<font color=Cyan>,</font>t<font color=Cyan>)</font> String a+<a name="line-270"></a><a name="elserror"></a><font color=Blue>p</font> <font color=Cyan>`elserror`</font> s <font color=Red>=</font> p <font color=Cyan>+++</font> parseerror s+<a name="line-271"></a>+<a name="line-272"></a><font color=Blue>--- State handling -----------------------------------------------------------</font>+<a name="line-273"></a>+<a name="line-274"></a><a name="stupd"></a><font color=Blue>-- | Update the internal state.</font>+<a name="line-275"></a><font color=Blue>stupd</font> <font color=Red>::</font> <font color=Cyan>(</font>s<font color=Red>-></font>s<font color=Cyan>)</font> <font color=Red>-></font> Parser s t e ()+<a name="line-276"></a><font color=Blue>stupd</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp<font color=Red>-></font> <font color=Blue>{-let newst = f st in newst `seq`-}</font>+<a name="line-277"></a> Right <font color=Red>[</font><font color=Cyan>(</font>()<font color=Cyan>,</font> f st<font color=Cyan>,</font> inp<font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>+<a name="line-278"></a>+<a name="line-279"></a><a name="stquery"></a><font color=Blue>-- | Query the internal state.</font>+<a name="line-280"></a><font color=Blue>stquery</font> <font color=Red>::</font> <font color=Cyan>(</font>s<font color=Red>-></font>a<font color=Cyan>)</font> <font color=Red>-></font> Parser s t e a+<a name="line-281"></a><font color=Blue>stquery</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp<font color=Red>-></font> Right <font color=Red>[</font><font color=Cyan>(</font>f st<font color=Cyan>,</font> st<font color=Cyan>,</font> inp<font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>+<a name="line-282"></a>+<a name="line-283"></a><a name="stget"></a><font color=Blue>-- | Deliver the entire internal state.</font>+<a name="line-284"></a><font color=Blue>stget</font> <font color=Red>::</font> Parser s t e s+<a name="line-285"></a><font color=Blue>stget</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp<font color=Red>-></font> Right <font color=Red>[</font><font color=Cyan>(</font>st<font color=Cyan>,</font> st<font color=Cyan>,</font> inp<font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>+<a name="line-286"></a>+<a name="line-287"></a>+<a name="line-288"></a><font color=Blue>--- Push some tokens back onto the input stream and reparse ------------------</font>+<a name="line-289"></a>+<a name="line-290"></a><a name="reparse"></a><font color=Blue>-- | This is useful for recursively expanding macros. When the</font>+<a name="line-291"></a><font color=Blue>-- user-parser recognises a macro use, it can lookup the macro</font>+<a name="line-292"></a><font color=Blue>-- expansion from the parse state, lex it, and then stuff the</font>+<a name="line-293"></a><font color=Blue>-- lexed expansion back down into the parser.</font>+<a name="line-294"></a><font color=Blue>reparse</font> <font color=Red>::</font> <font color=Red>[</font>Either e t<font color=Red>]</font> <font color=Red>-></font> Parser s t e ()+<a name="line-295"></a><font color=Blue>reparse</font> ts <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>st inp<font color=Red>-></font> Right <font color=Red>[</font><font color=Cyan>(</font>()<font color=Cyan>,</font> st<font color=Cyan>,</font> ts<font color=Cyan>++</font>inp<font color=Cyan>)</font><font color=Red>]</font><font color=Cyan>)</font>+<a name="line-296"></a>+<a name="line-297"></a><font color=Blue>------------------------------------------------------------------------------</font> </pre>+</body> </html>
docs/haddock/src/Text/ParserCombinators/Poly.html view
@@ -1,251 +1,15 @@ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"> <html>-<pre><a name="(line1)"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly-<a name="(line2)"></a> <font color=Cyan>(</font> <font color=Blue>-- * The Parser datatype</font>-<a name="(line3)"></a> Parser<font color=Cyan>(</font>P<font color=Cyan>)</font> <font color=Blue>-- datatype, instance of: Functor, Monad</font>-<a name="(line4)"></a> <font color=Cyan>,</font> runParser <font color=Blue>-- :: Parser t a -> [t] -> (Either String a, [t])</font>-<a name="(line5)"></a> <font color=Cyan>,</font> failBad <font color=Blue>-- :: String -> Parser t a</font>-<a name="(line6)"></a> <font color=Cyan>,</font> commit <font color=Blue>-- :: Parser t a -> Parser t a</font>-<a name="(line7)"></a>-<a name="(line8)"></a> <font color=Blue>-- * Combinators:</font>-<a name="(line9)"></a> <font color=Blue>-- ** Primitives</font>-<a name="(line10)"></a> <font color=Cyan>,</font> next <font color=Blue>-- :: Parser t t</font>-<a name="(line11)"></a> <font color=Cyan>,</font> satisfy <font color=Blue>-- :: (t->Bool) -> Parser t t</font>-<a name="(line12)"></a> <font color=Cyan>,</font> apply <font color=Blue>-- :: Parser t (a->b) -> Parser t a -> Parser t b</font>-<a name="(line13)"></a> <font color=Cyan>,</font> discard <font color=Blue>-- :: Parser t a -> Parser t b -> Parser t a</font>-<a name="(line14)"></a> <font color=Blue>-- ** Error-handling</font>-<a name="(line15)"></a> <font color=Cyan>,</font> adjustErr <font color=Blue>-- :: Parser t a -> (String->String) -> Parser t a</font>-<a name="(line16)"></a> <font color=Cyan>,</font> adjustErrBad<font color=Blue>-- :: Parser t a -> (String->String) -> Parser t a</font>-<a name="(line17)"></a> <font color=Cyan>,</font> indent <font color=Blue>-- :: Int -> String -> String</font>-<a name="(line18)"></a> <font color=Blue>-- ** Choices</font>-<a name="(line19)"></a> <font color=Cyan>,</font> onFail <font color=Blue>-- :: Parser t a -> Parser t a -> Parser t a</font>-<a name="(line20)"></a> <font color=Cyan>,</font> oneOf <font color=Blue>-- :: Show t => [Parser t a] -> Parser t a</font>-<a name="(line21)"></a> <font color=Cyan>,</font> oneOf' <font color=Blue>-- :: [(String,Parser t a)] -> Parser t a</font>-<a name="(line22)"></a> <font color=Cyan>,</font> optional <font color=Blue>-- :: Parser t a -> Parser t (Maybe a)</font>-<a name="(line23)"></a> <font color=Blue>-- ** Sequences</font>-<a name="(line24)"></a> <font color=Cyan>,</font> exactly <font color=Blue>-- :: Int -> Parser t a -> Parser t [a]</font>-<a name="(line25)"></a> <font color=Cyan>,</font> many <font color=Blue>-- :: Parser t a -> Parser t [a]</font>-<a name="(line26)"></a> <font color=Cyan>,</font> many1 <font color=Blue>-- :: Parser t a -> Parser t [a]</font>-<a name="(line27)"></a> <font color=Cyan>,</font> sepBy <font color=Blue>-- :: Parser t a -> Parser t sep -> Parser t [a]</font>-<a name="(line28)"></a> <font color=Cyan>,</font> sepBy1 <font color=Blue>-- :: Parser t a -> Parser t sep -> Parser t [a]</font>-<a name="(line29)"></a> <font color=Cyan>,</font> bracketSep <font color=Blue>-- :: Parser t bra -> Parser t sep -> Parser t ket</font>-<a name="(line30)"></a> <font color=Blue>-- -> Parser t a -> Parser t [a]</font>-<a name="(line31)"></a> <font color=Cyan>,</font> bracket <font color=Blue>-- :: Parser t bra -> Parser t ket -> Parser t a</font>-<a name="(line32)"></a> <font color=Blue>-- -> Parser t a</font>-<a name="(line33)"></a> <font color=Cyan>,</font> manyFinally <font color=Blue>-- :: Parser t a -> Parser t z -> Parser t [a]</font>-<a name="(line34)"></a> <font color=Blue>-- ** re-parsing</font>-<a name="(line35)"></a> <font color=Cyan>,</font> reparse <font color=Blue>-- :: [t] -> Parser t ()</font>-<a name="(line36)"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line37)"></a>-<a name="(line38)"></a>-<a name="(line39)"></a><a name="Parser"></a><font color=Blue>-- | The @Parser@ datatype is a fairly generic parsing monad with error</font>-<a name="(line40)"></a><a name="Parser"></a><font color=Blue>-- reporting. It can be used for arbitrary token types, not just</font>-<a name="(line41)"></a><a name="Parser"></a><font color=Blue>-- String input. (If you require a running state, use module PolyState</font>-<a name="(line42)"></a><a name="Parser"></a><font color=Blue>-- instead)</font>-<a name="(line43)"></a><a name="Parser"></a><font color=Green><u>newtype</u></font> Parser t a <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>EitherE String a<font color=Cyan>,</font> <font color=Red>[</font>t<font color=Red>]</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line44)"></a>-<a name="(line45)"></a><a name="EitherE"></a><font color=Blue>-- A return type like Either, that distinguishes not only between</font>-<a name="(line46)"></a><a name="EitherE"></a><font color=Blue>-- right and wrong answers, but also has gradations of wrongness.</font>-<a name="(line47)"></a><a name="EitherE"></a><font color=Green><u>type</u></font> EitherE a b <font color=Red>=</font> Either <font color=Cyan>(</font>Bool<font color=Cyan>,</font>a<font color=Cyan>)</font> b-<a name="(line48)"></a>-<a name="(line49)"></a><a name="runParser"></a><font color=Blue>-- | Apply a parser to an input token sequence.</font>-<a name="(line50)"></a>runParser <font color=Red>::</font> Parser t a <font color=Red>-></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>Either String a<font color=Cyan>,</font> <font color=Red>[</font>t<font color=Red>]</font><font color=Cyan>)</font>-<a name="(line51)"></a>runParser <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font>-<a name="(line52)"></a> <font color=Cyan>(</font><font color=Red>\</font> <font color=Cyan>(</font>e<font color=Cyan>,</font>ts<font color=Cyan>)</font><font color=Red>-></font> <font color=Cyan>(</font><font color=Green><u>case</u></font> e <font color=Green><u>of</u></font> <font color=Cyan>{</font>Left <font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>m<font color=Cyan>)</font><font color=Red>-></font>Left m<font color=Cyan>;</font> Right m<font color=Red>-></font>Right m<font color=Cyan>}</font><font color=Cyan>,</font> ts<font color=Cyan>)</font> <font color=Cyan>)</font>-<a name="(line53)"></a> <font color=Cyan>.</font> p-<a name="(line54)"></a>-<a name="(line55)"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Parser t<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line56)"></a> fmap f <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line57)"></a> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line58)"></a> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Right <font color=Cyan>(</font>f x<font color=Cyan>)</font><font color=Cyan>,</font> ts'<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line59)"></a><font color=Green><u>instance</u></font> Monad <font color=Cyan>(</font>Parser t<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line60)"></a> return x <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line61)"></a> <font color=Cyan>(</font>P f<font color=Cyan>)</font> <font color=Cyan>>>=</font> g <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> f ts <font color=Green><u>of</u></font>-<a name="(line62)"></a> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line63)"></a> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P g'<font color=Cyan>)</font> <font color=Red>=</font> g x <font color=Green><u>in</u></font> g' ts'<font color=Cyan>)</font>-<a name="(line64)"></a> fail e <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>False<font color=Cyan>,</font>e<font color=Cyan>)</font><font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line65)"></a>-<a name="(line66)"></a><a name="failBad"></a><font color=Blue>-- | When a simple fail is not strong enough, use failBad for emphasis.</font>-<a name="(line67)"></a><font color=Blue>-- An emphasised (severe) error can propagate out through choice operators.</font>-<a name="(line68)"></a>failBad <font color=Red>::</font> String <font color=Red>-></font> Parser t a-<a name="(line69)"></a>failBad msg <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>True<font color=Cyan>,</font>msg<font color=Cyan>)</font><font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line70)"></a>-<a name="(line71)"></a><a name="commit"></a><font color=Blue>-- | Commit is a way of raising the severity of any errors found within</font>-<a name="(line72)"></a><font color=Blue>-- its argument. Used in the middle of a parser definition, it means that</font>-<a name="(line73)"></a><font color=Blue>-- any operations prior to commitment fail softly, but after commitment,</font>-<a name="(line74)"></a><font color=Blue>-- they fail hard.</font>-<a name="(line75)"></a>commit <font color=Red>::</font> Parser t a <font color=Red>-></font> Parser t a-<a name="(line76)"></a>commit <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line77)"></a> <font color=Cyan>(</font>Left <font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>e<font color=Cyan>)</font><font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>True<font color=Cyan>,</font>e<font color=Cyan>)</font><font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line78)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line79)"></a>-<a name="(line80)"></a>-<a name="(line81)"></a><font color=Blue>-- Combinators</font>-<a name="(line82)"></a>-<a name="(line83)"></a><a name="next"></a><font color=Blue>-- | One token</font>-<a name="(line84)"></a>next <font color=Red>::</font> Parser t t-<a name="(line85)"></a>next <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> ts <font color=Green><u>of</u></font>-<a name="(line86)"></a> [] <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>False<font color=Cyan>,</font><font color=Magenta>"Ran out of input (EOF)"</font><font color=Cyan>)</font><font color=Cyan>,</font> []<font color=Cyan>)</font>-<a name="(line87)"></a> <font color=Cyan>(</font>t<font color=Red><b>:</b></font>ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Right t<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Cyan>)</font>-<a name="(line88)"></a>-<a name="(line89)"></a><a name="satisfy"></a><font color=Blue>-- | One token satifying a predicate</font>-<a name="(line90)"></a>satisfy <font color=Red>::</font> <font color=Cyan>(</font>t<font color=Red>-></font>Bool<font color=Cyan>)</font> <font color=Red>-></font> Parser t t-<a name="(line91)"></a>satisfy p <font color=Red>=</font> <font color=Green><u>do</u></font><font color=Cyan>{</font> x <font color=Red><-</font> next-<a name="(line92)"></a> <font color=Cyan>;</font> <font color=Green><u>if</u></font> p x <font color=Green><u>then</u></font> return x <font color=Green><u>else</u></font> fail <font color=Magenta>"Parse.satisfy: failed"</font>-<a name="(line93)"></a> <font color=Cyan>}</font>-<a name="(line94)"></a>-<a name="(line95)"></a><font color=Green><u>infixl</u></font> <font color=Magenta>3</font> <font color=Cyan>`apply`</font>-<a name="(line96)"></a><a name="apply"></a><font color=Blue>-- | Apply a parsed function to a parsed value</font>-<a name="(line97)"></a>apply <font color=Red>::</font> Parser t <font color=Cyan>(</font>a<font color=Red>-></font>b<font color=Cyan>)</font> <font color=Red>-></font> Parser t a <font color=Red>-></font> Parser t b-<a name="(line98)"></a><a name="apply"></a>pf <font color=Cyan>`apply`</font> px <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> f <font color=Red><-</font> pf<font color=Cyan>;</font> x <font color=Red><-</font> px<font color=Cyan>;</font> return <font color=Cyan>(</font>f x<font color=Cyan>)</font> <font color=Cyan>}</font>-<a name="(line99)"></a>-<a name="(line100)"></a><font color=Green><u>infixl</u></font> <font color=Magenta>3</font> <font color=Cyan>`discard`</font>-<a name="(line101)"></a><a name="discard"></a><font color=Blue>-- | @x `discard` y@ parses both x and y, but discards the result of y</font>-<a name="(line102)"></a>discard <font color=Red>::</font> Parser t a <font color=Red>-></font> Parser t b <font color=Red>-></font> Parser t a-<a name="(line103)"></a><a name="discard"></a>px <font color=Cyan>`discard`</font> py <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> px<font color=Cyan>;</font> <font color=Green><u>_</u></font> <font color=Red><-</font> py<font color=Cyan>;</font> return x <font color=Cyan>}</font>-<a name="(line104)"></a>-<a name="(line105)"></a><a name="adjustErr"></a><font color=Blue>-- | @p `adjustErr` f@ applies the transformation @f@ to any error message</font>-<a name="(line106)"></a><font color=Blue>-- generated in @p@, having no effect if @p@ succeeds.</font>-<a name="(line107)"></a>adjustErr <font color=Red>::</font> Parser t a <font color=Red>-></font> <font color=Cyan>(</font>String<font color=Red>-></font>String<font color=Cyan>)</font> <font color=Red>-></font> Parser t a-<a name="(line108)"></a><a name="adjustErr"></a><font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`adjustErr`</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line109)"></a> <font color=Cyan>(</font>Left <font color=Cyan>(</font>b<font color=Cyan>,</font>msg<font color=Cyan>)</font><font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>b<font color=Cyan>,</font><font color=Cyan>(</font>f msg<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line110)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line111)"></a>-<a name="(line112)"></a><a name="adjustErrBad"></a><font color=Blue>-- | @adjustErrBad@ is just like @adjustErr@ except it also raises the</font>-<a name="(line113)"></a><font color=Blue>-- severity of the error.</font>-<a name="(line114)"></a>adjustErrBad <font color=Red>::</font> Parser t a <font color=Red>-></font> <font color=Cyan>(</font>String<font color=Red>-></font>String<font color=Cyan>)</font> <font color=Red>-></font> Parser t a-<a name="(line115)"></a><a name="adjustErrBad"></a>p <font color=Cyan>`adjustErrBad`</font> f <font color=Red>=</font> commit <font color=Cyan>(</font>p <font color=Cyan>`adjustErr`</font> f<font color=Cyan>)</font>-<a name="(line116)"></a>-<a name="(line117)"></a><font color=Green><u>infixl</u></font> <font color=Magenta>6</font> <font color=Cyan>`onFail`</font> <font color=Blue>-- not sure about precedence 6?</font>-<a name="(line118)"></a><a name="onFail"></a><font color=Blue>-- | @p `onFail` q@ means parse p unless p fails in which case parse q instead.</font>-<a name="(line119)"></a><font color=Blue>-- Can be chained together to give multiple attempts to parse something.</font>-<a name="(line120)"></a><font color=Blue>-- (Note that q could itself be a failing parser, e.g. to change the error</font>-<a name="(line121)"></a><font color=Blue>-- message from that defined in p to something different.)</font>-<a name="(line122)"></a><font color=Blue>-- However, a *severe* failure in p cannot be ignored.</font>-<a name="(line123)"></a>onFail <font color=Red>::</font> Parser t a <font color=Red>-></font> Parser t a <font color=Red>-></font> Parser t a-<a name="(line124)"></a><a name="onFail"></a><font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`onFail`</font> <font color=Cyan>(</font>P q<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line125)"></a> r<font color=Red>@</font><font color=Cyan>(</font>Left <font color=Cyan>(</font>True<font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>)</font><font color=Cyan>,</font> <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> r-<a name="(line126)"></a> <font color=Cyan>(</font>Left <font color=Green><u>_</u></font><font color=Cyan>,</font> <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> q ts-<a name="(line127)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line128)"></a>-<a name="(line129)"></a><a name="oneOf"></a><font color=Blue>-- | Parse the first alternative in the list that succeeds.</font>-<a name="(line130)"></a>oneOf <font color=Red>::</font> <font color=Red>[</font>Parser t a<font color=Red>]</font> <font color=Red>-></font> Parser t a-<a name="(line131)"></a>oneOf [] <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> n <font color=Red><-</font> next-<a name="(line132)"></a> <font color=Cyan>;</font> fail <font color=Cyan>(</font><font color=Magenta>"failed to parse any of the possible choices"</font><font color=Cyan>)</font>-<a name="(line133)"></a> <font color=Cyan>}</font>-<a name="(line134)"></a><font color=Blue>--oneOf :: Show t => [Parser t a] -> Parser t a</font>-<a name="(line135)"></a><font color=Blue>--oneOf [] = do { n <- next</font>-<a name="(line136)"></a><font color=Blue>-- ; fail ("failed to parse any of the possible choices"</font>-<a name="(line137)"></a><font color=Blue>-- ++"\n next token is "++show n)</font>-<a name="(line138)"></a><font color=Blue>-- }</font>-<a name="(line139)"></a>oneOf <font color=Cyan>(</font>p<font color=Red><b>:</b></font>ps<font color=Cyan>)</font> <font color=Red>=</font> p <font color=Cyan>`onFail`</font> oneOf ps-<a name="(line140)"></a>-<a name="(line141)"></a><a name="oneOf'"></a><font color=Blue>-- | Parse the first alternative that succeeds, but if none succeed,</font>-<a name="(line142)"></a><font color=Blue>-- report only the severe errors, and if none of those, then report</font>-<a name="(line143)"></a><font color=Blue>-- all the soft errors.</font>-<a name="(line144)"></a>oneOf' <font color=Red>::</font> <font color=Red>[</font><font color=Cyan>(</font>String<font color=Cyan>,</font> Parser t a<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> Parser t a-<a name="(line145)"></a>oneOf' <font color=Red>=</font> accum []-<a name="(line146)"></a> <font color=Green><u>where</u></font> accum errs [] <font color=Red>=</font>-<a name="(line147)"></a> <font color=Green><u>case</u></font> filter isBad errs <font color=Green><u>of</u></font>-<a name="(line148)"></a> [] <font color=Red>-></font> fail <font color=Cyan>(</font><font color=Magenta>"failed to parse any of the possible choices:\n"</font>-<a name="(line149)"></a> <font color=Cyan>++</font>indent <font color=Magenta>2</font> <font color=Cyan>(</font>concatMap showErr <font color=Cyan>(</font>reverse errs<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line150)"></a> <font color=Red>[</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>e<font color=Cyan>)</font><font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> failBad e-<a name="(line151)"></a> es <font color=Red>-></font> failBad <font color=Cyan>(</font><font color=Magenta>"one of the following failures occurred:\n"</font>-<a name="(line152)"></a> <font color=Cyan>++</font>indent <font color=Magenta>2</font> <font color=Cyan>(</font>concatMap showErr <font color=Cyan>(</font>reverse es<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line153)"></a> accum errs <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>P p<font color=Cyan>)</font><font color=Red><b>:</b></font>ps<font color=Cyan>)</font> <font color=Red>=</font>-<a name="(line154)"></a> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line155)"></a> <font color=Cyan>(</font>Left err<font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> accum <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>err<font color=Cyan>)</font><font color=Red><b>:</b></font>errs<font color=Cyan>)</font> ps-<a name="(line156)"></a> <font color=Green><u>in</u></font> p ts-<a name="(line157)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line158)"></a> showErr <font color=Cyan>(</font>name<font color=Cyan>,</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>err<font color=Cyan>)</font><font color=Cyan>)</font> <font color=Red>=</font> name<font color=Cyan>++</font><font color=Magenta>":\n"</font><font color=Cyan>++</font>indent <font color=Magenta>2</font> err-<a name="(line159)"></a> isBad <font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font><font color=Cyan>(</font>b<font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>)</font><font color=Cyan>)</font> <font color=Red>=</font> b-<a name="(line160)"></a>-<a name="(line161)"></a><a name="indent"></a><font color=Blue>-- | Helper for formatting error messages: indents all lines by a fixed amount.</font>-<a name="(line162)"></a>indent <font color=Red>::</font> Int <font color=Red>-></font> String <font color=Red>-></font> String-<a name="(line163)"></a>indent n <font color=Red>=</font> unlines <font color=Cyan>.</font> map <font color=Cyan>(</font>replicate n <font color=Magenta>' '</font> <font color=Cyan>++</font><font color=Cyan>)</font> <font color=Cyan>.</font> lines-<a name="(line164)"></a>-<a name="(line165)"></a><a name="optional"></a><font color=Blue>-- | 'optional' indicates whether the parser succeeded through the Maybe type.</font>-<a name="(line166)"></a>optional <font color=Red>::</font> Parser t a <font color=Red>-></font> Parser t <font color=Cyan>(</font>Maybe a<font color=Cyan>)</font>-<a name="(line167)"></a>optional p <font color=Red>=</font> fmap Just p <font color=Cyan>`onFail`</font> return Nothing-<a name="(line168)"></a>-<a name="(line169)"></a><a name="exactly"></a><font color=Blue>-- | 'exactly n p' parses a precise number of items, n, using the parser</font>-<a name="(line170)"></a><font color=Blue>-- p, in sequence.</font>-<a name="(line171)"></a>exactly <font color=Red>::</font> Int <font color=Red>-></font> Parser t a <font color=Red>-></font> Parser t <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line172)"></a>exactly <font color=Magenta>0</font> p <font color=Red>=</font> return []-<a name="(line173)"></a>exactly n p <font color=Red>=</font> <font color=Green><u>do</u></font> x <font color=Red><-</font> p-<a name="(line174)"></a> xs <font color=Red><-</font> exactly <font color=Cyan>(</font>n<font color=Blue>-</font><font color=Magenta>1</font><font color=Cyan>)</font> p-<a name="(line175)"></a> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font>-<a name="(line176)"></a>-<a name="(line177)"></a><a name="many"></a><font color=Blue>-- | 'many p' parses a list of elements with individual parser p.</font>-<a name="(line178)"></a><font color=Blue>-- Cannot fail, since an empty list is a valid return value.</font>-<a name="(line179)"></a>many <font color=Red>::</font> Parser t a <font color=Red>-></font> Parser t <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line180)"></a>many p <font color=Red>=</font> many1 p <font color=Cyan>`onFail`</font> return []-<a name="(line181)"></a>-<a name="(line182)"></a><a name="many1"></a><font color=Blue>-- | Parse a non-empty list of items.</font>-<a name="(line183)"></a>many1 <font color=Red>::</font> Parser t a <font color=Red>-></font> Parser t <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line184)"></a>many1 p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> p <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Cyan>(</font><font color=Magenta>"In a sequence:\n"</font><font color=Cyan>++</font><font color=Cyan>)</font><font color=Cyan>.</font> indent <font color=Magenta>2</font><font color=Cyan>)</font>-<a name="(line185)"></a> <font color=Cyan>;</font> xs <font color=Red><-</font> many p-<a name="(line186)"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font>-<a name="(line187)"></a> <font color=Cyan>}</font>-<a name="(line188)"></a><font color=Blue>-- `adjustErr` ("When looking for a non-empty sequence:\n\t"++)</font>-<a name="(line189)"></a>-<a name="(line190)"></a><a name="sepBy"></a><font color=Blue>-- | Parse a list of items separated by discarded junk.</font>-<a name="(line191)"></a>sepBy <font color=Red>::</font> Parser t a <font color=Red>-></font> Parser t sep <font color=Red>-></font> Parser t <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line192)"></a>sepBy p sep <font color=Red>=</font> <font color=Green><u>do</u></font> sepBy1 p sep <font color=Cyan>`onFail`</font> return []-<a name="(line193)"></a>-<a name="(line194)"></a><a name="sepBy1"></a><font color=Blue>-- | Parse a non-empty list of items separated by discarded junk.</font>-<a name="(line195)"></a>sepBy1 <font color=Red>::</font> Parser t a <font color=Red>-></font> Parser t sep <font color=Red>-></font> Parser t <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line196)"></a>sepBy1 p sep <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> p-<a name="(line197)"></a> <font color=Cyan>;</font> xs <font color=Red><-</font> many <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>sep<font color=Cyan>;</font> p<font color=Cyan>}</font><font color=Cyan>)</font>-<a name="(line198)"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font>-<a name="(line199)"></a> <font color=Cyan>}</font>-<a name="(line200)"></a> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"When looking for a non-empty sequence with separators:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line201)"></a> -<a name="(line202)"></a><a name="bracketSep"></a><font color=Blue>-- | Parse a list of items, discarding the start, end, and separator</font>-<a name="(line203)"></a><font color=Blue>-- items.</font>-<a name="(line204)"></a>bracketSep <font color=Red>::</font> Parser t bra <font color=Red>-></font> Parser t sep <font color=Red>-></font> Parser t ket-<a name="(line205)"></a> <font color=Red>-></font> Parser t a <font color=Red>-></font> Parser t <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line206)"></a>bracketSep open sep close p <font color=Red>=</font>-<a name="(line207)"></a> <font color=Green><u>do</u></font> <font color=Cyan>{</font> open<font color=Cyan>;</font> close<font color=Cyan>;</font> return [] <font color=Cyan>}</font>-<a name="(line208)"></a> <font color=Cyan>`onFail`</font>-<a name="(line209)"></a> <font color=Green><u>do</u></font> <font color=Cyan>{</font> open <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Missing opening bracket:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line210)"></a> <font color=Cyan>;</font> x <font color=Red><-</font> p <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"After first bracket in a group:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line211)"></a> <font color=Cyan>;</font> xs <font color=Red><-</font> many <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>sep<font color=Cyan>;</font> p<font color=Cyan>}</font><font color=Cyan>)</font>-<a name="(line212)"></a> <font color=Cyan>;</font> close <font color=Cyan>`adjustErrBad`</font> <font color=Cyan>(</font><font color=Magenta>"When looking for closing bracket:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line213)"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font>xs<font color=Cyan>)</font>-<a name="(line214)"></a> <font color=Cyan>}</font>-<a name="(line215)"></a>-<a name="(line216)"></a><a name="bracket"></a><font color=Blue>-- | Parse a bracketed item, discarding the brackets.</font>-<a name="(line217)"></a>bracket <font color=Red>::</font> Parser t bra <font color=Red>-></font> Parser t ket <font color=Red>-></font> Parser t a <font color=Red>-></font> Parser t a-<a name="(line218)"></a>bracket open close p <font color=Red>=</font> <font color=Green><u>do</u></font>-<a name="(line219)"></a> <font color=Green><u>do</u></font> <font color=Cyan>{</font> open <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Missing opening bracket:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line220)"></a> <font color=Cyan>;</font> x <font color=Red><-</font> p-<a name="(line221)"></a> <font color=Cyan>;</font> close <font color=Cyan>`adjustErrBad`</font> <font color=Cyan>(</font><font color=Magenta>"Missing closing bracket:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line222)"></a> <font color=Cyan>;</font> return x-<a name="(line223)"></a> <font color=Cyan>}</font>-<a name="(line224)"></a>-<a name="(line225)"></a><a name="manyFinally"></a><font color=Blue>-- | 'manyFinally e t' parses a possibly-empty sequence of e's,</font>-<a name="(line226)"></a><font color=Blue>-- terminated by a t. Any parse failures could be due either to</font>-<a name="(line227)"></a><font color=Blue>-- a badly-formed terminator or a badly-formed element, so raise</font>-<a name="(line228)"></a><font color=Blue>-- both possible errors.</font>-<a name="(line229)"></a>manyFinally <font color=Red>::</font> Parser t a <font color=Red>-></font> Parser t z <font color=Red>-></font> Parser t <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line230)"></a>manyFinally p t <font color=Red>=</font>-<a name="(line231)"></a> <font color=Green><u>do</u></font> <font color=Cyan>{</font> xs <font color=Red><-</font> many p-<a name="(line232)"></a> <font color=Cyan>;</font> oneOf' <font color=Red>[</font> <font color=Cyan>(</font><font color=Magenta>"sequence terminator"</font><font color=Cyan>,</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> t<font color=Cyan>;</font> return () <font color=Cyan>}</font> <font color=Cyan>)</font>-<a name="(line233)"></a> <font color=Cyan>,</font> <font color=Cyan>(</font><font color=Magenta>"item in a sequence"</font><font color=Cyan>,</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> p<font color=Cyan>;</font> return () <font color=Cyan>}</font> <font color=Cyan>)</font>-<a name="(line234)"></a> <font color=Red>]</font>-<a name="(line235)"></a> <font color=Cyan>;</font> return xs-<a name="(line236)"></a> <font color=Cyan>}</font>-<a name="(line237)"></a>-<a name="(line238)"></a><a name="reparse"></a><font color=Blue>------------------------------------------------------------------------</font>-<a name="(line239)"></a><font color=Blue>-- | Push some tokens back onto the front of the input stream and reparse.</font>-<a name="(line240)"></a><font color=Blue>-- This is useful e.g. for recursively expanding macros. When the</font>-<a name="(line241)"></a><font color=Blue>-- user-parser recognises a macro use, it can lookup the macro</font>-<a name="(line242)"></a><font color=Blue>-- expansion from the parse state, lex it, and then stuff the</font>-<a name="(line243)"></a><font color=Blue>-- lexed expansion back down into the parser.</font>-<a name="(line244)"></a>reparse <font color=Red>::</font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Parser t ()-<a name="(line245)"></a>reparse ts <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp<font color=Red>-></font> <font color=Cyan>(</font>Right ()<font color=Cyan>,</font> ts<font color=Cyan>++</font>inp<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line246)"></a>-<a name="(line247)"></a><font color=Blue>------------------------------------------------------------------------</font>+<head>+<!-- Generated by HsColour, http://www.cs.york.ac.uk/fp/darcs/hscolour/ -->+<title>src/Text/ParserCombinators/Poly.hs</title>+</head>+<body>+<pre><a name="line-1"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly+<a name="line-2"></a> <font color=Cyan>(</font> <font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Plain+<a name="line-3"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-4"></a>+<a name="line-5"></a><font color=Green><u>import</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Plain </pre>+</body> </html>
docs/haddock/src/Text/ParserCombinators/Poly/Base.html view
@@ -1,194 +1,205 @@ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"> <html>-<pre><a name="(line1)"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base-<a name="(line2)"></a> <font color=Cyan>(</font> <font color=Blue>-- * The PolyParse class</font>-<a name="(line3)"></a> PolyParse<font color=Cyan>(</font><font color=Red>..</font><font color=Cyan>)</font> <font color=Blue>-- class of all monadic two-level-error parsers</font>-<a name="(line4)"></a>-<a name="(line5)"></a> <font color=Blue>-- * Combinators general to all parser types.</font>-<a name="(line6)"></a> <font color=Blue>-- ** Simple combinators</font>-<a name="(line7)"></a> <font color=Cyan>,</font> discard <font color=Blue>-- :: PolyParse p => p a -> p b -> p a</font>-<a name="(line8)"></a> <font color=Blue>-- ** Error-handling</font>-<a name="(line9)"></a> <font color=Cyan>,</font> failBad <font color=Blue>-- :: PolyParse p => String -> p a</font>-<a name="(line10)"></a> <font color=Cyan>,</font> adjustErrBad<font color=Blue>-- :: PolyParse p => p a -> (String->String) -> p a</font>-<a name="(line11)"></a> <font color=Cyan>,</font> indent <font color=Blue>-- :: Int -> String -> String</font>-<a name="(line12)"></a> <font color=Blue>-- ** Choices</font>-<a name="(line13)"></a> <font color=Cyan>,</font> oneOf <font color=Blue>-- :: PolyParse p => [p a] -> p a</font>-<a name="(line14)"></a> <font color=Cyan>,</font> optional <font color=Blue>-- :: PolyParse p => p a -> p (Maybe a)</font>-<a name="(line15)"></a> <font color=Blue>-- ** Sequences</font>-<a name="(line16)"></a> <font color=Cyan>,</font> exactly <font color=Blue>-- :: PolyParse p => Int -> p a -> p [a]</font>-<a name="(line17)"></a> <font color=Cyan>,</font> many <font color=Blue>-- :: PolyParse p => p a -> p [a]</font>-<a name="(line18)"></a> <font color=Cyan>,</font> many1 <font color=Blue>-- :: PolyParse p => p a -> p [a]</font>-<a name="(line19)"></a> <font color=Cyan>,</font> sepBy <font color=Blue>-- :: PolyParse p => p a -> p sep -> p [a]</font>-<a name="(line20)"></a> <font color=Cyan>,</font> sepBy1 <font color=Blue>-- :: PolyParse p => p a -> p sep -> p [a]</font>-<a name="(line21)"></a> <font color=Cyan>,</font> bracketSep <font color=Blue>-- :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a]</font>-<a name="(line22)"></a> <font color=Cyan>,</font> bracket <font color=Blue>-- :: PolyParse p => p bra -> p ket -> p a -> p a</font>-<a name="(line23)"></a> <font color=Cyan>,</font> manyFinally <font color=Blue>-- :: PolyParse p => p a -> p z -> p [a]</font>-<a name="(line24)"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line25)"></a>-<a name="(line26)"></a><a name="PolyParse"></a><font color=Blue>-- | The @PolyParse@ class is an abstraction over all the current</font>-<a name="(line27)"></a><a name="PolyParse"></a><font color=Blue>-- concrete representations of monadic parser combinators in this</font>-<a name="(line28)"></a><a name="PolyParse"></a><font color=Blue>-- package. The common feature is two-level error-handling.</font>-<a name="(line29)"></a><a name="PolyParse"></a><font color=Blue>-- Some primitives must be implemented specific to each parser type</font>-<a name="(line30)"></a><a name="PolyParse"></a><font color=Blue>-- (e.g. depending on whether the parser has a running state, or</font>-<a name="(line31)"></a><a name="PolyParse"></a><font color=Blue>-- whether it is lazy). But given those primitives, large numbers of</font>-<a name="(line32)"></a><a name="PolyParse"></a><font color=Blue>-- combinators do not depend any further on the internal structure of</font>-<a name="(line33)"></a><a name="PolyParse"></a><font color=Blue>-- the particular parser.</font>-<a name="(line34)"></a><a name="PolyParse"></a><font color=Blue>--</font>-<a name="(line35)"></a><a name="PolyParse"></a><font color=Blue>-- There are two additional basic combinators that we expect to be implemented</font>-<a name="(line36)"></a><a name="PolyParse"></a><font color=Blue>-- afresh for every concrete type, but which (for technical reasons)</font>-<a name="(line37)"></a><a name="PolyParse"></a><font color=Blue>-- cannot be class methods. They are @next@ and @satisfy@.</font>-<a name="(line38)"></a><a name="PolyParse"></a><font color=Green><u>class</u></font> <font color=Cyan>(</font>Functor p<font color=Cyan>,</font> Monad p<font color=Cyan>)</font> <font color=Red>=></font> PolyParse p <font color=Green><u>where</u></font>-<a name="(line39)"></a> <font color=Blue>-- | Commit is a way of raising the severity of any errors found within</font>-<a name="(line40)"></a> <font color=Blue>-- its argument. Used in the middle of a parser definition, it means that</font>-<a name="(line41)"></a> <font color=Blue>-- any operations prior to commitment fail softly, but after commitment,</font>-<a name="(line42)"></a> <font color=Blue>-- they fail hard.</font>-<a name="(line43)"></a> commit <font color=Red>::</font> p a <font color=Red>-></font> p a-<a name="(line44)"></a> <font color=Blue>-- | @p `adjustErr` f@ applies the transformation @f@ to any error message</font>-<a name="(line45)"></a> <font color=Blue>-- generated in @p@, having no effect if @p@ succeeds.</font>-<a name="(line46)"></a> adjustErr <font color=Red>::</font> p a <font color=Red>-></font> <font color=Cyan>(</font>String <font color=Red>-></font> String<font color=Cyan>)</font> <font color=Red>-></font> p a-<a name="(line47)"></a> <font color=Blue>-- | @p `onFail` q@ means parse p, unless p fails, in which case</font>-<a name="(line48)"></a> <font color=Blue>-- parse q instead.</font>-<a name="(line49)"></a> <font color=Blue>-- Can be chained together to give multiple attempts to parse something.</font>-<a name="(line50)"></a> <font color=Blue>-- (Note that q could itself be a failing parser, e.g. to change the error</font>-<a name="(line51)"></a> <font color=Blue>-- message from that defined in p to something different.)</font>-<a name="(line52)"></a> <font color=Blue>-- However, a severe failure in p cannot be ignored.</font>-<a name="(line53)"></a> onFail <font color=Red>::</font> p a <font color=Red>-></font> p a <font color=Red>-></font> p a-<a name="(line54)"></a> <font color=Blue>-- | Parse the first alternative that succeeds, but if none succeed,</font>-<a name="(line55)"></a> <font color=Blue>-- report only the severe errors, and if none of those, then report</font>-<a name="(line56)"></a> <font color=Blue>-- all the soft errors.</font>-<a name="(line57)"></a> oneOf' <font color=Red>::</font> <font color=Red>[</font><font color=Cyan>(</font>String<font color=Cyan>,</font> p a<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> p a-<a name="(line58)"></a> <font color=Blue>-- | Apply a parsed function to a parsed value.</font>-<a name="(line59)"></a> <font color=Blue>-- Rather like ordinary function application lifted into parsers.</font>-<a name="(line60)"></a> apply <font color=Red>::</font> p <font color=Cyan>(</font>a<font color=Red>-></font>b<font color=Cyan>)</font> <font color=Red>-></font> p a <font color=Red>-></font> p b-<a name="(line61)"></a> pf <font color=Cyan>`apply`</font> px <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> f <font color=Red><-</font> pf<font color=Cyan>;</font> x <font color=Red><-</font> px<font color=Cyan>;</font> return <font color=Cyan>(</font>f x<font color=Cyan>)</font> <font color=Cyan>}</font>-<a name="(line62)"></a> <font color=Blue>-- note: the Poly.Lazy variants override this defn with a lazier one.</font>-<a name="(line63)"></a>-<a name="(line64)"></a><font color=Green><u>infixl</u></font> <font color=Magenta>6</font> <font color=Cyan>`onFail`</font> <font color=Blue>-- not sure about precedence 6?</font>-<a name="(line65)"></a><font color=Green><u>infixl</u></font> <font color=Magenta>3</font> <font color=Cyan>`apply`</font>-<a name="(line66)"></a><font color=Green><u>infixl</u></font> <font color=Magenta>3</font> <font color=Cyan>`discard`</font>-<a name="(line67)"></a>-<a name="(line68)"></a><font color=Blue>{--<a name="(line69)"></a>-- Combinators we expect most concrete parser types to implement.-<a name="(line70)"></a>-- For technical reasons, they cannot be class members.-<a name="(line71)"></a>-<a name="(line72)"></a>-- | Yield the next token-<a name="(line73)"></a>next :: PolyParse p => p t-<a name="(line74)"></a> -- where t is constrained to be the input token type-<a name="(line75)"></a>-<a name="(line76)"></a>-- | One token satisfying a predicate.-<a name="(line77)"></a>satisfy :: PolyParse p => (t->Bool) -> p t t-<a name="(line78)"></a>satisfy p = do{ x <- next-<a name="(line79)"></a> ; if p x then return x else fail "Parse.satisfy: failed"-<a name="(line80)"></a> }-<a name="(line81)"></a> -- note: must be re-defined for each implementation because-<a name="(line82)"></a> -- its type cannot be expressed otherwise.-<a name="(line83)"></a>-}</font>-<a name="(line84)"></a>-<a name="(line85)"></a><a name="failBad"></a><font color=Blue>-- | When a simple fail is not strong enough, use failBad for emphasis.</font>-<a name="(line86)"></a><font color=Blue>-- An emphasised (severe) error cannot be overridden by choice</font>-<a name="(line87)"></a><font color=Blue>-- operators.</font>-<a name="(line88)"></a>failBad <font color=Red>::</font> PolyParse p <font color=Red>=></font> String <font color=Red>-></font> p a-<a name="(line89)"></a>failBad e <font color=Red>=</font> commit <font color=Cyan>(</font>fail e<font color=Cyan>)</font>-<a name="(line90)"></a>-<a name="(line91)"></a><a name="discard"></a><font color=Blue>-- | @x `discard` y@ parses both x and y, but discards the result of y.</font>-<a name="(line92)"></a><font color=Blue>-- Rather like @const@ lifted into parsers.</font>-<a name="(line93)"></a>discard <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> p b <font color=Red>-></font> p a-<a name="(line94)"></a><a name="discard"></a>px <font color=Cyan>`discard`</font> py <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> px<font color=Cyan>;</font> return <font color=Cyan>(</font>const x<font color=Cyan>)</font> <font color=Cyan>`apply`</font> py<font color=Cyan>;</font> <font color=Cyan>}</font>-<a name="(line95)"></a>-<a name="(line96)"></a><a name="adjustErrBad"></a><font color=Blue>-- | @adjustErrBad@ is just like @adjustErr@ except it also raises the</font>-<a name="(line97)"></a><font color=Blue>-- severity of the error.</font>-<a name="(line98)"></a>adjustErrBad <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> <font color=Cyan>(</font>String<font color=Red>-></font>String<font color=Cyan>)</font> <font color=Red>-></font> p a-<a name="(line99)"></a><a name="adjustErrBad"></a>p <font color=Cyan>`adjustErrBad`</font> f <font color=Red>=</font> commit <font color=Cyan>(</font>p <font color=Cyan>`adjustErr`</font> f<font color=Cyan>)</font>-<a name="(line100)"></a>-<a name="(line101)"></a><a name="oneOf"></a><font color=Blue>-- | Parse the first alternative in the list that succeeds.</font>-<a name="(line102)"></a>oneOf <font color=Red>::</font> PolyParse p <font color=Red>=></font> <font color=Red>[</font>p a<font color=Red>]</font> <font color=Red>-></font> p a-<a name="(line103)"></a>oneOf [] <font color=Red>=</font> fail <font color=Cyan>(</font><font color=Magenta>"failed to parse any of the possible choices"</font><font color=Cyan>)</font>-<a name="(line104)"></a>oneOf <font color=Cyan>(</font>p<font color=Red><b>:</b></font>ps<font color=Cyan>)</font> <font color=Red>=</font> p <font color=Cyan>`onFail`</font> oneOf ps-<a name="(line105)"></a><font color=Blue>--oneOf :: Show t => [Parser t a] -> Parser t a</font>-<a name="(line106)"></a><font color=Blue>--oneOf [] = do { n <- next</font>-<a name="(line107)"></a><font color=Blue>-- ; fail ("failed to parse any of the possible choices"</font>-<a name="(line108)"></a><font color=Blue>-- ++"\n next token is "++show n)</font>-<a name="(line109)"></a><font color=Blue>-- }</font>-<a name="(line110)"></a><font color=Blue>--oneOf (p:ps) = p `onFail` oneOf ps</font>-<a name="(line111)"></a>-<a name="(line112)"></a><a name="indent"></a><font color=Blue>-- | Helper for formatting error messages: indents all lines by a fixed amount.</font>-<a name="(line113)"></a>indent <font color=Red>::</font> Int <font color=Red>-></font> String <font color=Red>-></font> String-<a name="(line114)"></a>indent n <font color=Red>=</font> unlines <font color=Cyan>.</font> map <font color=Cyan>(</font>replicate n <font color=Magenta>' '</font> <font color=Cyan>++</font><font color=Cyan>)</font> <font color=Cyan>.</font> lines-<a name="(line115)"></a>-<a name="(line116)"></a><a name="optional"></a><font color=Blue>-- | 'optional' indicates whether the parser succeeded through the Maybe type.</font>-<a name="(line117)"></a>optional <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> p <font color=Cyan>(</font>Maybe a<font color=Cyan>)</font>-<a name="(line118)"></a>optional p <font color=Red>=</font> fmap Just p <font color=Cyan>`onFail`</font> return Nothing-<a name="(line119)"></a>-<a name="(line120)"></a><a name="exactly"></a><font color=Blue>-- | 'exactly n p' parses precisely n items, using the parser p, in sequence.</font>-<a name="(line121)"></a>exactly <font color=Red>::</font> PolyParse p <font color=Red>=></font> Int <font color=Red>-></font> p a <font color=Red>-></font> p <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line122)"></a>exactly <font color=Magenta>0</font> p <font color=Red>=</font> return []-<a name="(line123)"></a>exactly n p <font color=Red>=</font> return <font color=Cyan>(</font><font color=Red><b>:</b></font><font color=Cyan>)</font> <font color=Cyan>`apply`</font> <font color=Cyan>(</font>p <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Cyan>(</font><font color=Magenta>"When expecting exactly "</font>-<a name="(line124)"></a> <font color=Cyan>++</font>show n<font color=Cyan>++</font><font color=Magenta>" more items"</font><font color=Cyan>)</font><font color=Cyan>++</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line125)"></a> <font color=Cyan>`apply`</font> exactly <font color=Cyan>(</font>n<font color=Blue>-</font><font color=Magenta>1</font><font color=Cyan>)</font> p-<a name="(line126)"></a>-<a name="(line127)"></a><a name="many"></a><font color=Blue>-- | 'many p' parses a list of elements with individual parser p.</font>-<a name="(line128)"></a><font color=Blue>-- Cannot fail, since an empty list is a valid return value.</font>-<a name="(line129)"></a>many <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> p <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line130)"></a>many p <font color=Red>=</font> many1 p <font color=Cyan>`onFail`</font> return []-<a name="(line131)"></a>-<a name="(line132)"></a><a name="many1"></a><font color=Blue>-- | Parse a non-empty list of items.</font>-<a name="(line133)"></a>many1 <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> p <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line134)"></a>many1 p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> p <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Cyan>(</font><font color=Magenta>"In a sequence:\n"</font><font color=Cyan>++</font><font color=Cyan>)</font><font color=Cyan>.</font> indent <font color=Magenta>2</font><font color=Cyan>)</font>-<a name="(line135)"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font><font color=Cyan>)</font> <font color=Cyan>`apply`</font> many p-<a name="(line136)"></a> <font color=Cyan>}</font>-<a name="(line137)"></a><font color=Blue>-- `adjustErr` ("When looking for a non-empty sequence:\n\t"++)</font>-<a name="(line138)"></a>-<a name="(line139)"></a><a name="sepBy"></a><font color=Blue>-- | Parse a list of items separated by discarded junk.</font>-<a name="(line140)"></a>sepBy <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> p sep <font color=Red>-></font> p <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line141)"></a>sepBy p sep <font color=Red>=</font> <font color=Green><u>do</u></font> sepBy1 p sep <font color=Cyan>`onFail`</font> return []-<a name="(line142)"></a>-<a name="(line143)"></a><a name="sepBy1"></a><font color=Blue>-- | Parse a non-empty list of items separated by discarded junk.</font>-<a name="(line144)"></a>sepBy1 <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> p sep <font color=Red>-></font> p <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line145)"></a>sepBy1 p sep <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> p-<a name="(line146)"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font><font color=Cyan>)</font> <font color=Cyan>`apply`</font> many <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>sep<font color=Cyan>;</font> p<font color=Cyan>}</font><font color=Cyan>)</font>-<a name="(line147)"></a> <font color=Cyan>}</font>-<a name="(line148)"></a> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"When looking for a non-empty sequence with separators:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line149)"></a> -<a name="(line150)"></a><a name="bracketSep"></a><font color=Blue>-- | Parse a list of items, discarding the start, end, and separator</font>-<a name="(line151)"></a><font color=Blue>-- items.</font>-<a name="(line152)"></a>bracketSep <font color=Red>::</font> PolyParse p <font color=Red>=></font> p bra <font color=Red>-></font> p sep <font color=Red>-></font> p ket <font color=Red>-></font> p a <font color=Red>-></font> p <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line153)"></a>bracketSep open sep close p <font color=Red>=</font>-<a name="(line154)"></a> <font color=Green><u>do</u></font> <font color=Cyan>{</font> open<font color=Cyan>;</font> close<font color=Cyan>;</font> return [] <font color=Cyan>}</font>-<a name="(line155)"></a> <font color=Cyan>`onFail`</font>-<a name="(line156)"></a> <font color=Green><u>do</u></font> <font color=Cyan>{</font> open <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Missing opening bracket:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line157)"></a> <font color=Cyan>;</font> x <font color=Red><-</font> p <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"After first bracket in a group:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line158)"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font><font color=Cyan>)</font>-<a name="(line159)"></a> <font color=Cyan>`apply`</font> manyFinally <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>sep<font color=Cyan>;</font> p<font color=Cyan>}</font><font color=Cyan>)</font>-<a name="(line160)"></a> <font color=Cyan>(</font>close <font color=Cyan>`adjustErrBad`</font> <font color=Cyan>(</font><font color=Magenta>"When looking for closing bracket:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line161)"></a> <font color=Cyan>}</font>-<a name="(line162)"></a>-<a name="(line163)"></a><a name="bracket"></a><font color=Blue>-- | Parse a bracketed item, discarding the brackets.</font>-<a name="(line164)"></a>bracket <font color=Red>::</font> PolyParse p <font color=Red>=></font> p bra <font color=Red>-></font> p ket <font color=Red>-></font> p a <font color=Red>-></font> p a-<a name="(line165)"></a>bracket open close p <font color=Red>=</font> <font color=Green><u>do</u></font>-<a name="(line166)"></a> <font color=Green><u>do</u></font> <font color=Cyan>{</font> open <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Missing opening bracket:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font>-<a name="(line167)"></a> <font color=Cyan>;</font> p <font color=Cyan>`discard`</font> <font color=Cyan>(</font>close <font color=Cyan>`adjustErrBad`</font> <font color=Cyan>(</font><font color=Magenta>"Missing closing bracket:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line168)"></a> <font color=Cyan>}</font>-<a name="(line169)"></a>-<a name="(line170)"></a><a name="manyFinally"></a><font color=Blue>-- | 'manyFinally e t' parses a possibly-empty sequence of e's,</font>-<a name="(line171)"></a><font color=Blue>-- terminated by a t. The final t is discarded. Any parse failures</font>-<a name="(line172)"></a><font color=Blue>-- could be due either to a badly-formed terminator or a badly-formed</font>-<a name="(line173)"></a><font color=Blue>-- element, so it raises both possible errors.</font>-<a name="(line174)"></a>manyFinally <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> p z <font color=Red>-></font> p <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line175)"></a>manyFinally p t <font color=Red>=</font>-<a name="(line176)"></a> <font color=Cyan>(</font>many p <font color=Cyan>`discard`</font> t<font color=Cyan>)</font>-<a name="(line177)"></a> <font color=Cyan>`onFail`</font>-<a name="(line178)"></a> oneOf' <font color=Red>[</font> <font color=Cyan>(</font><font color=Magenta>"sequence terminator"</font><font color=Cyan>,</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> t<font color=Cyan>;</font> return [] <font color=Cyan>}</font> <font color=Cyan>)</font>-<a name="(line179)"></a> <font color=Cyan>,</font> <font color=Cyan>(</font><font color=Magenta>"item in a sequence"</font><font color=Cyan>,</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> p<font color=Cyan>;</font> return [] <font color=Cyan>}</font> <font color=Cyan>)</font>-<a name="(line180)"></a> <font color=Red>]</font>-<a name="(line181)"></a><font color=Blue>{--<a name="(line182)"></a>manyFinally p t =-<a name="(line183)"></a> do { xs <- many p-<a name="(line184)"></a> ; oneOf' [ ("sequence terminator", do { t; return () } )-<a name="(line185)"></a> , ("item in a sequence", do { p; return () } )-<a name="(line186)"></a> ]-<a name="(line187)"></a> ; return xs-<a name="(line188)"></a> }-<a name="(line189)"></a>-}</font>-<a name="(line190)"></a><font color=Blue>------------------------------------------------------------------------</font>+<head>+<!-- Generated by HsColour, http://www.cs.york.ac.uk/fp/darcs/hscolour/ -->+<title>src/Text/ParserCombinators/Poly/Base.hs</title>+</head>+<body>+<pre><a name="line-1"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base+<a name="line-2"></a> <font color=Cyan>(</font> <font color=Blue>-- * The PolyParse class</font>+<a name="line-3"></a> PolyParse<font color=Cyan>(</font><font color=Red>..</font><font color=Cyan>)</font> <font color=Blue>-- class of all monadic two-level-error parsers</font>+<a name="line-4"></a>+<a name="line-5"></a> <font color=Blue>-- * Combinators general to all parser types.</font>+<a name="line-6"></a> <font color=Blue>-- ** Simple combinators</font>+<a name="line-7"></a> <font color=Cyan>,</font> discard <font color=Blue>-- :: PolyParse p => p a -> p b -> p a</font>+<a name="line-8"></a> <font color=Blue>-- ** Error-handling</font>+<a name="line-9"></a> <font color=Cyan>,</font> failBad <font color=Blue>-- :: PolyParse p => String -> p a</font>+<a name="line-10"></a> <font color=Cyan>,</font> adjustErrBad<font color=Blue>-- :: PolyParse p => p a -> (String->String) -> p a</font>+<a name="line-11"></a> <font color=Cyan>,</font> indent <font color=Blue>-- :: Int -> String -> String</font>+<a name="line-12"></a> <font color=Blue>-- ** Choices</font>+<a name="line-13"></a> <font color=Cyan>,</font> oneOf <font color=Blue>-- :: PolyParse p => [p a] -> p a</font>+<a name="line-14"></a> <font color=Cyan>,</font> optional <font color=Blue>-- :: PolyParse p => p a -> p (Maybe a)</font>+<a name="line-15"></a> <font color=Blue>-- ** Sequences</font>+<a name="line-16"></a> <font color=Cyan>,</font> exactly <font color=Blue>-- :: PolyParse p => Int -> p a -> p [a]</font>+<a name="line-17"></a> <font color=Cyan>,</font> many <font color=Blue>-- :: PolyParse p => p a -> p [a]</font>+<a name="line-18"></a> <font color=Cyan>,</font> many1 <font color=Blue>-- :: PolyParse p => p a -> p [a]</font>+<a name="line-19"></a> <font color=Cyan>,</font> sepBy <font color=Blue>-- :: PolyParse p => p a -> p sep -> p [a]</font>+<a name="line-20"></a> <font color=Cyan>,</font> sepBy1 <font color=Blue>-- :: PolyParse p => p a -> p sep -> p [a]</font>+<a name="line-21"></a> <font color=Cyan>,</font> bracketSep <font color=Blue>-- :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a]</font>+<a name="line-22"></a> <font color=Cyan>,</font> bracket <font color=Blue>-- :: PolyParse p => p bra -> p ket -> p a -> p a</font>+<a name="line-23"></a> <font color=Cyan>,</font> manyFinally <font color=Blue>-- :: PolyParse p => p a -> p z -> p [a]</font>+<a name="line-24"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-25"></a>+<a name="line-26"></a><font color=Magenta><em>#ifdef __NHC__</em></font>+<a name="line-27"></a><font color=Green><u>default</u></font> <font color=Cyan>(</font>Integer<font color=Cyan>,</font>Double<font color=Cyan>,</font>[]<font color=Cyan>)</font> <font color=Blue>-- hack to avoid bizarre type defaulting error</font>+<a name="line-28"></a><font color=Green><u>instance</u></font> PolyParse []+<a name="line-29"></a><font color=Magenta><em>#endif</em></font>+<a name="line-30"></a>+<a name="line-31"></a><a name="PolyParse"></a><font color=Blue>-- | The @PolyParse@ class is an abstraction over all the current</font>+<a name="line-32"></a><a name="PolyParse"></a><font color=Blue>-- concrete representations of monadic parser combinators in this</font>+<a name="line-33"></a><a name="PolyParse"></a><font color=Blue>-- package. The common feature is two-level error-handling.</font>+<a name="line-34"></a><a name="PolyParse"></a><font color=Blue>-- Some primitives must be implemented specific to each parser type</font>+<a name="line-35"></a><a name="PolyParse"></a><font color=Blue>-- (e.g. depending on whether the parser has a running state, or</font>+<a name="line-36"></a><a name="PolyParse"></a><font color=Blue>-- whether it is lazy). But given those primitives, large numbers of</font>+<a name="line-37"></a><a name="PolyParse"></a><font color=Blue>-- combinators do not depend any further on the internal structure of</font>+<a name="line-38"></a><a name="PolyParse"></a><font color=Blue>-- the particular parser.</font>+<a name="line-39"></a><a name="PolyParse"></a><font color=Blue>--</font>+<a name="line-40"></a><a name="PolyParse"></a><font color=Blue>-- There are two additional basic combinators that we expect to be implemented</font>+<a name="line-41"></a><a name="PolyParse"></a><font color=Blue>-- afresh for every concrete type, but which (for technical reasons)</font>+<a name="line-42"></a><a name="PolyParse"></a><font color=Blue>-- cannot be class methods. They are @next@ and @satisfy@.</font>+<a name="line-43"></a><a name="PolyParse"></a><font color=Green><u>class</u></font> <font color=Cyan>(</font>Functor p<font color=Cyan>,</font> Monad p<font color=Cyan>)</font> <font color=Red>=></font> PolyParse p <font color=Green><u>where</u></font>+<a name="line-44"></a> <font color=Blue>-- | Commit is a way of raising the severity of any errors found within</font>+<a name="line-45"></a> <font color=Blue>-- its argument. Used in the middle of a parser definition, it means that</font>+<a name="line-46"></a> <font color=Blue>-- any operations prior to commitment fail softly, but after commitment,</font>+<a name="line-47"></a> <font color=Blue>-- they fail hard.</font>+<a name="line-48"></a> commit <font color=Red>::</font> p a <font color=Red>-></font> p a+<a name="line-49"></a> <font color=Blue>-- | @p `adjustErr` f@ applies the transformation @f@ to any error message</font>+<a name="line-50"></a> <font color=Blue>-- generated in @p@, having no effect if @p@ succeeds.</font>+<a name="line-51"></a> adjustErr <font color=Red>::</font> p a <font color=Red>-></font> <font color=Cyan>(</font>String <font color=Red>-></font> String<font color=Cyan>)</font> <font color=Red>-></font> p a+<a name="line-52"></a> <font color=Blue>-- | @p `onFail` q@ means parse p, unless p fails, in which case</font>+<a name="line-53"></a> <font color=Blue>-- parse q instead.</font>+<a name="line-54"></a> <font color=Blue>-- Can be chained together to give multiple attempts to parse something.</font>+<a name="line-55"></a> <font color=Blue>-- (Note that q could itself be a failing parser, e.g. to change the error</font>+<a name="line-56"></a> <font color=Blue>-- message from that defined in p to something different.)</font>+<a name="line-57"></a> <font color=Blue>-- However, a severe failure in p cannot be ignored.</font>+<a name="line-58"></a> onFail <font color=Red>::</font> p a <font color=Red>-></font> p a <font color=Red>-></font> p a+<a name="line-59"></a> <font color=Blue>-- | Parse the first alternative that succeeds, but if none succeed,</font>+<a name="line-60"></a> <font color=Blue>-- report only the severe errors, and if none of those, then report</font>+<a name="line-61"></a> <font color=Blue>-- all the soft errors.</font>+<a name="line-62"></a> oneOf' <font color=Red>::</font> <font color=Red>[</font><font color=Cyan>(</font>String<font color=Cyan>,</font> p a<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> p a+<a name="line-63"></a> <font color=Blue>-- | Apply a parsed function to a parsed value.</font>+<a name="line-64"></a> <font color=Blue>-- Rather like ordinary function application lifted into parsers.</font>+<a name="line-65"></a> apply <font color=Red>::</font> p <font color=Cyan>(</font>a<font color=Red>-></font>b<font color=Cyan>)</font> <font color=Red>-></font> p a <font color=Red>-></font> p b+<a name="line-66"></a> pf <font color=Cyan>`apply`</font> px <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> f <font color=Red><-</font> pf<font color=Cyan>;</font> x <font color=Red><-</font> px<font color=Cyan>;</font> return <font color=Cyan>(</font>f x<font color=Cyan>)</font> <font color=Cyan>}</font>+<a name="line-67"></a> <font color=Blue>-- note: the Poly.Lazy variants override this defn with a lazier one.</font>+<a name="line-68"></a>+<a name="line-69"></a><font color=Green><u>infixl</u></font> <font color=Magenta>6</font> <font color=Cyan>`onFail`</font> <font color=Blue>-- not sure about precedence 6?</font>+<a name="line-70"></a><font color=Green><u>infixl</u></font> <font color=Magenta>3</font> <font color=Cyan>`apply`</font>+<a name="line-71"></a><font color=Green><u>infixl</u></font> <font color=Magenta>3</font> <font color=Cyan>`discard`</font>+<a name="line-72"></a>+<a name="line-73"></a><font color=Blue>{-+<a name="line-74"></a>-- Combinators we expect most concrete parser types to implement.+<a name="line-75"></a>-- For technical reasons, they cannot be class members.+<a name="line-76"></a>+<a name="line-77"></a>-- | Yield the next token+<a name="line-78"></a>next :: PolyParse p => p t+<a name="line-79"></a> -- where t is constrained to be the input token type+<a name="line-80"></a>+<a name="line-81"></a>-- | One token satisfying a predicate.+<a name="line-82"></a>satisfy :: PolyParse p => (t->Bool) -> p t t+<a name="line-83"></a>satisfy p = do{ x <- next+<a name="line-84"></a> ; if p x then return x else fail "Parse.satisfy: failed"+<a name="line-85"></a> }+<a name="line-86"></a> -- note: must be re-defined for each implementation because+<a name="line-87"></a> -- its type cannot be expressed otherwise.+<a name="line-88"></a>-}</font>+<a name="line-89"></a>+<a name="line-90"></a><a name="failBad"></a><font color=Blue>-- | When a simple fail is not strong enough, use failBad for emphasis.</font>+<a name="line-91"></a><font color=Blue>-- An emphasised (severe) error cannot be overridden by choice</font>+<a name="line-92"></a><font color=Blue>-- operators.</font>+<a name="line-93"></a><font color=Blue>failBad</font> <font color=Red>::</font> PolyParse p <font color=Red>=></font> String <font color=Red>-></font> p a+<a name="line-94"></a><font color=Blue>failBad</font> e <font color=Red>=</font> commit <font color=Cyan>(</font>fail e<font color=Cyan>)</font>+<a name="line-95"></a>+<a name="line-96"></a><a name="discard"></a><font color=Blue>-- | @x `discard` y@ parses both x and y, but discards the result of y.</font>+<a name="line-97"></a><font color=Blue>-- Rather like @const@ lifted into parsers.</font>+<a name="line-98"></a><font color=Blue>discard</font> <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> p b <font color=Red>-></font> p a+<a name="line-99"></a><a name="discard"></a><font color=Blue>px</font> <font color=Cyan>`discard`</font> py <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> px<font color=Cyan>;</font> return <font color=Cyan>(</font>const x<font color=Cyan>)</font> <font color=Cyan>`apply`</font> py<font color=Cyan>;</font> <font color=Cyan>}</font>+<a name="line-100"></a>+<a name="line-101"></a><a name="adjustErrBad"></a><font color=Blue>-- | @adjustErrBad@ is just like @adjustErr@ except it also raises the</font>+<a name="line-102"></a><font color=Blue>-- severity of the error.</font>+<a name="line-103"></a><font color=Blue>adjustErrBad</font> <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> <font color=Cyan>(</font>String<font color=Red>-></font>String<font color=Cyan>)</font> <font color=Red>-></font> p a+<a name="line-104"></a><a name="adjustErrBad"></a><font color=Blue>p</font> <font color=Cyan>`adjustErrBad`</font> f <font color=Red>=</font> commit <font color=Cyan>(</font>p <font color=Cyan>`adjustErr`</font> f<font color=Cyan>)</font>+<a name="line-105"></a>+<a name="line-106"></a><a name="oneOf"></a><font color=Blue>-- | Parse the first alternative in the list that succeeds.</font>+<a name="line-107"></a><font color=Blue>oneOf</font> <font color=Red>::</font> PolyParse p <font color=Red>=></font> <font color=Red>[</font>p a<font color=Red>]</font> <font color=Red>-></font> p a+<a name="line-108"></a><font color=Blue>oneOf</font> [] <font color=Red>=</font> fail <font color=Cyan>(</font><font color=Magenta>"failed to parse any of the possible choices"</font><font color=Cyan>)</font>+<a name="line-109"></a><font color=Blue>oneOf</font> <font color=Cyan>(</font>p<font color=Red><b>:</b></font>ps<font color=Cyan>)</font> <font color=Red>=</font> p <font color=Cyan>`onFail`</font> oneOf ps+<a name="line-110"></a><font color=Blue>--oneOf :: Show t => [Parser t a] -> Parser t a</font>+<a name="line-111"></a><font color=Blue>--oneOf [] = do { n <- next</font>+<a name="line-112"></a><font color=Blue>-- ; fail ("failed to parse any of the possible choices"</font>+<a name="line-113"></a><font color=Blue>-- ++"\n next token is "++show n)</font>+<a name="line-114"></a><font color=Blue>-- }</font>+<a name="line-115"></a><font color=Blue>--oneOf (p:ps) = p `onFail` oneOf ps</font>+<a name="line-116"></a>+<a name="line-117"></a><a name="indent"></a><font color=Blue>-- | Helper for formatting error messages: indents all lines by a fixed amount.</font>+<a name="line-118"></a><font color=Blue>indent</font> <font color=Red>::</font> Int <font color=Red>-></font> String <font color=Red>-></font> String+<a name="line-119"></a><font color=Blue>indent</font> n <font color=Red>=</font> unlines <font color=Cyan>.</font> map <font color=Cyan>(</font>replicate n <font color=Magenta>' '</font> <font color=Cyan>++</font><font color=Cyan>)</font> <font color=Cyan>.</font> lines+<a name="line-120"></a>+<a name="line-121"></a><a name="optional"></a><font color=Blue>-- | 'optional' indicates whether the parser succeeded through the Maybe type.</font>+<a name="line-122"></a><font color=Blue>optional</font> <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> p <font color=Cyan>(</font>Maybe a<font color=Cyan>)</font>+<a name="line-123"></a><font color=Blue>optional</font> p <font color=Red>=</font> fmap Just p <font color=Cyan>`onFail`</font> return Nothing+<a name="line-124"></a>+<a name="line-125"></a><a name="exactly"></a><font color=Blue>-- | 'exactly n p' parses precisely n items, using the parser p, in sequence.</font>+<a name="line-126"></a><font color=Blue>exactly</font> <font color=Red>::</font> PolyParse p <font color=Red>=></font> Int <font color=Red>-></font> p a <font color=Red>-></font> p <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-127"></a><font color=Blue>exactly</font> <font color=Magenta>0</font> p <font color=Red>=</font> return []+<a name="line-128"></a><font color=Blue>exactly</font> n p <font color=Red>=</font> return <font color=Cyan>(</font><font color=Red><b>:</b></font><font color=Cyan>)</font> <font color=Cyan>`apply`</font> <font color=Cyan>(</font>p <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Cyan>(</font><font color=Magenta>"When expecting exactly "</font>+<a name="line-129"></a> <font color=Cyan>++</font>show n<font color=Cyan>++</font><font color=Magenta>" more items"</font><font color=Cyan>)</font><font color=Cyan>++</font><font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-130"></a> <font color=Cyan>`apply`</font> exactly <font color=Cyan>(</font>n<font color=Blue>-</font><font color=Magenta>1</font><font color=Cyan>)</font> p+<a name="line-131"></a>+<a name="line-132"></a><a name="many"></a><font color=Blue>-- | 'many p' parses a list of elements with individual parser p.</font>+<a name="line-133"></a><font color=Blue>-- Cannot fail, since an empty list is a valid return value.</font>+<a name="line-134"></a><font color=Blue>many</font> <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> p <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-135"></a><font color=Blue>many</font> p <font color=Red>=</font> many1 p <font color=Cyan>`onFail`</font> return []+<a name="line-136"></a>+<a name="line-137"></a><a name="many1"></a><font color=Blue>-- | Parse a non-empty list of items.</font>+<a name="line-138"></a><font color=Blue>many1</font> <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> p <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-139"></a><font color=Blue>many1</font> p <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> p <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Cyan>(</font><font color=Magenta>"In a sequence:\n"</font><font color=Cyan>++</font><font color=Cyan>)</font><font color=Cyan>.</font> indent <font color=Magenta>2</font><font color=Cyan>)</font>+<a name="line-140"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font><font color=Cyan>)</font> <font color=Cyan>`apply`</font> many p+<a name="line-141"></a> <font color=Cyan>}</font>+<a name="line-142"></a><font color=Blue>-- `adjustErr` ("When looking for a non-empty sequence:\n\t"++)</font>+<a name="line-143"></a>+<a name="line-144"></a><a name="sepBy"></a><font color=Blue>-- | Parse a list of items separated by discarded junk.</font>+<a name="line-145"></a><font color=Blue>sepBy</font> <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> p sep <font color=Red>-></font> p <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-146"></a><font color=Blue>sepBy</font> p sep <font color=Red>=</font> <font color=Green><u>do</u></font> sepBy1 p sep <font color=Cyan>`onFail`</font> return []+<a name="line-147"></a>+<a name="line-148"></a><a name="sepBy1"></a><font color=Blue>-- | Parse a non-empty list of items separated by discarded junk.</font>+<a name="line-149"></a><font color=Blue>sepBy1</font> <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> p sep <font color=Red>-></font> p <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-150"></a><font color=Blue>sepBy1</font> p sep <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> p+<a name="line-151"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font><font color=Cyan>)</font> <font color=Cyan>`apply`</font> many <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>sep<font color=Cyan>;</font> p<font color=Cyan>}</font><font color=Cyan>)</font>+<a name="line-152"></a> <font color=Cyan>}</font>+<a name="line-153"></a> <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"When looking for a non-empty sequence with separators:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-154"></a> +<a name="line-155"></a><a name="bracketSep"></a><font color=Blue>-- | Parse a list of items, discarding the start, end, and separator</font>+<a name="line-156"></a><font color=Blue>-- items.</font>+<a name="line-157"></a><font color=Blue>bracketSep</font> <font color=Red>::</font> PolyParse p <font color=Red>=></font> p bra <font color=Red>-></font> p sep <font color=Red>-></font> p ket <font color=Red>-></font> p a <font color=Red>-></font> p <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-158"></a><font color=Blue>bracketSep</font> open sep close p <font color=Red>=</font>+<a name="line-159"></a> <font color=Green><u>do</u></font> <font color=Cyan>{</font> open<font color=Cyan>;</font> close<font color=Cyan>;</font> return [] <font color=Cyan>}</font>+<a name="line-160"></a> <font color=Cyan>`onFail`</font>+<a name="line-161"></a> <font color=Green><u>do</u></font> <font color=Cyan>{</font> open <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Missing opening bracket:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-162"></a> <font color=Cyan>;</font> x <font color=Red><-</font> p <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"After first bracket in a group:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-163"></a> <font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font><font color=Cyan>)</font>+<a name="line-164"></a> <font color=Cyan>`apply`</font> manyFinally <font color=Cyan>(</font><font color=Green><u>do</u></font> <font color=Cyan>{</font>sep<font color=Cyan>;</font> p<font color=Cyan>}</font><font color=Cyan>)</font>+<a name="line-165"></a> <font color=Cyan>(</font>close <font color=Cyan>`adjustErrBad`</font> <font color=Cyan>(</font><font color=Magenta>"When looking for closing bracket:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-166"></a> <font color=Cyan>}</font>+<a name="line-167"></a>+<a name="line-168"></a><a name="bracket"></a><font color=Blue>-- | Parse a bracketed item, discarding the brackets.</font>+<a name="line-169"></a><font color=Blue>bracket</font> <font color=Red>::</font> PolyParse p <font color=Red>=></font> p bra <font color=Red>-></font> p ket <font color=Red>-></font> p a <font color=Red>-></font> p a+<a name="line-170"></a><font color=Blue>bracket</font> open close p <font color=Red>=</font> <font color=Green><u>do</u></font>+<a name="line-171"></a> <font color=Green><u>do</u></font> <font color=Cyan>{</font> open <font color=Cyan>`adjustErr`</font> <font color=Cyan>(</font><font color=Magenta>"Missing opening bracket:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font>+<a name="line-172"></a> <font color=Cyan>;</font> p <font color=Cyan>`discard`</font> <font color=Cyan>(</font>close <font color=Cyan>`adjustErrBad`</font> <font color=Cyan>(</font><font color=Magenta>"Missing closing bracket:\n\t"</font><font color=Cyan>++</font><font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-173"></a> <font color=Cyan>}</font>+<a name="line-174"></a>+<a name="line-175"></a><a name="manyFinally"></a><font color=Blue>-- | 'manyFinally e t' parses a possibly-empty sequence of e's,</font>+<a name="line-176"></a><font color=Blue>-- terminated by a t. The final t is discarded. Any parse failures</font>+<a name="line-177"></a><font color=Blue>-- could be due either to a badly-formed terminator or a badly-formed</font>+<a name="line-178"></a><font color=Blue>-- element, so it raises both possible errors.</font>+<a name="line-179"></a><font color=Blue>manyFinally</font> <font color=Red>::</font> PolyParse p <font color=Red>=></font> p a <font color=Red>-></font> p z <font color=Red>-></font> p <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-180"></a><font color=Blue>manyFinally</font> p t <font color=Red>=</font>+<a name="line-181"></a> <font color=Cyan>(</font>many p <font color=Cyan>`discard`</font> t<font color=Cyan>)</font>+<a name="line-182"></a> <font color=Cyan>`onFail`</font>+<a name="line-183"></a> oneOf' <font color=Red>[</font> <font color=Cyan>(</font><font color=Magenta>"sequence terminator"</font><font color=Cyan>,</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> t<font color=Cyan>;</font> return [] <font color=Cyan>}</font> <font color=Cyan>)</font>+<a name="line-184"></a> <font color=Cyan>,</font> <font color=Cyan>(</font><font color=Magenta>"item in a sequence"</font><font color=Cyan>,</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> p<font color=Cyan>;</font> return [] <font color=Cyan>}</font> <font color=Cyan>)</font>+<a name="line-185"></a> <font color=Red>]</font>+<a name="line-186"></a><font color=Blue>{-+<a name="line-187"></a>manyFinally p t =+<a name="line-188"></a> do { xs <- many p+<a name="line-189"></a> ; oneOf' [ ("sequence terminator", do { t; return () } )+<a name="line-190"></a> , ("item in a sequence", do { p; return () } )+<a name="line-191"></a> ]+<a name="line-192"></a> ; return xs+<a name="line-193"></a> }+<a name="line-194"></a>-}</font>+<a name="line-195"></a><font color=Blue>------------------------------------------------------------------------</font> </pre>+</body> </html>
docs/haddock/src/Text/ParserCombinators/Poly/Lazy.html view
@@ -1,140 +1,139 @@ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"> <html>-<pre><a name="(line1)"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Lazy-<a name="(line2)"></a> <font color=Cyan>(</font> <font color=Blue>-- * The Parser datatype.</font>-<a name="(line3)"></a> <font color=Blue>-- $parser</font>-<a name="(line4)"></a> Parser<font color=Cyan>(</font>P<font color=Cyan>)</font> <font color=Blue>-- datatype, instance of: Functor, Monad</font>-<a name="(line5)"></a> <font color=Cyan>,</font> runParser <font color=Blue>-- :: Parser t a -> [t] -> (a, [t])</font>-<a name="(line6)"></a> <font color=Blue>-- ** basic parsers</font>-<a name="(line7)"></a> <font color=Cyan>,</font> next <font color=Blue>-- :: Parser t t</font>-<a name="(line8)"></a> <font color=Cyan>,</font> satisfy <font color=Blue>-- :: (t->Bool) -> Parser t t</font>-<a name="(line9)"></a> <font color=Blue>-- one defn from 'Base' is overridden here, because it depends</font>-<a name="(line10)"></a> <font color=Blue>-- on the representation of the Lazy parser monad</font>-<a name="(line11)"></a> <font color=Cyan>,</font> manyFinally <font color=Blue>-- :: Parser t a -> Parser t z -> Parser t [a]</font>-<a name="(line12)"></a> <font color=Blue>-- ** Re-parsing</font>-<a name="(line13)"></a> <font color=Cyan>,</font> reparse <font color=Blue>-- :: [t] -> Parser t ()</font>-<a name="(line14)"></a> <font color=Blue>-- * Re-export all more general combinators</font>-<a name="(line15)"></a> <font color=Cyan>,</font> <font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base-<a name="(line16)"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line17)"></a>-<a name="(line18)"></a><font color=Green><u>import</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base hiding <font color=Cyan>(</font> manyFinally <font color=Cyan>)</font>-<a name="(line19)"></a>-<a name="(line20)"></a><font color=Magenta><em>#if __GLASGOW_HASKELL__</em></font>-<a name="(line21)"></a><font color=Green><u>import</u></font> Control<font color=Cyan>.</font>Exception hiding <font color=Cyan>(</font>bracket<font color=Cyan>)</font>-<a name="(line22)"></a><a name="throwE"></a>throwE <font color=Red>::</font> String <font color=Red>-></font> a-<a name="(line23)"></a>throwE msg <font color=Red>=</font> throw <font color=Cyan>(</font>ErrorCall msg<font color=Cyan>)</font>-<a name="(line24)"></a><font color=Magenta><em>#else</em></font>-<a name="(line25)"></a>throwE <font color=Red>::</font> String <font color=Red>-></font> a-<a name="(line26)"></a>throwE msg <font color=Red>=</font> error msg-<a name="(line27)"></a><font color=Magenta><em>#endif</em></font>-<a name="(line28)"></a>-<a name="(line29)"></a><font color=Blue>-- $parser</font>-<a name="(line30)"></a><font color=Blue>-- When applied, these parsers do not return explicit failure.</font>-<a name="(line31)"></a><font color=Blue>-- An exception is</font>-<a name="(line32)"></a><font color=Blue>-- raised instead. This allows partial results to be returned</font>-<a name="(line33)"></a><font color=Blue>-- before a full parse is complete.</font>-<a name="(line34)"></a><font color=Blue>-- One of the key ways to ensure that your parser is properly lazy,</font>-<a name="(line35)"></a><font color=Blue>-- is to parse the initial portion of text returning a function, then</font>-<a name="(line36)"></a><font color=Blue>-- use the @apply@ combinator to build the final value.</font>-<a name="(line37)"></a>-<a name="(line38)"></a><a name="Parser"></a><font color=Blue>-- | The @Parser@ datatype is a fairly generic parsing monad with error</font>-<a name="(line39)"></a><a name="Parser"></a><font color=Blue>-- reporting. It can be used for arbitrary token types, not just</font>-<a name="(line40)"></a><a name="Parser"></a><font color=Blue>-- String input. (If you require a running state, use module PolyStateLazy</font>-<a name="(line41)"></a><a name="Parser"></a><font color=Blue>-- instead.)</font>-<a name="(line42)"></a><a name="Parser"></a><font color=Green><u>newtype</u></font> Parser t a <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>Either String a<font color=Cyan>,</font> <font color=Red>[</font>t<font color=Red>]</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line43)"></a>-<a name="(line44)"></a><a name="runParser"></a><font color=Blue>-- | Apply a parser to an input token sequence. The parser cannot return</font>-<a name="(line45)"></a><font color=Blue>-- an error value explicitly, so errors raise an exception. Thus, results</font>-<a name="(line46)"></a><font color=Blue>-- can be partial (lazily constructed, but containing undefined).</font>-<a name="(line47)"></a>runParser <font color=Red>::</font> Parser t a <font color=Red>-></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>a<font color=Cyan>,</font> <font color=Red>[</font>t<font color=Red>]</font><font color=Cyan>)</font>-<a name="(line48)"></a>runParser <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font>-<a name="(line49)"></a> <font color=Cyan>(</font><font color=Red>\</font> <font color=Cyan>(</font>e<font color=Cyan>,</font>ts<font color=Cyan>)</font><font color=Red>-></font> <font color=Cyan>(</font><font color=Green><u>case</u></font> e <font color=Green><u>of</u></font> <font color=Cyan>{</font>Left m<font color=Red>-></font>throwE m<font color=Cyan>;</font> Right x<font color=Red>-></font>x<font color=Cyan>}</font><font color=Cyan>,</font> ts<font color=Cyan>)</font> <font color=Cyan>)</font>-<a name="(line50)"></a> <font color=Cyan>.</font> p-<a name="(line51)"></a>-<a name="(line52)"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Parser t<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line53)"></a> fmap f <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line54)"></a> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line55)"></a> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Right <font color=Cyan>(</font>f x<font color=Cyan>)</font><font color=Cyan>,</font> ts'<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line56)"></a><font color=Green><u>instance</u></font> Monad <font color=Cyan>(</font>Parser t<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line57)"></a> return x <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line58)"></a> <font color=Cyan>(</font>P f<font color=Cyan>)</font> <font color=Cyan>>>=</font> g <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> f ts <font color=Green><u>of</u></font>-<a name="(line59)"></a> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line60)"></a> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P g'<font color=Cyan>)</font> <font color=Red>=</font> g x <font color=Green><u>in</u></font> g' ts'<font color=Cyan>)</font>-<a name="(line61)"></a> fail e <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Cyan>(</font>Left e<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line62)"></a>-<a name="(line63)"></a>-<a name="(line64)"></a><font color=Green><u>instance</u></font> PolyParse <font color=Cyan>(</font>Parser t<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line65)"></a> commit <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line66)"></a> <font color=Cyan>(</font>Left e<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>throwE e<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line67)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line68)"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`onFail`</font> <font color=Cyan>(</font>P q<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line69)"></a> <font color=Cyan>(</font>Left <font color=Green><u>_</u></font><font color=Cyan>,</font> <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> q ts-<a name="(line70)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line71)"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`adjustErr`</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line72)"></a> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>f msg<font color=Cyan>)</font><font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line73)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line74)"></a> oneOf' ps <font color=Red>=</font> accum [] ps-<a name="(line75)"></a> <font color=Green><u>where</u></font> accum errs [] <font color=Red>=</font>-<a name="(line76)"></a> <font color=Green><u>case</u></font> errs <font color=Green><u>of</u></font>-<a name="(line77)"></a> [] <font color=Red>-></font> failBad <font color=Cyan>(</font><font color=Magenta>"internal failure in parser (oneOf'):\n"</font>-<a name="(line78)"></a> <font color=Cyan>++</font>indent <font color=Magenta>2</font> <font color=Cyan>(</font>show <font color=Cyan>(</font>map fst ps<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line79)"></a> <font color=Red>[</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>e<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> fail e-<a name="(line80)"></a> es <font color=Red>-></font> fail <font color=Cyan>(</font><font color=Magenta>"one of the following failures occurred:\n"</font>-<a name="(line81)"></a> <font color=Cyan>++</font>indent <font color=Magenta>2</font> <font color=Cyan>(</font>concatMap showErr <font color=Cyan>(</font>reverse es<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line82)"></a> accum errs <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>P p<font color=Cyan>)</font><font color=Red><b>:</b></font>ps<font color=Cyan>)</font> <font color=Red>=</font>-<a name="(line83)"></a> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line84)"></a> <font color=Cyan>(</font>Left err<font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> accum <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>err<font color=Cyan>)</font><font color=Red><b>:</b></font>errs<font color=Cyan>)</font> ps-<a name="(line85)"></a> <font color=Green><u>in</u></font> p ts-<a name="(line86)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line87)"></a> showErr <font color=Cyan>(</font>name<font color=Cyan>,</font>err<font color=Cyan>)</font> <font color=Red>=</font> name<font color=Cyan>++</font><font color=Magenta>":\n"</font><font color=Cyan>++</font>indent <font color=Magenta>2</font> err-<a name="(line88)"></a> <font color=Blue>-- This version of "apply"</font>-<a name="(line89)"></a> <font color=Blue>-- is strict in the result of the function parser, but</font>-<a name="(line90)"></a> <font color=Blue>-- lazy in the result of the argument parser. (Argument laziness is</font>-<a name="(line91)"></a> <font color=Blue>-- the distinctive feature over other implementations.)</font>-<a name="(line92)"></a> <font color=Cyan>(</font>P pf<font color=Cyan>)</font> <font color=Cyan>`apply`</font> <font color=Cyan>(</font>P px<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font>-<a name="(line93)"></a> <font color=Green><u>case</u></font> pf ts <font color=Green><u>of</u></font>-<a name="(line94)"></a> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line95)"></a> <font color=Cyan>(</font>Right f<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>x'<font color=Cyan>,</font>ts''<font color=Cyan>)</font> <font color=Red>=</font> px ts'-<a name="(line96)"></a> x <font color=Red>=</font> <font color=Green><u>case</u></font> x' <font color=Green><u>of</u></font> <font color=Cyan>{</font> Right x <font color=Red>-></font> x-<a name="(line97)"></a> <font color=Cyan>;</font> Left e <font color=Red>-></font> throwE e <font color=Cyan>}</font>-<a name="(line98)"></a> <font color=Green><u>in</u></font> <font color=Cyan>(</font>Right <font color=Cyan>(</font>f x<font color=Cyan>)</font><font color=Cyan>,</font> ts''<font color=Cyan>)</font> <font color=Cyan>)</font>-<a name="(line99)"></a>-<a name="(line100)"></a><a name="next"></a><font color=Blue>-- | Next token</font>-<a name="(line101)"></a>next <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> ts <font color=Green><u>of</u></font>-<a name="(line102)"></a> [] <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Magenta>"Ran out of input (EOF)"</font><font color=Cyan>,</font> []<font color=Cyan>)</font>-<a name="(line103)"></a> <font color=Cyan>(</font>t<font color=Red><b>:</b></font>ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Right t<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Cyan>)</font>-<a name="(line104)"></a>-<a name="(line105)"></a><a name="satisfy"></a><font color=Blue>-- | One token satifying a predicate</font>-<a name="(line106)"></a>satisfy <font color=Red>::</font> <font color=Cyan>(</font>t<font color=Red>-></font>Bool<font color=Cyan>)</font> <font color=Red>-></font> Parser t t-<a name="(line107)"></a>satisfy p <font color=Red>=</font> <font color=Green><u>do</u></font><font color=Cyan>{</font> x <font color=Red><-</font> next-<a name="(line108)"></a> <font color=Cyan>;</font> <font color=Green><u>if</u></font> p x <font color=Green><u>then</u></font> return x <font color=Green><u>else</u></font> fail <font color=Magenta>"Parse.satisfy: failed"</font>-<a name="(line109)"></a> <font color=Cyan>}</font>-<a name="(line110)"></a>-<a name="(line111)"></a><a name="manyFinally"></a><font color=Blue>-- | 'manyFinally e t' parses a possibly-empty sequence of e's,</font>-<a name="(line112)"></a><font color=Blue>-- terminated by a t. Any parse failures could be due either to</font>-<a name="(line113)"></a><font color=Blue>-- a badly-formed terminator or a badly-formed element, so raise</font>-<a name="(line114)"></a><font color=Blue>-- both possible errors.</font>-<a name="(line115)"></a>manyFinally <font color=Red>::</font> Parser t a <font color=Red>-></font> Parser t z <font color=Red>-></font> Parser t <font color=Red>[</font>a<font color=Red>]</font>-<a name="(line116)"></a>manyFinally pp<font color=Red>@</font><font color=Cyan>(</font>P p<font color=Cyan>)</font> pt<font color=Red>@</font><font color=Cyan>(</font>P t<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts <font color=Red>-></font>-<a name="(line117)"></a> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line118)"></a> <font color=Cyan>(</font>Left e<font color=Cyan>,</font> <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font>-<a name="(line119)"></a> <font color=Green><u>case</u></font> t ts <font color=Green><u>of</u></font>-<a name="(line120)"></a> <font color=Cyan>(</font>Right <font color=Green><u>_</u></font><font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Right []<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line121)"></a> <font color=Cyan>(</font>Left e<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left e<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line122)"></a> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font>-<a name="(line123)"></a> <font color=Green><u>let</u></font> <font color=Cyan>(</font>tail<font color=Cyan>,</font>ts''<font color=Cyan>)</font> <font color=Red>=</font> runParser <font color=Cyan>(</font>manyFinally pp pt<font color=Cyan>)</font> ts'-<a name="(line124)"></a> <font color=Green><u>in</u></font> <font color=Cyan>(</font>Right <font color=Cyan>(</font>x<font color=Red><b>:</b></font>tail<font color=Cyan>)</font><font color=Cyan>,</font> ts''<font color=Cyan>)</font> <font color=Cyan>)</font>-<a name="(line125)"></a>-<a name="(line126)"></a>-<a name="(line127)"></a><a name="reparse"></a><font color=Blue>------------------------------------------------------------------------</font>-<a name="(line128)"></a><font color=Blue>-- | Push some tokens back onto the front of the input stream and reparse.</font>-<a name="(line129)"></a><font color=Blue>-- This is useful e.g. for recursively expanding macros. When the</font>-<a name="(line130)"></a><font color=Blue>-- user-parser recognises a macro use, it can lookup the macro</font>-<a name="(line131)"></a><font color=Blue>-- expansion from the parse state, lex it, and then stuff the</font>-<a name="(line132)"></a><font color=Blue>-- lexed expansion back down into the parser.</font>-<a name="(line133)"></a>reparse <font color=Red>::</font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Parser t ()-<a name="(line134)"></a>reparse ts <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp<font color=Red>-></font> <font color=Cyan>(</font>Right ()<font color=Cyan>,</font> ts<font color=Cyan>++</font>inp<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line135)"></a>-<a name="(line136)"></a><font color=Blue>------------------------------------------------------------------------</font>+<head>+<!-- Generated by HsColour, http://www.cs.york.ac.uk/fp/darcs/hscolour/ -->+<title>src/Text/ParserCombinators/Poly/Lazy.hs</title>+</head>+<body>+<pre><a name="line-1"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Lazy+<a name="line-2"></a> <font color=Cyan>(</font> <font color=Blue>-- * The Parser datatype</font>+<a name="line-3"></a> Parser<font color=Cyan>(</font>P<font color=Cyan>)</font> <font color=Blue>-- datatype, instance of: Functor, Monad, PolyParse</font>+<a name="line-4"></a> <font color=Cyan>,</font> Result<font color=Cyan>(</font><font color=Red>..</font><font color=Cyan>)</font> <font color=Blue>-- internal to the parser monad</font>+<a name="line-5"></a> <font color=Cyan>,</font> runParser <font color=Blue>-- :: Parser t a -> [t] -> (Either String a, [t])</font>+<a name="line-6"></a> <font color=Blue>-- ** basic parsers</font>+<a name="line-7"></a> <font color=Cyan>,</font> next <font color=Blue>-- :: Parser t t</font>+<a name="line-8"></a> <font color=Cyan>,</font> satisfy <font color=Blue>-- :: (t->Bool) -> Parser t t</font>+<a name="line-9"></a>+<a name="line-10"></a> <font color=Blue>-- ** re-parsing</font>+<a name="line-11"></a> <font color=Cyan>,</font> reparse <font color=Blue>-- :: [t] -> Parser t ()</font>+<a name="line-12"></a> <font color=Blue>-- * Re-export all more general combinators</font>+<a name="line-13"></a> <font color=Cyan>,</font> <font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base+<a name="line-14"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-15"></a>+<a name="line-16"></a>+<a name="line-17"></a><font color=Green><u>import</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base+<a name="line-18"></a>+<a name="line-19"></a><font color=Magenta><em>#if __GLASGOW_HASKELL__</em></font>+<a name="line-20"></a><font color=Green><u>import</u></font> Control<font color=Cyan>.</font>Exception hiding <font color=Cyan>(</font>bracket<font color=Cyan>)</font>+<a name="line-21"></a><a name="throwE"></a><font color=Blue>throwE</font> <font color=Red>::</font> String <font color=Red>-></font> a+<a name="line-22"></a><font color=Blue>throwE</font> msg <font color=Red>=</font> throw <font color=Cyan>(</font>ErrorCall msg<font color=Cyan>)</font>+<a name="line-23"></a><font color=Magenta><em>#else</em></font>+<a name="line-24"></a><font color=Blue>throwE</font> <font color=Red>::</font> String <font color=Red>-></font> a+<a name="line-25"></a><font color=Blue>throwE</font> msg <font color=Red>=</font> error msg+<a name="line-26"></a><font color=Magenta><em>#endif</em></font>+<a name="line-27"></a>+<a name="line-28"></a>+<a name="line-29"></a><a name="Parser"></a><font color=Blue>-- | This @Parser@ datatype is a fairly generic parsing monad with error</font>+<a name="line-30"></a><a name="Parser"></a><font color=Blue>-- reporting. It can be used for arbitrary token types, not just</font>+<a name="line-31"></a><a name="Parser"></a><font color=Blue>-- String input. (If you require a running state, use module PolyState</font>+<a name="line-32"></a><a name="Parser"></a><font color=Blue>-- instead)</font>+<a name="line-33"></a><a name="Parser"></a><font color=Green><u>newtype</u></font> Parser t a <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Result <font color=Red>[</font>t<font color=Red>]</font> a<font color=Cyan>)</font>+<a name="line-34"></a>+<a name="line-35"></a><a name="Result"></a><font color=Blue>-- | A return type like Either, that distinguishes not only between</font>+<a name="line-36"></a><a name="Result"></a><font color=Blue>-- right and wrong answers, but also has gradations of wrongness.</font>+<a name="line-37"></a><a name="Result"></a><font color=Blue>-- This should only be used for writing very primitive</font>+<a name="line-38"></a><a name="Result"></a><font color=Blue>-- parsers - really it is an internal detail of the library.</font>+<a name="line-39"></a><a name="Result"></a><font color=Green><u>data</u></font> Result z a <font color=Red>=</font> Success z a+<a name="line-40"></a> <font color=Red>|</font> Failure z String+<a name="line-41"></a> <font color=Red>|</font> Committed <font color=Cyan>(</font>Result z a<font color=Cyan>)</font> <font color=Blue>-- still needed</font>+<a name="line-42"></a>+<a name="line-43"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Result z<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-44"></a> fmap f <font color=Cyan>(</font>Success z a<font color=Cyan>)</font> <font color=Red>=</font> Success z <font color=Cyan>(</font>f a<font color=Cyan>)</font>+<a name="line-45"></a> fmap f <font color=Cyan>(</font>Failure z e<font color=Cyan>)</font> <font color=Red>=</font> Failure z e+<a name="line-46"></a> fmap f <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> Committed <font color=Cyan>(</font>fmap f r<font color=Cyan>)</font>+<a name="line-47"></a>+<a name="line-48"></a><a name="runParser"></a><font color=Blue>-- | Apply a parser to an input token sequence.</font>+<a name="line-49"></a><font color=Blue>runParser</font> <font color=Red>::</font> Parser t a <font color=Red>-></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>a<font color=Cyan>,</font> <font color=Red>[</font>t<font color=Red>]</font><font color=Cyan>)</font>+<a name="line-50"></a><font color=Blue>runParser</font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> fromResult <font color=Cyan>.</font> p+<a name="line-51"></a> <font color=Green><u>where</u></font>+<a name="line-52"></a> fromResult <font color=Red>::</font> Result z a <font color=Red>-></font> <font color=Cyan>(</font>a<font color=Cyan>,</font> z<font color=Cyan>)</font>+<a name="line-53"></a> fromResult <font color=Cyan>(</font>Success z a<font color=Cyan>)</font> <font color=Red>=</font> <font color=Cyan>(</font>a<font color=Cyan>,</font> z<font color=Cyan>)</font>+<a name="line-54"></a> fromResult <font color=Cyan>(</font>Failure z e<font color=Cyan>)</font> <font color=Red>=</font> throwE e+<a name="line-55"></a> fromResult <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> fromResult r+<a name="line-56"></a>+<a name="line-57"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Parser t<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-58"></a> fmap f <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font>fmap f <font color=Cyan>.</font> p<font color=Cyan>)</font>+<a name="line-59"></a>+<a name="line-60"></a><font color=Green><u>instance</u></font> Monad <font color=Cyan>(</font>Parser t<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-61"></a> return x <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> Success ts x<font color=Cyan>)</font>+<a name="line-62"></a> fail e <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> Failure ts e<font color=Cyan>)</font>+<a name="line-63"></a> <font color=Cyan>(</font>P f<font color=Cyan>)</font> <font color=Cyan>>>=</font> g <font color=Red>=</font> P <font color=Cyan>(</font>continue <font color=Cyan>.</font> f<font color=Cyan>)</font>+<a name="line-64"></a> <font color=Green><u>where</u></font>+<a name="line-65"></a> continue <font color=Cyan>(</font>Success ts x<font color=Cyan>)</font> <font color=Red>=</font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P g'<font color=Cyan>)</font> <font color=Red>=</font> g x <font color=Green><u>in</u></font> g' ts+<a name="line-66"></a> continue <font color=Cyan>(</font>Committed <font color=Cyan>(</font>Committed r<font color=Cyan>)</font><font color=Cyan>)</font> <font color=Red>=</font> continue <font color=Cyan>(</font>Committed r<font color=Cyan>)</font>+<a name="line-67"></a> continue <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> Committed <font color=Cyan>(</font>continue r<font color=Cyan>)</font>+<a name="line-68"></a> continue <font color=Cyan>(</font>Failure ts e<font color=Cyan>)</font> <font color=Red>=</font> Failure ts e+<a name="line-69"></a>+<a name="line-70"></a><font color=Green><u>instance</u></font> PolyParse <font color=Cyan>(</font>Parser t<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-71"></a> commit <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font>Committed <font color=Cyan>.</font> p<font color=Cyan>)</font>+<a name="line-72"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`adjustErr`</font> f <font color=Red>=</font> P <font color=Cyan>(</font>adjust <font color=Cyan>.</font> p<font color=Cyan>)</font>+<a name="line-73"></a> <font color=Green><u>where</u></font>+<a name="line-74"></a> adjust <font color=Cyan>(</font>Failure z e<font color=Cyan>)</font> <font color=Red>=</font> Failure z <font color=Cyan>(</font>f e<font color=Cyan>)</font>+<a name="line-75"></a> adjust <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> Committed <font color=Cyan>(</font>adjust r<font color=Cyan>)</font>+<a name="line-76"></a> adjust good <font color=Red>=</font> good+<a name="line-77"></a>+<a name="line-78"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`onFail`</font> <font color=Cyan>(</font>P q<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> continue ts <font color=Cyan>$</font> p ts<font color=Cyan>)</font>+<a name="line-79"></a> <font color=Green><u>where</u></font>+<a name="line-80"></a> continue ts <font color=Cyan>(</font>Failure z e<font color=Cyan>)</font> <font color=Red>=</font> q ts+<a name="line-81"></a> <font color=Blue>-- continue _ (Committed r) = r -- no, remain Committed</font>+<a name="line-82"></a> continue <font color=Green><u>_</u></font> r <font color=Red>=</font> r+<a name="line-83"></a>+<a name="line-84"></a> oneOf' <font color=Red>=</font> accum []+<a name="line-85"></a> <font color=Green><u>where</u></font> accum errs [] <font color=Red>=</font>+<a name="line-86"></a> fail <font color=Cyan>(</font><font color=Magenta>"failed to parse any of the possible choices:\n"</font>+<a name="line-87"></a> <font color=Cyan>++</font>indent <font color=Magenta>2</font> <font color=Cyan>(</font>concatMap showErr <font color=Cyan>(</font>reverse errs<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-88"></a> accum errs <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>P p<font color=Cyan>)</font><font color=Red><b>:</b></font>ps<font color=Cyan>)</font> <font color=Red>=</font>+<a name="line-89"></a> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>+<a name="line-90"></a> Failure <font color=Green><u>_</u></font> err <font color=Red>-></font>+<a name="line-91"></a> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> accum <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>err<font color=Cyan>)</font><font color=Red><b>:</b></font>errs<font color=Cyan>)</font> ps+<a name="line-92"></a> <font color=Green><u>in</u></font> p ts+<a name="line-93"></a> r<font color=Red>@</font><font color=Cyan>(</font>Success z a<font color=Cyan>)</font> <font color=Red>-></font> r+<a name="line-94"></a> r<font color=Red>@</font><font color=Cyan>(</font>Committed <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> r <font color=Cyan>)</font>+<a name="line-95"></a> showErr <font color=Cyan>(</font>name<font color=Cyan>,</font>err<font color=Cyan>)</font> <font color=Red>=</font> name<font color=Cyan>++</font><font color=Magenta>":\n"</font><font color=Cyan>++</font>indent <font color=Magenta>2</font> err+<a name="line-96"></a>+<a name="line-97"></a> <font color=Blue>-- Apply a parsed function to a parsed value. This version</font>+<a name="line-98"></a> <font color=Blue>-- is strict in the result of the function parser, but</font>+<a name="line-99"></a> <font color=Blue>-- lazy in the result of the argument parser. (Argument laziness is</font>+<a name="line-100"></a> <font color=Blue>-- the distinctive feature over other implementations.)</font>+<a name="line-101"></a> <font color=Cyan>(</font>P pf<font color=Cyan>)</font> <font color=Cyan>`apply`</font> px <font color=Red>=</font> P <font color=Cyan>(</font>continue <font color=Cyan>.</font> pf<font color=Cyan>)</font>+<a name="line-102"></a> <font color=Green><u>where</u></font>+<a name="line-103"></a> continue <font color=Cyan>(</font>Success z f<font color=Cyan>)</font> <font color=Red>=</font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>x<font color=Cyan>,</font>z'<font color=Cyan>)</font> <font color=Red>=</font> runParser px z+<a name="line-104"></a> <font color=Green><u>in</u></font> Success z' <font color=Cyan>(</font>f x<font color=Cyan>)</font>+<a name="line-105"></a> continue <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> Committed <font color=Cyan>(</font>continue r<font color=Cyan>)</font>+<a name="line-106"></a> continue <font color=Cyan>(</font>Failure z e<font color=Cyan>)</font> <font color=Red>=</font> Failure z e+<a name="line-107"></a>+<a name="line-108"></a>+<a name="line-109"></a><a name="next"></a><font color=Blue>------------------------------------------------------------------------</font>+<a name="line-110"></a><font color=Blue>next</font> <font color=Red>::</font> Parser t t+<a name="line-111"></a><font color=Blue>next</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> ts <font color=Green><u>of</u></font>+<a name="line-112"></a> [] <font color=Red>-></font> Failure [] <font color=Magenta>"Ran out of input (EOF)"</font>+<a name="line-113"></a> <font color=Cyan>(</font>t<font color=Red><b>:</b></font>ts'<font color=Cyan>)</font> <font color=Red>-></font> Success ts' t <font color=Cyan>)</font>+<a name="line-114"></a>+<a name="line-115"></a><a name="satisfy"></a><font color=Blue>satisfy</font> <font color=Red>::</font> <font color=Cyan>(</font>t<font color=Red>-></font>Bool<font color=Cyan>)</font> <font color=Red>-></font> Parser t t+<a name="line-116"></a><font color=Blue>satisfy</font> pred <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> next+<a name="line-117"></a> <font color=Cyan>;</font> <font color=Green><u>if</u></font> pred x <font color=Green><u>then</u></font> return x <font color=Green><u>else</u></font> fail <font color=Magenta>"Parse.satisfy: failed"</font>+<a name="line-118"></a> <font color=Cyan>}</font>+<a name="line-119"></a>+<a name="line-120"></a><a name="reparse"></a><font color=Blue>------------------------------------------------------------------------</font>+<a name="line-121"></a><font color=Blue>-- | Push some tokens back onto the front of the input stream and reparse.</font>+<a name="line-122"></a><font color=Blue>-- This is useful e.g. for recursively expanding macros. When the</font>+<a name="line-123"></a><font color=Blue>-- user-parser recognises a macro use, it can lookup the macro</font>+<a name="line-124"></a><font color=Blue>-- expansion from the parse state, lex it, and then stuff the</font>+<a name="line-125"></a><font color=Blue>-- lexed expansion back down into the parser.</font>+<a name="line-126"></a><font color=Blue>reparse</font> <font color=Red>::</font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Parser t ()+<a name="line-127"></a><font color=Blue>reparse</font> ts <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp<font color=Red>-></font> Success <font color=Cyan>(</font>ts<font color=Cyan>++</font>inp<font color=Cyan>)</font> ()<font color=Cyan>)</font>+<a name="line-128"></a>+<a name="line-129"></a><font color=Blue>------------------------------------------------------------------------</font> </pre>+</body> </html>
docs/haddock/src/Text/ParserCombinators/Poly/Plain.html view
@@ -1,96 +1,117 @@ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"> <html>-<pre><a name="(line1)"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Plain-<a name="(line2)"></a> <font color=Cyan>(</font> <font color=Blue>-- * The Parser datatype</font>-<a name="(line3)"></a> Parser<font color=Cyan>(</font>P<font color=Cyan>)</font> <font color=Blue>-- datatype, instance of: Functor, Monad, PolyParse</font>-<a name="(line4)"></a> <font color=Cyan>,</font> runParser <font color=Blue>-- :: Parser t a -> [t] -> (Either String a, [t])</font>-<a name="(line5)"></a> <font color=Blue>-- ** basic parsers</font>-<a name="(line6)"></a> <font color=Cyan>,</font> next <font color=Blue>-- :: Parser t t</font>-<a name="(line7)"></a> <font color=Cyan>,</font> satisfy <font color=Blue>-- :: (t->Bool) -> Parser t t</font>-<a name="(line8)"></a>-<a name="(line9)"></a> <font color=Blue>-- ** re-parsing</font>-<a name="(line10)"></a> <font color=Cyan>,</font> reparse <font color=Blue>-- :: [t] -> Parser t ()</font>-<a name="(line11)"></a> <font color=Blue>-- * Re-export all more general combinators</font>-<a name="(line12)"></a> <font color=Cyan>,</font> <font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base-<a name="(line13)"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line14)"></a>-<a name="(line15)"></a>-<a name="(line16)"></a><font color=Green><u>import</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base-<a name="(line17)"></a>-<a name="(line18)"></a><a name="Parser"></a><font color=Blue>-- | This @Parser@ datatype is a fairly generic parsing monad with error</font>-<a name="(line19)"></a><a name="Parser"></a><font color=Blue>-- reporting. It can be used for arbitrary token types, not just</font>-<a name="(line20)"></a><a name="Parser"></a><font color=Blue>-- String input. (If you require a running state, use module PolyState</font>-<a name="(line21)"></a><a name="Parser"></a><font color=Blue>-- instead)</font>-<a name="(line22)"></a><a name="Parser"></a><font color=Green><u>newtype</u></font> Parser t a <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>EitherE String a<font color=Cyan>,</font> <font color=Red>[</font>t<font color=Red>]</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line23)"></a>-<a name="(line24)"></a><a name="EitherE"></a><font color=Blue>-- A return type like Either, that distinguishes not only between</font>-<a name="(line25)"></a><a name="EitherE"></a><font color=Blue>-- right and wrong answers, but also has gradations of wrongness.</font>-<a name="(line26)"></a><a name="EitherE"></a><font color=Green><u>type</u></font> EitherE a b <font color=Red>=</font> Either <font color=Cyan>(</font>Bool<font color=Cyan>,</font>a<font color=Cyan>)</font> b-<a name="(line27)"></a>-<a name="(line28)"></a><a name="runParser"></a><font color=Blue>-- | Apply a parser to an input token sequence.</font>-<a name="(line29)"></a>runParser <font color=Red>::</font> Parser t a <font color=Red>-></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>Either String a<font color=Cyan>,</font> <font color=Red>[</font>t<font color=Red>]</font><font color=Cyan>)</font>-<a name="(line30)"></a>runParser <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font>-<a name="(line31)"></a> <font color=Cyan>(</font><font color=Red>\</font> <font color=Cyan>(</font>e<font color=Cyan>,</font>ts<font color=Cyan>)</font><font color=Red>-></font> <font color=Cyan>(</font><font color=Green><u>case</u></font> e <font color=Green><u>of</u></font> <font color=Cyan>{</font>Left <font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>m<font color=Cyan>)</font><font color=Red>-></font>Left m<font color=Cyan>;</font> Right m<font color=Red>-></font>Right m<font color=Cyan>}</font><font color=Cyan>,</font> ts<font color=Cyan>)</font> <font color=Cyan>)</font>-<a name="(line32)"></a> <font color=Cyan>.</font> p-<a name="(line33)"></a>-<a name="(line34)"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Parser t<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line35)"></a> fmap f <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line36)"></a> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line37)"></a> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Right <font color=Cyan>(</font>f x<font color=Cyan>)</font><font color=Cyan>,</font> ts'<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line38)"></a><font color=Green><u>instance</u></font> Monad <font color=Cyan>(</font>Parser t<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line39)"></a> return x <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line40)"></a> <font color=Cyan>(</font>P f<font color=Cyan>)</font> <font color=Cyan>>>=</font> g <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> f ts <font color=Green><u>of</u></font>-<a name="(line41)"></a> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line42)"></a> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P g'<font color=Cyan>)</font> <font color=Red>=</font> g x <font color=Green><u>in</u></font> g' ts'<font color=Cyan>)</font>-<a name="(line43)"></a> fail e <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>False<font color=Cyan>,</font>e<font color=Cyan>)</font><font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line44)"></a>-<a name="(line45)"></a><font color=Green><u>instance</u></font> PolyParse <font color=Cyan>(</font>Parser t<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line46)"></a> commit <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line47)"></a> <font color=Cyan>(</font>Left <font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>e<font color=Cyan>)</font><font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>True<font color=Cyan>,</font>e<font color=Cyan>)</font><font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line48)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line49)"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`adjustErr`</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line50)"></a> <font color=Cyan>(</font>Left <font color=Cyan>(</font>b<font color=Cyan>,</font>msg<font color=Cyan>)</font><font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>b<font color=Cyan>,</font><font color=Cyan>(</font>f msg<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line51)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line52)"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`onFail`</font> <font color=Cyan>(</font>P q<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line53)"></a> r<font color=Red>@</font><font color=Cyan>(</font>Left <font color=Cyan>(</font>True<font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>)</font><font color=Cyan>,</font> <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> r-<a name="(line54)"></a> <font color=Cyan>(</font>Left <font color=Green><u>_</u></font><font color=Cyan>,</font> <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> q ts-<a name="(line55)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line56)"></a> oneOf' <font color=Red>=</font> accum []-<a name="(line57)"></a> <font color=Green><u>where</u></font> accum errs [] <font color=Red>=</font>-<a name="(line58)"></a> <font color=Green><u>case</u></font> filter isBad errs <font color=Green><u>of</u></font>-<a name="(line59)"></a> [] <font color=Red>-></font> fail <font color=Cyan>(</font><font color=Magenta>"failed to parse any of the possible choices:\n"</font>-<a name="(line60)"></a> <font color=Cyan>++</font>indent <font color=Magenta>2</font> <font color=Cyan>(</font>concatMap showErr <font color=Cyan>(</font>reverse errs<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line61)"></a> <font color=Red>[</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>e<font color=Cyan>)</font><font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> failBad e-<a name="(line62)"></a> es <font color=Red>-></font> failBad <font color=Cyan>(</font><font color=Magenta>"one of the following failures occurred:\n"</font>-<a name="(line63)"></a> <font color=Cyan>++</font>indent <font color=Magenta>2</font> <font color=Cyan>(</font>concatMap showErr <font color=Cyan>(</font>reverse es<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line64)"></a> accum errs <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>P p<font color=Cyan>)</font><font color=Red><b>:</b></font>ps<font color=Cyan>)</font> <font color=Red>=</font>-<a name="(line65)"></a> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>-<a name="(line66)"></a> <font color=Cyan>(</font>Left err<font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> accum <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>err<font color=Cyan>)</font><font color=Red><b>:</b></font>errs<font color=Cyan>)</font> ps-<a name="(line67)"></a> <font color=Green><u>in</u></font> p ts-<a name="(line68)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line69)"></a> showErr <font color=Cyan>(</font>name<font color=Cyan>,</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>err<font color=Cyan>)</font><font color=Cyan>)</font> <font color=Red>=</font> name<font color=Cyan>++</font><font color=Magenta>":\n"</font><font color=Cyan>++</font>indent <font color=Magenta>2</font> err-<a name="(line70)"></a> isBad <font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font><font color=Cyan>(</font>b<font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>)</font><font color=Cyan>)</font> <font color=Red>=</font> b-<a name="(line71)"></a>-<a name="(line72)"></a><a name="next"></a><font color=Blue>------------------------------------------------------------------------</font>-<a name="(line73)"></a>next <font color=Red>::</font> Parser t t-<a name="(line74)"></a>next <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> ts <font color=Green><u>of</u></font>-<a name="(line75)"></a> [] <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>False<font color=Cyan>,</font><font color=Magenta>"Ran out of input (EOF)"</font><font color=Cyan>)</font><font color=Cyan>,</font> []<font color=Cyan>)</font>-<a name="(line76)"></a> <font color=Cyan>(</font>t<font color=Red><b>:</b></font>ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Right t<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Cyan>)</font>-<a name="(line77)"></a>-<a name="(line78)"></a><a name="satisfy"></a>satisfy <font color=Red>::</font> <font color=Cyan>(</font>t<font color=Red>-></font>Bool<font color=Cyan>)</font> <font color=Red>-></font> Parser t t-<a name="(line79)"></a>satisfy pred <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> next-<a name="(line80)"></a> <font color=Cyan>;</font> <font color=Green><u>if</u></font> pred x <font color=Green><u>then</u></font> return x <font color=Green><u>else</u></font> fail <font color=Magenta>"Parse.satisfy: failed"</font>-<a name="(line81)"></a> <font color=Cyan>}</font>-<a name="(line82)"></a>-<a name="(line83)"></a><a name="reparse"></a><font color=Blue>------------------------------------------------------------------------</font>-<a name="(line84)"></a><font color=Blue>-- | Push some tokens back onto the front of the input stream and reparse.</font>-<a name="(line85)"></a><font color=Blue>-- This is useful e.g. for recursively expanding macros. When the</font>-<a name="(line86)"></a><font color=Blue>-- user-parser recognises a macro use, it can lookup the macro</font>-<a name="(line87)"></a><font color=Blue>-- expansion from the parse state, lex it, and then stuff the</font>-<a name="(line88)"></a><font color=Blue>-- lexed expansion back down into the parser.</font>-<a name="(line89)"></a>reparse <font color=Red>::</font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Parser t ()-<a name="(line90)"></a>reparse ts <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp<font color=Red>-></font> <font color=Cyan>(</font>Right ()<font color=Cyan>,</font> ts<font color=Cyan>++</font>inp<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line91)"></a>-<a name="(line92)"></a><font color=Blue>------------------------------------------------------------------------</font>+<head>+<!-- Generated by HsColour, http://www.cs.york.ac.uk/fp/darcs/hscolour/ -->+<title>src/Text/ParserCombinators/Poly/Plain.hs</title>+</head>+<body>+<pre><a name="line-1"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Plain+<a name="line-2"></a> <font color=Cyan>(</font> <font color=Blue>-- * The Parser datatype</font>+<a name="line-3"></a> Parser<font color=Cyan>(</font>P<font color=Cyan>)</font> <font color=Blue>-- datatype, instance of: Functor, Monad, PolyParse</font>+<a name="line-4"></a> <font color=Cyan>,</font> Result<font color=Cyan>(</font><font color=Red>..</font><font color=Cyan>)</font> <font color=Blue>-- internal to the Parser Monad.</font>+<a name="line-5"></a> <font color=Cyan>,</font> runParser <font color=Blue>-- :: Parser t a -> [t] -> (Either String a, [t])</font>+<a name="line-6"></a> <font color=Blue>-- ** basic parsers</font>+<a name="line-7"></a> <font color=Cyan>,</font> next <font color=Blue>-- :: Parser t t</font>+<a name="line-8"></a> <font color=Cyan>,</font> satisfy <font color=Blue>-- :: (t->Bool) -> Parser t t</font>+<a name="line-9"></a>+<a name="line-10"></a> <font color=Blue>-- ** re-parsing</font>+<a name="line-11"></a> <font color=Cyan>,</font> reparse <font color=Blue>-- :: [t] -> Parser t ()</font>+<a name="line-12"></a> <font color=Blue>-- * Re-export all more general combinators</font>+<a name="line-13"></a> <font color=Cyan>,</font> <font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base+<a name="line-14"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-15"></a>+<a name="line-16"></a>+<a name="line-17"></a><font color=Green><u>import</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base+<a name="line-18"></a>+<a name="line-19"></a><a name="Parser"></a><font color=Blue>-- | This @Parser@ datatype is a fairly generic parsing monad with error</font>+<a name="line-20"></a><a name="Parser"></a><font color=Blue>-- reporting. It can be used for arbitrary token types, not just</font>+<a name="line-21"></a><a name="Parser"></a><font color=Blue>-- String input. (If you require a running state, use module PolyState</font>+<a name="line-22"></a><a name="Parser"></a><font color=Blue>-- instead)</font>+<a name="line-23"></a><a name="Parser"></a><font color=Green><u>newtype</u></font> Parser t a <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Result <font color=Red>[</font>t<font color=Red>]</font> a<font color=Cyan>)</font>+<a name="line-24"></a>+<a name="line-25"></a><a name="Result"></a><font color=Blue>-- | A return type like Either, that distinguishes not only between</font>+<a name="line-26"></a><a name="Result"></a><font color=Blue>-- right and wrong answers, but also has commitment, so that a failure</font>+<a name="line-27"></a><a name="Result"></a><font color=Blue>-- cannot be undone. This should only be used for writing very primitive</font>+<a name="line-28"></a><a name="Result"></a><font color=Blue>-- parsers - really it is an internal detail of the library.</font>+<a name="line-29"></a><a name="Result"></a><font color=Green><u>data</u></font> Result z a <font color=Red>=</font> Success z a+<a name="line-30"></a> <font color=Red>|</font> Failure z String+<a name="line-31"></a> <font color=Red>|</font> Committed <font color=Cyan>(</font>Result z a<font color=Cyan>)</font>+<a name="line-32"></a>+<a name="line-33"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Result z<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-34"></a> fmap f <font color=Cyan>(</font>Success z a<font color=Cyan>)</font> <font color=Red>=</font> Success z <font color=Cyan>(</font>f a<font color=Cyan>)</font>+<a name="line-35"></a> fmap f <font color=Cyan>(</font>Failure z e<font color=Cyan>)</font> <font color=Red>=</font> Failure z e+<a name="line-36"></a> fmap f <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> Committed <font color=Cyan>(</font>fmap f r<font color=Cyan>)</font>+<a name="line-37"></a>+<a name="line-38"></a><a name="runParser"></a><font color=Blue>-- | Apply a parser to an input token sequence.</font>+<a name="line-39"></a><font color=Blue>runParser</font> <font color=Red>::</font> Parser t a <font color=Red>-></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>Either String a<font color=Cyan>,</font> <font color=Red>[</font>t<font color=Red>]</font><font color=Cyan>)</font>+<a name="line-40"></a><font color=Blue>runParser</font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> resultToEither <font color=Cyan>.</font> p+<a name="line-41"></a> <font color=Green><u>where</u></font>+<a name="line-42"></a> resultToEither <font color=Red>::</font> Result z a <font color=Red>-></font> <font color=Cyan>(</font>Either String a<font color=Cyan>,</font> z<font color=Cyan>)</font>+<a name="line-43"></a> resultToEither <font color=Cyan>(</font>Success z a<font color=Cyan>)</font> <font color=Red>=</font> <font color=Cyan>(</font>Right a<font color=Cyan>,</font> z<font color=Cyan>)</font>+<a name="line-44"></a> resultToEither <font color=Cyan>(</font>Failure z e<font color=Cyan>)</font> <font color=Red>=</font> <font color=Cyan>(</font>Left e<font color=Cyan>,</font> z<font color=Cyan>)</font>+<a name="line-45"></a> resultToEither <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> resultToEither r+<a name="line-46"></a>+<a name="line-47"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Parser t<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-48"></a> fmap f <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font>fmap f <font color=Cyan>.</font> p<font color=Cyan>)</font>+<a name="line-49"></a>+<a name="line-50"></a><font color=Green><u>instance</u></font> Monad <font color=Cyan>(</font>Parser t<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-51"></a> return x <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> Success ts x<font color=Cyan>)</font>+<a name="line-52"></a> fail e <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> Failure ts e<font color=Cyan>)</font>+<a name="line-53"></a> <font color=Cyan>(</font>P f<font color=Cyan>)</font> <font color=Cyan>>>=</font> g <font color=Red>=</font> P <font color=Cyan>(</font>continue <font color=Cyan>.</font> f<font color=Cyan>)</font>+<a name="line-54"></a> <font color=Green><u>where</u></font>+<a name="line-55"></a> continue <font color=Cyan>(</font>Success ts x<font color=Cyan>)</font> <font color=Red>=</font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P g'<font color=Cyan>)</font> <font color=Red>=</font> g x <font color=Green><u>in</u></font> g' ts+<a name="line-56"></a> continue <font color=Cyan>(</font>Committed <font color=Cyan>(</font>Committed r<font color=Cyan>)</font><font color=Cyan>)</font> <font color=Red>=</font> continue <font color=Cyan>(</font>Committed r<font color=Cyan>)</font>+<a name="line-57"></a> continue <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> Committed <font color=Cyan>(</font>continue r<font color=Cyan>)</font>+<a name="line-58"></a> continue <font color=Cyan>(</font>Failure ts e<font color=Cyan>)</font> <font color=Red>=</font> Failure ts e+<a name="line-59"></a>+<a name="line-60"></a><font color=Green><u>instance</u></font> PolyParse <font color=Cyan>(</font>Parser t<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-61"></a> commit <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font>Committed <font color=Cyan>.</font> p<font color=Cyan>)</font>+<a name="line-62"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`adjustErr`</font> f <font color=Red>=</font> P <font color=Cyan>(</font>adjust <font color=Cyan>.</font> p<font color=Cyan>)</font>+<a name="line-63"></a> <font color=Green><u>where</u></font>+<a name="line-64"></a> adjust <font color=Cyan>(</font>Failure z e<font color=Cyan>)</font> <font color=Red>=</font> Failure z <font color=Cyan>(</font>f e<font color=Cyan>)</font>+<a name="line-65"></a> adjust <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> Committed <font color=Cyan>(</font>adjust r<font color=Cyan>)</font>+<a name="line-66"></a> adjust good <font color=Red>=</font> good+<a name="line-67"></a>+<a name="line-68"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`onFail`</font> <font color=Cyan>(</font>P q<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> continue ts <font color=Cyan>$</font> p ts<font color=Cyan>)</font>+<a name="line-69"></a> <font color=Green><u>where</u></font>+<a name="line-70"></a> continue ts <font color=Cyan>(</font>Failure z e<font color=Cyan>)</font> <font color=Red>=</font> q ts+<a name="line-71"></a> <font color=Blue>-- continue _ (Committed r) = r -- no, remain Committed</font>+<a name="line-72"></a> continue <font color=Green><u>_</u></font> r <font color=Red>=</font> r+<a name="line-73"></a>+<a name="line-74"></a> oneOf' <font color=Red>=</font> accum []+<a name="line-75"></a> <font color=Green><u>where</u></font> accum errs [] <font color=Red>=</font>+<a name="line-76"></a> fail <font color=Cyan>(</font><font color=Magenta>"failed to parse any of the possible choices:\n"</font>+<a name="line-77"></a> <font color=Cyan>++</font>indent <font color=Magenta>2</font> <font color=Cyan>(</font>concatMap showErr <font color=Cyan>(</font>reverse errs<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-78"></a> accum errs <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>P p<font color=Cyan>)</font><font color=Red><b>:</b></font>ps<font color=Cyan>)</font> <font color=Red>=</font>+<a name="line-79"></a> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> p ts <font color=Green><u>of</u></font>+<a name="line-80"></a> Failure <font color=Green><u>_</u></font> err <font color=Red>-></font>+<a name="line-81"></a> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> accum <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>err<font color=Cyan>)</font><font color=Red><b>:</b></font>errs<font color=Cyan>)</font> ps+<a name="line-82"></a> <font color=Green><u>in</u></font> p ts+<a name="line-83"></a> r<font color=Red>@</font><font color=Cyan>(</font>Success z a<font color=Cyan>)</font> <font color=Red>-></font> r+<a name="line-84"></a> r<font color=Red>@</font><font color=Cyan>(</font>Committed <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> r <font color=Cyan>)</font>+<a name="line-85"></a> showErr <font color=Cyan>(</font>name<font color=Cyan>,</font>err<font color=Cyan>)</font> <font color=Red>=</font> name<font color=Cyan>++</font><font color=Magenta>":\n"</font><font color=Cyan>++</font>indent <font color=Magenta>2</font> err+<a name="line-86"></a>+<a name="line-87"></a><a name="next"></a><font color=Blue>------------------------------------------------------------------------</font>+<a name="line-88"></a><font color=Blue>next</font> <font color=Red>::</font> Parser t t+<a name="line-89"></a><font color=Blue>next</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>ts<font color=Red>-></font> <font color=Green><u>case</u></font> ts <font color=Green><u>of</u></font>+<a name="line-90"></a> [] <font color=Red>-></font> Failure [] <font color=Magenta>"Ran out of input (EOF)"</font>+<a name="line-91"></a> <font color=Cyan>(</font>t<font color=Red><b>:</b></font>ts'<font color=Cyan>)</font> <font color=Red>-></font> Success ts' t <font color=Cyan>)</font>+<a name="line-92"></a>+<a name="line-93"></a><a name="satisfy"></a><font color=Blue>satisfy</font> <font color=Red>::</font> <font color=Cyan>(</font>t<font color=Red>-></font>Bool<font color=Cyan>)</font> <font color=Red>-></font> Parser t t+<a name="line-94"></a><font color=Blue>satisfy</font> pred <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> next+<a name="line-95"></a> <font color=Cyan>;</font> <font color=Green><u>if</u></font> pred x <font color=Green><u>then</u></font> return x <font color=Green><u>else</u></font> fail <font color=Magenta>"Parse.satisfy: failed"</font>+<a name="line-96"></a> <font color=Cyan>}</font>+<a name="line-97"></a>+<a name="line-98"></a><a name="reparse"></a><font color=Blue>------------------------------------------------------------------------</font>+<a name="line-99"></a><font color=Blue>-- | Push some tokens back onto the front of the input stream and reparse.</font>+<a name="line-100"></a><font color=Blue>-- This is useful e.g. for recursively expanding macros. When the</font>+<a name="line-101"></a><font color=Blue>-- user-parser recognises a macro use, it can lookup the macro</font>+<a name="line-102"></a><font color=Blue>-- expansion from the parse state, lex it, and then stuff the</font>+<a name="line-103"></a><font color=Blue>-- lexed expansion back down into the parser.</font>+<a name="line-104"></a><font color=Blue>reparse</font> <font color=Red>::</font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Parser t ()+<a name="line-105"></a><font color=Blue>reparse</font> ts <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>inp<font color=Red>-></font> Success <font color=Cyan>(</font>ts<font color=Cyan>++</font>inp<font color=Cyan>)</font> ()<font color=Cyan>)</font>+<a name="line-106"></a>+<a name="line-107"></a><font color=Blue>------------------------------------------------------------------------</font> </pre>+</body> </html>
docs/haddock/src/Text/ParserCombinators/Poly/State.html view
@@ -1,113 +1,135 @@ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"> <html>-<pre><a name="(line1)"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>State-<a name="(line2)"></a> <font color=Cyan>(</font> <font color=Blue>-- * The Parser datatype</font>-<a name="(line3)"></a> Parser<font color=Cyan>(</font>P<font color=Cyan>)</font> <font color=Blue>-- datatype, instance of: Functor, Monad</font>-<a name="(line4)"></a> <font color=Cyan>,</font> runParser <font color=Blue>-- :: Parser s t a -> s -> [t] -> (Either String a, s, [t])</font>-<a name="(line5)"></a> <font color=Blue>-- ** basic parsers</font>-<a name="(line6)"></a> <font color=Cyan>,</font> next <font color=Blue>-- :: Parser s t t</font>-<a name="(line7)"></a> <font color=Cyan>,</font> satisfy <font color=Blue>-- :: (t->Bool) -> Parser s t t</font>-<a name="(line8)"></a> <font color=Blue>-- ** State-handling</font>-<a name="(line9)"></a> <font color=Cyan>,</font> stUpdate <font color=Blue>-- :: (s->s) -> Parser s t ()</font>-<a name="(line10)"></a> <font color=Cyan>,</font> stQuery <font color=Blue>-- :: (s->a) -> Parser s t a</font>-<a name="(line11)"></a> <font color=Cyan>,</font> stGet <font color=Blue>-- :: Parser s t s</font>-<a name="(line12)"></a> <font color=Blue>-- ** Re-parsing</font>-<a name="(line13)"></a> <font color=Cyan>,</font> reparse <font color=Blue>-- :: [t] -> Parser s t ()</font>-<a name="(line14)"></a> <font color=Blue>-- * Re-export all more general combinators.</font>-<a name="(line15)"></a> <font color=Cyan>,</font> <font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base-<a name="(line16)"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line17)"></a>-<a name="(line18)"></a><font color=Green><u>import</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base-<a name="(line19)"></a>-<a name="(line20)"></a><a name="Parser"></a><font color=Blue>-- | The @Parser@ datatype is a fairly generic parsing monad with error</font>-<a name="(line21)"></a><a name="Parser"></a><font color=Blue>-- reporting and a running state. It can be used for arbitrary token</font>-<a name="(line22)"></a><a name="Parser"></a><font color=Blue>-- types, not just String input.</font>-<a name="(line23)"></a><a name="Parser"></a><font color=Green><u>newtype</u></font> Parser s t a <font color=Red>=</font> P <font color=Cyan>(</font>s <font color=Red>-></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>EitherE String a<font color=Cyan>,</font> s<font color=Cyan>,</font> <font color=Red>[</font>t<font color=Red>]</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line24)"></a>-<a name="(line25)"></a><a name="EitherE"></a><font color=Blue>-- | A return type like Either, that distinguishes not only between</font>-<a name="(line26)"></a><a name="EitherE"></a><font color=Blue>-- right and wrong answers, but also had gradations of wrongness.</font>-<a name="(line27)"></a><a name="EitherE"></a><font color=Green><u>type</u></font> EitherE a b <font color=Red>=</font> Either <font color=Cyan>(</font>Bool<font color=Cyan>,</font>a<font color=Cyan>)</font> b-<a name="(line28)"></a>-<a name="(line29)"></a><a name="runParser"></a><font color=Blue>-- | Apply a parser to an initial state and input token sequence.</font>-<a name="(line30)"></a>runParser <font color=Red>::</font> Parser s t a <font color=Red>-></font> s <font color=Red>-></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>Either String a<font color=Cyan>,</font> s<font color=Cyan>,</font> <font color=Red>[</font>t<font color=Red>]</font><font color=Cyan>)</font>-<a name="(line31)"></a>runParser <font color=Cyan>(</font>P p<font color=Cyan>)</font> s <font color=Red>=</font>-<a name="(line32)"></a> <font color=Cyan>(</font><font color=Red>\</font> <font color=Cyan>(</font>e<font color=Cyan>,</font>s<font color=Cyan>,</font>ts<font color=Cyan>)</font><font color=Red>-></font> <font color=Cyan>(</font><font color=Green><u>case</u></font> e <font color=Green><u>of</u></font> Left <font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>m<font color=Cyan>)</font><font color=Red>-></font>Left m<font color=Cyan>;</font> Right m<font color=Red>-></font>Right m-<a name="(line33)"></a> <font color=Cyan>,</font>s<font color=Cyan>,</font>ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line34)"></a> <font color=Cyan>.</font> p s-<a name="(line35)"></a>-<a name="(line36)"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Parser s t<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line37)"></a> fmap f <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> p s ts <font color=Green><u>of</u></font>-<a name="(line38)"></a> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line39)"></a> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Right <font color=Cyan>(</font>f x<font color=Cyan>)</font><font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line40)"></a><font color=Green><u>instance</u></font> Monad <font color=Cyan>(</font>Parser s t<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line41)"></a> return x <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> s<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line42)"></a> <font color=Cyan>(</font>P f<font color=Cyan>)</font> <font color=Cyan>>>=</font> g <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> f s ts <font color=Green><u>of</u></font>-<a name="(line43)"></a> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line44)"></a> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P g'<font color=Cyan>)</font> <font color=Red>=</font> g x-<a name="(line45)"></a> <font color=Green><u>in</u></font> g' s' ts'<font color=Cyan>)</font>-<a name="(line46)"></a> fail msg <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>False<font color=Cyan>,</font>msg<font color=Cyan>)</font><font color=Cyan>,</font> s<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line47)"></a>-<a name="(line48)"></a><font color=Green><u>instance</u></font> PolyParse <font color=Cyan>(</font>Parser s t<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line49)"></a> commit <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> p s ts <font color=Green><u>of</u></font>-<a name="(line50)"></a> <font color=Cyan>(</font>Left <font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>e<font color=Cyan>)</font><font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>True<font color=Cyan>,</font>e<font color=Cyan>)</font><font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line51)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line52)"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`onFail`</font> <font color=Cyan>(</font>P q<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> p s ts <font color=Green><u>of</u></font>-<a name="(line53)"></a> r<font color=Red>@</font><font color=Cyan>(</font>Left <font color=Cyan>(</font>True<font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>)</font><font color=Cyan>,</font> <font color=Green><u>_</u></font><font color=Cyan>,</font> <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> r-<a name="(line54)"></a> <font color=Cyan>(</font>Left <font color=Green><u>_</u></font><font color=Cyan>,</font> <font color=Green><u>_</u></font><font color=Cyan>,</font> <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> q s ts-<a name="(line55)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line56)"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`adjustErr`</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> p s ts <font color=Green><u>of</u></font>-<a name="(line57)"></a> <font color=Cyan>(</font>Left <font color=Cyan>(</font>b<font color=Cyan>,</font>msg<font color=Cyan>)</font><font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line58)"></a> <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>b<font color=Cyan>,</font><font color=Cyan>(</font>f msg<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>,</font> s<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line59)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line60)"></a> oneOf' <font color=Red>=</font> accum []-<a name="(line61)"></a> <font color=Green><u>where</u></font> accum errs [] <font color=Red>=</font>-<a name="(line62)"></a> <font color=Green><u>case</u></font> filter isBad errs <font color=Green><u>of</u></font>-<a name="(line63)"></a> [] <font color=Red>-></font> fail <font color=Cyan>(</font><font color=Magenta>"failed to parse any of the possible choices:\n"</font>-<a name="(line64)"></a> <font color=Cyan>++</font>indent <font color=Magenta>2</font> <font color=Cyan>(</font>concatMap showErr <font color=Cyan>(</font>reverse errs<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line65)"></a> <font color=Red>[</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>e<font color=Cyan>)</font><font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> failBad e-<a name="(line66)"></a> es <font color=Red>-></font> failBad <font color=Cyan>(</font><font color=Magenta>"one of the following failures occurred:\n"</font>-<a name="(line67)"></a> <font color=Cyan>++</font>indent <font color=Magenta>2</font> <font color=Cyan>(</font>concatMap showErr <font color=Cyan>(</font>reverse es<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line68)"></a> accum errs <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>P p<font color=Cyan>)</font><font color=Red><b>:</b></font>ps<font color=Cyan>)</font> <font color=Red>=</font>-<a name="(line69)"></a> P <font color=Cyan>(</font><font color=Red>\</font>u ts<font color=Red>-></font> <font color=Green><u>case</u></font> p u ts <font color=Green><u>of</u></font>-<a name="(line70)"></a> <font color=Cyan>(</font>Left err<font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> accum <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>err<font color=Cyan>)</font><font color=Red><b>:</b></font>errs<font color=Cyan>)</font> ps-<a name="(line71)"></a> <font color=Green><u>in</u></font> p u ts-<a name="(line72)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line73)"></a> showErr <font color=Cyan>(</font>name<font color=Cyan>,</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>err<font color=Cyan>)</font><font color=Cyan>)</font> <font color=Red>=</font> name<font color=Cyan>++</font><font color=Magenta>":\n"</font><font color=Cyan>++</font>indent <font color=Magenta>2</font> err-<a name="(line74)"></a> isBad <font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font><font color=Cyan>(</font>b<font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>)</font><font color=Cyan>)</font> <font color=Red>=</font> b-<a name="(line75)"></a>-<a name="(line76)"></a><a name="next"></a><font color=Blue>------------------------------------------------------------------------</font>-<a name="(line77)"></a>next <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> ts <font color=Green><u>of</u></font>-<a name="(line78)"></a> [] <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>False<font color=Cyan>,</font><font color=Magenta>"Ran out of input (EOF)"</font><font color=Cyan>)</font><font color=Cyan>,</font> s<font color=Cyan>,</font> []<font color=Cyan>)</font>-<a name="(line79)"></a> <font color=Cyan>(</font>t<font color=Red><b>:</b></font>ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Right t<font color=Cyan>,</font> s<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Cyan>)</font>-<a name="(line80)"></a>-<a name="(line81)"></a><a name="satisfy"></a>satisfy <font color=Red>::</font> <font color=Cyan>(</font>t<font color=Red>-></font>Bool<font color=Cyan>)</font> <font color=Red>-></font> Parser s t t-<a name="(line82)"></a>satisfy p <font color=Red>=</font> <font color=Green><u>do</u></font><font color=Cyan>{</font> x <font color=Red><-</font> next-<a name="(line83)"></a> <font color=Cyan>;</font> <font color=Green><u>if</u></font> p x <font color=Green><u>then</u></font> return x <font color=Green><u>else</u></font> fail <font color=Magenta>"Parse.satisfy: failed"</font>-<a name="(line84)"></a> <font color=Cyan>}</font>-<a name="(line85)"></a><font color=Blue>------------------------------------------------------------------------</font>-<a name="(line86)"></a><font color=Blue>-- State handling</font>-<a name="(line87)"></a>-<a name="(line88)"></a><a name="stUpdate"></a><font color=Blue>-- | Update the internal state.</font>-<a name="(line89)"></a>stUpdate <font color=Red>::</font> <font color=Cyan>(</font>s<font color=Red>-></font>s<font color=Cyan>)</font> <font color=Red>-></font> Parser s t ()-<a name="(line90)"></a>stUpdate f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Cyan>(</font>Right ()<font color=Cyan>,</font> f s<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line91)"></a>-<a name="(line92)"></a><a name="stQuery"></a><font color=Blue>-- | Query the internal state.</font>-<a name="(line93)"></a>stQuery <font color=Red>::</font> <font color=Cyan>(</font>s<font color=Red>-></font>a<font color=Cyan>)</font> <font color=Red>-></font> Parser s t a-<a name="(line94)"></a>stQuery f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Cyan>(</font>Right <font color=Cyan>(</font>f s<font color=Cyan>)</font><font color=Cyan>,</font> s<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line95)"></a>-<a name="(line96)"></a><a name="stGet"></a><font color=Blue>-- | Deliver the entire internal state.</font>-<a name="(line97)"></a>stGet <font color=Red>::</font> Parser s t s-<a name="(line98)"></a>stGet <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Cyan>(</font>Right s<font color=Cyan>,</font> s<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line99)"></a>-<a name="(line100)"></a><a name="reparse"></a><font color=Blue>------------------------------------------------------------------------</font>-<a name="(line101)"></a><font color=Blue>-- | Push some tokens back onto the front of the input stream and reparse.</font>-<a name="(line102)"></a><font color=Blue>-- This is useful e.g. for recursively expanding macros. When the</font>-<a name="(line103)"></a><font color=Blue>-- user-parser recognises a macro use, it can lookup the macro</font>-<a name="(line104)"></a><font color=Blue>-- expansion from the parse state, lex it, and then stuff the</font>-<a name="(line105)"></a><font color=Blue>-- lexed expansion back down into the parser.</font>-<a name="(line106)"></a>reparse <font color=Red>::</font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Parser s t ()-<a name="(line107)"></a>reparse ts <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s inp<font color=Red>-></font> <font color=Cyan>(</font>Right ()<font color=Cyan>,</font> s<font color=Cyan>,</font> ts<font color=Cyan>++</font>inp<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line108)"></a>-<a name="(line109)"></a><font color=Blue>------------------------------------------------------------------------</font>+<head>+<!-- Generated by HsColour, http://www.cs.york.ac.uk/fp/darcs/hscolour/ -->+<title>src/Text/ParserCombinators/Poly/State.hs</title>+</head>+<body>+<pre><a name="line-1"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>State+<a name="line-2"></a> <font color=Cyan>(</font> <font color=Blue>-- * The Parser datatype</font>+<a name="line-3"></a> Parser<font color=Cyan>(</font>P<font color=Cyan>)</font> <font color=Blue>-- datatype, instance of: Functor, Monad, PolyParse</font>+<a name="line-4"></a> <font color=Cyan>,</font> Result<font color=Cyan>(</font><font color=Red>..</font><font color=Cyan>)</font> <font color=Blue>-- internal to the parser monad</font>+<a name="line-5"></a> <font color=Cyan>,</font> runParser <font color=Blue>-- :: Parser s t a -> s -> [t] -> (Either String a, s, [t])</font>+<a name="line-6"></a> <font color=Blue>-- ** basic parsers</font>+<a name="line-7"></a> <font color=Cyan>,</font> next <font color=Blue>-- :: Parser s t t</font>+<a name="line-8"></a> <font color=Cyan>,</font> satisfy <font color=Blue>-- :: (t->Bool) -> Parser s t t</font>+<a name="line-9"></a> <font color=Blue>-- ** State-handling</font>+<a name="line-10"></a> <font color=Cyan>,</font> stUpdate <font color=Blue>-- :: (s->s) -> Parser s t ()</font>+<a name="line-11"></a> <font color=Cyan>,</font> stQuery <font color=Blue>-- :: (s->a) -> Parser s t a</font>+<a name="line-12"></a> <font color=Cyan>,</font> stGet <font color=Blue>-- :: Parser s t s</font>+<a name="line-13"></a> <font color=Blue>-- ** re-parsing</font>+<a name="line-14"></a> <font color=Cyan>,</font> reparse <font color=Blue>-- :: [t] -> Parser s t ()</font>+<a name="line-15"></a> <font color=Blue>-- * Re-export all more general combinators</font>+<a name="line-16"></a> <font color=Cyan>,</font> <font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base+<a name="line-17"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-18"></a>+<a name="line-19"></a>+<a name="line-20"></a><font color=Green><u>import</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base+<a name="line-21"></a>+<a name="line-22"></a><a name="Parser"></a><font color=Blue>-- | This @Parser@ datatype is a fairly generic parsing monad with error</font>+<a name="line-23"></a><a name="Parser"></a><font color=Blue>-- reporting. It can be used for arbitrary token types, not just</font>+<a name="line-24"></a><a name="Parser"></a><font color=Blue>-- String input. (If you require a running state, use module PolyState</font>+<a name="line-25"></a><a name="Parser"></a><font color=Blue>-- instead)</font>+<a name="line-26"></a><a name="Parser"></a><font color=Green><u>newtype</u></font> Parser s t a <font color=Red>=</font> P <font color=Cyan>(</font>s <font color=Red>-></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Result <font color=Red>[</font>t<font color=Red>]</font> s a<font color=Cyan>)</font>+<a name="line-27"></a>+<a name="line-28"></a><a name="Result"></a><font color=Blue>-- | A return type like Either, that distinguishes not only between</font>+<a name="line-29"></a><a name="Result"></a><font color=Blue>-- right and wrong answers, but also has gradations of wrongness.</font>+<a name="line-30"></a><a name="Result"></a><font color=Blue>-- This should only be used for writing very primitive</font>+<a name="line-31"></a><a name="Result"></a><font color=Blue>-- parsers - really it is an internal detail of the library.</font>+<a name="line-32"></a><a name="Result"></a><font color=Green><u>data</u></font> Result z s a <font color=Red>=</font> Success z s a+<a name="line-33"></a> <font color=Red>|</font> Failure z s String+<a name="line-34"></a> <font color=Red>|</font> Committed <font color=Cyan>(</font>Result z s a<font color=Cyan>)</font>+<a name="line-35"></a>+<a name="line-36"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Result z s<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-37"></a> fmap f <font color=Cyan>(</font>Success z s a<font color=Cyan>)</font> <font color=Red>=</font> Success z s <font color=Cyan>(</font>f a<font color=Cyan>)</font>+<a name="line-38"></a> fmap f <font color=Cyan>(</font>Failure z s e<font color=Cyan>)</font> <font color=Red>=</font> Failure z s e+<a name="line-39"></a> fmap f <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> Committed <font color=Cyan>(</font>fmap f r<font color=Cyan>)</font>+<a name="line-40"></a>+<a name="line-41"></a><a name="runParser"></a><font color=Blue>-- | Apply a parser to an input token sequence.</font>+<a name="line-42"></a><font color=Blue>runParser</font> <font color=Red>::</font> Parser s t a <font color=Red>-></font> s <font color=Red>-></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>Either String a<font color=Cyan>,</font> s<font color=Cyan>,</font> <font color=Red>[</font>t<font color=Red>]</font><font color=Cyan>)</font>+<a name="line-43"></a><font color=Blue>runParser</font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> <font color=Red>\</font>s<font color=Red>-></font> resultToEither <font color=Cyan>.</font> p s+<a name="line-44"></a> <font color=Green><u>where</u></font>+<a name="line-45"></a> resultToEither <font color=Red>::</font> Result z s a <font color=Red>-></font> <font color=Cyan>(</font>Either String a<font color=Cyan>,</font> s<font color=Cyan>,</font> z<font color=Cyan>)</font>+<a name="line-46"></a> resultToEither <font color=Cyan>(</font>Success z s a<font color=Cyan>)</font> <font color=Red>=</font> <font color=Cyan>(</font>Right a<font color=Cyan>,</font> s<font color=Cyan>,</font> z<font color=Cyan>)</font>+<a name="line-47"></a> resultToEither <font color=Cyan>(</font>Failure z s e<font color=Cyan>)</font> <font color=Red>=</font> <font color=Cyan>(</font>Left e<font color=Cyan>,</font> s<font color=Cyan>,</font> z<font color=Cyan>)</font>+<a name="line-48"></a> resultToEither <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> resultToEither r+<a name="line-49"></a>+<a name="line-50"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Parser s t<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-51"></a> fmap f <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s<font color=Red>-></font> fmap f <font color=Cyan>.</font> p s<font color=Cyan>)</font>+<a name="line-52"></a>+<a name="line-53"></a><font color=Green><u>instance</u></font> Monad <font color=Cyan>(</font>Parser s t<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-54"></a> return x <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> Success ts s x<font color=Cyan>)</font>+<a name="line-55"></a> fail e <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> Failure ts s e<font color=Cyan>)</font>+<a name="line-56"></a> <font color=Cyan>(</font>P f<font color=Cyan>)</font> <font color=Cyan>>>=</font> g <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s<font color=Red>-></font> continue <font color=Cyan>.</font> f s<font color=Cyan>)</font>+<a name="line-57"></a> <font color=Green><u>where</u></font>+<a name="line-58"></a> continue <font color=Cyan>(</font>Success ts s x<font color=Cyan>)</font> <font color=Red>=</font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P g'<font color=Cyan>)</font> <font color=Red>=</font> g x <font color=Green><u>in</u></font> g' s ts+<a name="line-59"></a> continue <font color=Cyan>(</font>Committed <font color=Cyan>(</font>Committed r<font color=Cyan>)</font><font color=Cyan>)</font> <font color=Red>=</font> continue <font color=Cyan>(</font>Committed r<font color=Cyan>)</font>+<a name="line-60"></a> continue <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> Committed <font color=Cyan>(</font>continue r<font color=Cyan>)</font>+<a name="line-61"></a> continue <font color=Cyan>(</font>Failure ts s e<font color=Cyan>)</font> <font color=Red>=</font> Failure ts s e+<a name="line-62"></a>+<a name="line-63"></a><font color=Green><u>instance</u></font> PolyParse <font color=Cyan>(</font>Parser s t<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-64"></a> commit <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s<font color=Red>-></font> Committed <font color=Cyan>.</font> p s<font color=Cyan>)</font>+<a name="line-65"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`adjustErr`</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s<font color=Red>-></font> adjust <font color=Cyan>.</font> p s<font color=Cyan>)</font>+<a name="line-66"></a> <font color=Green><u>where</u></font>+<a name="line-67"></a> adjust <font color=Cyan>(</font>Failure z s e<font color=Cyan>)</font> <font color=Red>=</font> Failure z s <font color=Cyan>(</font>f e<font color=Cyan>)</font>+<a name="line-68"></a> adjust <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> Committed <font color=Cyan>(</font>adjust r<font color=Cyan>)</font>+<a name="line-69"></a> adjust good <font color=Red>=</font> good+<a name="line-70"></a>+<a name="line-71"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`onFail`</font> <font color=Cyan>(</font>P q<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> continue s ts <font color=Cyan>$</font> p s ts<font color=Cyan>)</font>+<a name="line-72"></a> <font color=Green><u>where</u></font>+<a name="line-73"></a> continue s ts <font color=Cyan>(</font>Failure <font color=Green><u>_</u></font> <font color=Green><u>_</u></font> <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>=</font> q s ts+<a name="line-74"></a> <font color=Blue>-- continue _ _ (Committed r) = r -- no, remain Committed</font>+<a name="line-75"></a> continue <font color=Green><u>_</u></font> <font color=Green><u>_</u></font> r <font color=Red>=</font> r+<a name="line-76"></a>+<a name="line-77"></a> oneOf' <font color=Red>=</font> accum []+<a name="line-78"></a> <font color=Green><u>where</u></font> accum errs [] <font color=Red>=</font>+<a name="line-79"></a> fail <font color=Cyan>(</font><font color=Magenta>"failed to parse any of the possible choices:\n"</font>+<a name="line-80"></a> <font color=Cyan>++</font>indent <font color=Magenta>2</font> <font color=Cyan>(</font>concatMap showErr <font color=Cyan>(</font>reverse errs<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-81"></a> accum errs <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>P p<font color=Cyan>)</font><font color=Red><b>:</b></font>ps<font color=Cyan>)</font> <font color=Red>=</font>+<a name="line-82"></a> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> p s ts <font color=Green><u>of</u></font>+<a name="line-83"></a> Failure <font color=Green><u>_</u></font> <font color=Green><u>_</u></font> err <font color=Red>-></font>+<a name="line-84"></a> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> accum <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>err<font color=Cyan>)</font><font color=Red><b>:</b></font>errs<font color=Cyan>)</font> ps+<a name="line-85"></a> <font color=Green><u>in</u></font> p s ts+<a name="line-86"></a> r<font color=Red>@</font><font color=Cyan>(</font>Success z <font color=Green><u>_</u></font> a<font color=Cyan>)</font> <font color=Red>-></font> r+<a name="line-87"></a> r<font color=Red>@</font><font color=Cyan>(</font>Committed <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> r <font color=Cyan>)</font>+<a name="line-88"></a> showErr <font color=Cyan>(</font>name<font color=Cyan>,</font>err<font color=Cyan>)</font> <font color=Red>=</font> name<font color=Cyan>++</font><font color=Magenta>":\n"</font><font color=Cyan>++</font>indent <font color=Magenta>2</font> err+<a name="line-89"></a>+<a name="line-90"></a><a name="next"></a><font color=Blue>------------------------------------------------------------------------</font>+<a name="line-91"></a><font color=Blue>next</font> <font color=Red>::</font> Parser s t t+<a name="line-92"></a><font color=Blue>next</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> ts <font color=Green><u>of</u></font>+<a name="line-93"></a> [] <font color=Red>-></font> Failure [] s <font color=Magenta>"Ran out of input (EOF)"</font>+<a name="line-94"></a> <font color=Cyan>(</font>t<font color=Red><b>:</b></font>ts'<font color=Cyan>)</font> <font color=Red>-></font> Success ts' s t <font color=Cyan>)</font>+<a name="line-95"></a>+<a name="line-96"></a><a name="satisfy"></a><font color=Blue>satisfy</font> <font color=Red>::</font> <font color=Cyan>(</font>t<font color=Red>-></font>Bool<font color=Cyan>)</font> <font color=Red>-></font> Parser s t t+<a name="line-97"></a><font color=Blue>satisfy</font> pred <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> next+<a name="line-98"></a> <font color=Cyan>;</font> <font color=Green><u>if</u></font> pred x <font color=Green><u>then</u></font> return x <font color=Green><u>else</u></font> fail <font color=Magenta>"Parse.satisfy: failed"</font>+<a name="line-99"></a> <font color=Cyan>}</font>+<a name="line-100"></a><font color=Blue>------------------------------------------------------------------------</font>+<a name="line-101"></a><font color=Blue>-- State handling</font>+<a name="line-102"></a>+<a name="line-103"></a><a name="stUpdate"></a><font color=Blue>-- | Update the internal state.</font>+<a name="line-104"></a><font color=Blue>stUpdate</font> <font color=Red>::</font> <font color=Cyan>(</font>s<font color=Red>-></font>s<font color=Cyan>)</font> <font color=Red>-></font> Parser s t ()+<a name="line-105"></a><font color=Blue>stUpdate</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> Success ts <font color=Cyan>(</font>f s<font color=Cyan>)</font> ()<font color=Cyan>)</font>+<a name="line-106"></a>+<a name="line-107"></a><a name="stQuery"></a><font color=Blue>-- | Query the internal state.</font>+<a name="line-108"></a><font color=Blue>stQuery</font> <font color=Red>::</font> <font color=Cyan>(</font>s<font color=Red>-></font>a<font color=Cyan>)</font> <font color=Red>-></font> Parser s t a+<a name="line-109"></a><font color=Blue>stQuery</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> Success ts s <font color=Cyan>(</font>f s<font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-110"></a>+<a name="line-111"></a><a name="stGet"></a><font color=Blue>-- | Deliver the entire internal state.</font>+<a name="line-112"></a><font color=Blue>stGet</font> <font color=Red>::</font> Parser s t s+<a name="line-113"></a><font color=Blue>stGet</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> Success ts s s<font color=Cyan>)</font>+<a name="line-114"></a>+<a name="line-115"></a>+<a name="line-116"></a><a name="reparse"></a><font color=Blue>------------------------------------------------------------------------</font>+<a name="line-117"></a><font color=Blue>-- | Push some tokens back onto the front of the input stream and reparse.</font>+<a name="line-118"></a><font color=Blue>-- This is useful e.g. for recursively expanding macros. When the</font>+<a name="line-119"></a><font color=Blue>-- user-parser recognises a macro use, it can lookup the macro</font>+<a name="line-120"></a><font color=Blue>-- expansion from the parse state, lex it, and then stuff the</font>+<a name="line-121"></a><font color=Blue>-- lexed expansion back down into the parser.</font>+<a name="line-122"></a><font color=Blue>reparse</font> <font color=Red>::</font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Parser s t ()+<a name="line-123"></a><font color=Blue>reparse</font> ts <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s inp<font color=Red>-></font> Success <font color=Cyan>(</font>ts<font color=Cyan>++</font>inp<font color=Cyan>)</font> s ()<font color=Cyan>)</font>+<a name="line-124"></a>+<a name="line-125"></a><font color=Blue>------------------------------------------------------------------------</font> </pre>+</body> </html>
docs/haddock/src/Text/ParserCombinators/Poly/StateLazy.html view
@@ -1,144 +1,185 @@ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"> <html>-<pre><a name="(line1)"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>StateLazy-<a name="(line2)"></a> <font color=Cyan>(</font> <font color=Blue>-- * The Parser datatype.</font>-<a name="(line3)"></a> <font color=Blue>-- $parser</font>-<a name="(line4)"></a> Parser<font color=Cyan>(</font>P<font color=Cyan>)</font> <font color=Blue>-- datatype, instance of: Functor, Monad</font>-<a name="(line5)"></a> <font color=Cyan>,</font> runParser <font color=Blue>-- :: Parser s t a -> s -> [t] -> (a, s, [t])</font>-<a name="(line6)"></a> <font color=Blue>-- * Combinators:</font>-<a name="(line7)"></a> <font color=Blue>-- ** Primitives</font>-<a name="(line8)"></a> <font color=Cyan>,</font> next <font color=Blue>-- :: Parser s t t</font>-<a name="(line9)"></a> <font color=Cyan>,</font> satisfy <font color=Blue>-- :: (t->Bool) -> Parser s t t</font>-<a name="(line10)"></a> <font color=Blue>-- ** State-handling</font>-<a name="(line11)"></a> <font color=Cyan>,</font> stUpdate <font color=Blue>-- :: (s->s) -> Parser s t ()</font>-<a name="(line12)"></a> <font color=Cyan>,</font> stQuery <font color=Blue>-- :: (s->a) -> Parser s t a</font>-<a name="(line13)"></a> <font color=Cyan>,</font> stGet <font color=Blue>-- :: Parser s t s</font>-<a name="(line14)"></a> <font color=Blue>-- ** Re-parsing</font>-<a name="(line15)"></a> <font color=Cyan>,</font> reparse <font color=Blue>-- :: [t] -> Parser s t ()</font>-<a name="(line16)"></a> <font color=Blue>-- * Re-export all more general combinators</font>-<a name="(line17)"></a> <font color=Cyan>,</font> <font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base-<a name="(line18)"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line19)"></a>-<a name="(line20)"></a><font color=Green><u>import</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base-<a name="(line21)"></a>-<a name="(line22)"></a><font color=Magenta><em>#if __GLASGOW_HASKELL__</em></font>-<a name="(line23)"></a><font color=Green><u>import</u></font> Control<font color=Cyan>.</font>Exception hiding <font color=Cyan>(</font>bracket<font color=Cyan>)</font>-<a name="(line24)"></a><a name="throwE"></a>throwE <font color=Red>::</font> String <font color=Red>-></font> a-<a name="(line25)"></a>throwE msg <font color=Red>=</font> throw <font color=Cyan>(</font>ErrorCall msg<font color=Cyan>)</font>-<a name="(line26)"></a><font color=Magenta><em>#else</em></font>-<a name="(line27)"></a>throwE <font color=Red>::</font> String <font color=Red>-></font> a-<a name="(line28)"></a>throwE msg <font color=Red>=</font> error msg-<a name="(line29)"></a><font color=Magenta><em>#endif</em></font>-<a name="(line30)"></a>-<a name="(line31)"></a><font color=Blue>-- $parser</font>-<a name="(line32)"></a><font color=Blue>-- Parsers do not return explicit failure. An exception is raised</font>-<a name="(line33)"></a><font color=Blue>-- instead. This allows partial results to be returned before a</font>-<a name="(line34)"></a><font color=Blue>-- full parse is complete.</font>-<a name="(line35)"></a>-<a name="(line36)"></a><a name="Parser"></a><font color=Blue>-- | The @Parser@ datatype is a fairly generic parsing monad with error</font>-<a name="(line37)"></a><a name="Parser"></a><font color=Blue>-- reporting and a running state. It can be used for arbitrary token</font>-<a name="(line38)"></a><a name="Parser"></a><font color=Blue>-- types, not just String input.</font>-<a name="(line39)"></a><a name="Parser"></a><font color=Green><u>newtype</u></font> Parser s t a <font color=Red>=</font> P <font color=Cyan>(</font>s <font color=Red>-></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>Either String a<font color=Cyan>,</font> s<font color=Cyan>,</font> <font color=Red>[</font>t<font color=Red>]</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line40)"></a>-<a name="(line41)"></a><a name="EitherE"></a><font color=Blue>-- | A return type like Either, that distinguishes not only between</font>-<a name="(line42)"></a><a name="EitherE"></a><font color=Blue>-- right and wrong answers, but also had gradations of wrongness.</font>-<a name="(line43)"></a><a name="EitherE"></a><font color=Blue>-- Not used in this library. !!!!!!!!!!!!!!!!!!!!!!!!!!</font>-<a name="(line44)"></a><a name="EitherE"></a><font color=Green><u>type</u></font> EitherE a b <font color=Red>=</font> Either <font color=Cyan>(</font>Bool<font color=Cyan>,</font>a<font color=Cyan>)</font> b-<a name="(line45)"></a>-<a name="(line46)"></a><a name="runParser"></a><font color=Blue>-- | Apply a parser to an initial state and input token sequence.</font>-<a name="(line47)"></a><font color=Blue>-- The parser cannot return an error value explicitly, so errors</font>-<a name="(line48)"></a><font color=Blue>-- raise an exception. Thus, results can be partial (lazily constructed,</font>-<a name="(line49)"></a><font color=Blue>-- but containing undefined).</font>-<a name="(line50)"></a>runParser <font color=Red>::</font> Parser s t a <font color=Red>-></font> s <font color=Red>-></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>a<font color=Cyan>,</font> s<font color=Cyan>,</font> <font color=Red>[</font>t<font color=Red>]</font><font color=Cyan>)</font>-<a name="(line51)"></a>runParser <font color=Cyan>(</font>P p<font color=Cyan>)</font> s <font color=Red>=</font>-<a name="(line52)"></a> <font color=Cyan>(</font><font color=Red>\</font> <font color=Cyan>(</font>e<font color=Cyan>,</font>s<font color=Cyan>,</font>ts<font color=Cyan>)</font><font color=Red>-></font> <font color=Cyan>(</font><font color=Green><u>case</u></font> e <font color=Green><u>of</u></font> <font color=Cyan>{</font>Left m<font color=Red>-></font>throwE m<font color=Cyan>;</font> Right x<font color=Red>-></font>x<font color=Cyan>}</font><font color=Cyan>,</font> s<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line53)"></a> <font color=Cyan>.</font> p s-<a name="(line54)"></a>-<a name="(line55)"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Parser s t<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line56)"></a> fmap f <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> p s ts <font color=Green><u>of</u></font>-<a name="(line57)"></a> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line58)"></a> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Right <font color=Cyan>(</font>f x<font color=Cyan>)</font><font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line59)"></a><font color=Green><u>instance</u></font> Monad <font color=Cyan>(</font>Parser s t<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line60)"></a> return x <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> s<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line61)"></a> <font color=Cyan>(</font>P f<font color=Cyan>)</font> <font color=Cyan>>>=</font> g <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> f s ts <font color=Green><u>of</u></font>-<a name="(line62)"></a> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line63)"></a> <font color=Cyan>(</font>Right x<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P g'<font color=Cyan>)</font> <font color=Red>=</font> g x-<a name="(line64)"></a> <font color=Green><u>in</u></font> g' s' ts'<font color=Cyan>)</font>-<a name="(line65)"></a> fail msg <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> s<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line66)"></a>-<a name="(line67)"></a><font color=Green><u>instance</u></font> PolyParse <font color=Cyan>(</font>Parser s t<font color=Cyan>)</font> <font color=Green><u>where</u></font>-<a name="(line68)"></a> commit <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> p s ts <font color=Green><u>of</u></font>-<a name="(line69)"></a> <font color=Cyan>(</font>Left e<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>throwE e<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line70)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line71)"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`adjustErr`</font> f <font color=Red>=</font>-<a name="(line72)"></a> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> p s ts <font color=Green><u>of</u></font>-<a name="(line73)"></a> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Cyan>(</font>f msg<font color=Cyan>)</font><font color=Cyan>,</font> s<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line74)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line75)"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`onFail`</font> <font color=Cyan>(</font>P q<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> p s ts <font color=Green><u>of</u></font>-<a name="(line76)"></a> <font color=Cyan>(</font>Left <font color=Green><u>_</u></font><font color=Cyan>,</font> <font color=Green><u>_</u></font><font color=Cyan>,</font> <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> q s ts-<a name="(line77)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line78)"></a> oneOf' ps <font color=Red>=</font> accum [] ps-<a name="(line79)"></a> <font color=Green><u>where</u></font> accum errs [] <font color=Red>=</font>-<a name="(line80)"></a> <font color=Green><u>case</u></font> errs <font color=Green><u>of</u></font>-<a name="(line81)"></a> [] <font color=Red>-></font> failBad <font color=Cyan>(</font><font color=Magenta>"internal failure in parser (oneOf'):\n"</font>-<a name="(line82)"></a> <font color=Cyan>++</font>indent <font color=Magenta>2</font> <font color=Cyan>(</font>show <font color=Cyan>(</font>map fst ps<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line83)"></a> <font color=Red>[</font><font color=Cyan>(</font><font color=Green><u>_</u></font><font color=Cyan>,</font>e<font color=Cyan>)</font><font color=Red>]</font> <font color=Red>-></font> fail e-<a name="(line84)"></a> es <font color=Red>-></font> fail <font color=Cyan>(</font><font color=Magenta>"one of the following failures occurred:\n"</font>-<a name="(line85)"></a> <font color=Cyan>++</font>indent <font color=Magenta>2</font> <font color=Cyan>(</font>concatMap showErr <font color=Cyan>(</font>reverse es<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line86)"></a> accum errs <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>P p<font color=Cyan>)</font><font color=Red><b>:</b></font>ps<font color=Cyan>)</font> <font color=Red>=</font>-<a name="(line87)"></a> P <font color=Cyan>(</font><font color=Red>\</font>u ts<font color=Red>-></font> <font color=Green><u>case</u></font> p u ts <font color=Green><u>of</u></font>-<a name="(line88)"></a> <font color=Cyan>(</font>Left err<font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>,</font><font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> accum <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>err<font color=Cyan>)</font><font color=Red><b>:</b></font>errs<font color=Cyan>)</font> ps-<a name="(line89)"></a> <font color=Green><u>in</u></font> p u ts-<a name="(line90)"></a> right <font color=Red>-></font> right <font color=Cyan>)</font>-<a name="(line91)"></a> showErr <font color=Cyan>(</font>name<font color=Cyan>,</font>err<font color=Cyan>)</font> <font color=Red>=</font> name<font color=Cyan>++</font><font color=Magenta>":\n"</font><font color=Cyan>++</font>indent <font color=Magenta>2</font> err-<a name="(line92)"></a> <font color=Cyan>(</font>P pf<font color=Cyan>)</font> <font color=Cyan>`apply`</font> <font color=Cyan>(</font>P px<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font>-<a name="(line93)"></a> <font color=Green><u>case</u></font> pf s ts <font color=Green><u>of</u></font>-<a name="(line94)"></a> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Left msg<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font>-<a name="(line95)"></a> <font color=Cyan>(</font>Right f<font color=Cyan>,</font> s'<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>x'<font color=Cyan>,</font>s''<font color=Cyan>,</font>ts''<font color=Cyan>)</font> <font color=Red>=</font> px s' ts'-<a name="(line96)"></a> x <font color=Red>=</font> <font color=Green><u>case</u></font> x' <font color=Green><u>of</u></font> <font color=Cyan>{</font> Right x <font color=Red>-></font> x-<a name="(line97)"></a> <font color=Cyan>;</font> Left e <font color=Red>-></font> throwE e <font color=Cyan>}</font>-<a name="(line98)"></a> <font color=Green><u>in</u></font> <font color=Cyan>(</font>Right <font color=Cyan>(</font>f x<font color=Cyan>)</font><font color=Cyan>,</font> s''<font color=Cyan>,</font> ts''<font color=Cyan>)</font> <font color=Cyan>)</font>-<a name="(line99)"></a>-<a name="(line100)"></a>-<a name="(line101)"></a><font color=Blue>-- Combinators</font>-<a name="(line102)"></a>-<a name="(line103)"></a><a name="next"></a><font color=Blue>-- | Yield one token.</font>-<a name="(line104)"></a>next <font color=Red>::</font> Parser s t t-<a name="(line105)"></a>next <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> ts <font color=Green><u>of</u></font>-<a name="(line106)"></a> [] <font color=Red>-></font> <font color=Cyan>(</font>Left <font color=Magenta>"Ran out of input (EOF)"</font><font color=Cyan>,</font> s<font color=Cyan>,</font> []<font color=Cyan>)</font>-<a name="(line107)"></a> <font color=Cyan>(</font>t<font color=Red><b>:</b></font>ts'<font color=Cyan>)</font> <font color=Red>-></font> <font color=Cyan>(</font>Right t<font color=Cyan>,</font> s<font color=Cyan>,</font> ts'<font color=Cyan>)</font> <font color=Cyan>)</font>-<a name="(line108)"></a>-<a name="(line109)"></a><a name="satisfy"></a><font color=Blue>-- | Yield one token if it satisfies a predicate.</font>-<a name="(line110)"></a>satisfy <font color=Red>::</font> <font color=Cyan>(</font>t<font color=Red>-></font>Bool<font color=Cyan>)</font> <font color=Red>-></font> Parser s t t-<a name="(line111)"></a>satisfy p <font color=Red>=</font> <font color=Green><u>do</u></font><font color=Cyan>{</font> x <font color=Red><-</font> next-<a name="(line112)"></a> <font color=Cyan>;</font> <font color=Green><u>if</u></font> p x <font color=Green><u>then</u></font> return x <font color=Green><u>else</u></font> fail <font color=Magenta>"Parse.satisfy: failed"</font>-<a name="(line113)"></a> <font color=Cyan>}</font>-<a name="(line114)"></a>-<a name="(line115)"></a>-<a name="(line116)"></a><font color=Blue>------------------------------------------------------------------------</font>-<a name="(line117)"></a><font color=Blue>-- State handling</font>-<a name="(line118)"></a>-<a name="(line119)"></a><a name="stUpdate"></a><font color=Blue>-- | Update the internal state.</font>-<a name="(line120)"></a>stUpdate <font color=Red>::</font> <font color=Cyan>(</font>s<font color=Red>-></font>s<font color=Cyan>)</font> <font color=Red>-></font> Parser s t ()-<a name="(line121)"></a>stUpdate f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Cyan>(</font>Right ()<font color=Cyan>,</font> f s<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line122)"></a>-<a name="(line123)"></a><a name="stQuery"></a><font color=Blue>-- | Query the internal state.</font>-<a name="(line124)"></a>stQuery <font color=Red>::</font> <font color=Cyan>(</font>s<font color=Red>-></font>a<font color=Cyan>)</font> <font color=Red>-></font> Parser s t a-<a name="(line125)"></a>stQuery f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Cyan>(</font>Right <font color=Cyan>(</font>f s<font color=Cyan>)</font><font color=Cyan>,</font> s<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line126)"></a>-<a name="(line127)"></a><a name="stGet"></a><font color=Blue>-- | Deliver the entire internal state.</font>-<a name="(line128)"></a>stGet <font color=Red>::</font> Parser s t s-<a name="(line129)"></a>stGet <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Cyan>(</font>Right s<font color=Cyan>,</font> s<font color=Cyan>,</font> ts<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line130)"></a>-<a name="(line131)"></a><a name="reparse"></a><font color=Blue>------------------------------------------------------------------------</font>-<a name="(line132)"></a><font color=Blue>-- | Push some tokens back onto the front of the input stream and reparse.</font>-<a name="(line133)"></a><font color=Blue>-- This is useful e.g. for recursively expanding macros. When the</font>-<a name="(line134)"></a><font color=Blue>-- user-parser recognises a macro use, it can lookup the macro</font>-<a name="(line135)"></a><font color=Blue>-- expansion from the parse state, lex it, and then stuff the</font>-<a name="(line136)"></a><font color=Blue>-- lexed expansion back down into the parser.</font>-<a name="(line137)"></a>reparse <font color=Red>::</font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Parser s t ()-<a name="(line138)"></a>reparse ts <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s inp<font color=Red>-></font> <font color=Cyan>(</font>Right ()<font color=Cyan>,</font> s<font color=Cyan>,</font> ts<font color=Cyan>++</font>inp<font color=Cyan>)</font><font color=Cyan>)</font>-<a name="(line139)"></a>-<a name="(line140)"></a><font color=Blue>------------------------------------------------------------------------</font>+<head>+<!-- Generated by HsColour, http://www.cs.york.ac.uk/fp/darcs/hscolour/ -->+<title>src/Text/ParserCombinators/Poly/StateLazy.hs</title>+</head>+<body>+<pre><a name="line-1"></a><font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>StateLazy+<a name="line-2"></a> <font color=Cyan>(</font> <font color=Blue>-- * The Parser datatype</font>+<a name="line-3"></a> Parser<font color=Cyan>(</font>P<font color=Cyan>)</font> <font color=Blue>-- datatype, instance of: Functor, Monad, PolyParse</font>+<a name="line-4"></a> <font color=Cyan>,</font> Result<font color=Cyan>(</font><font color=Red>..</font><font color=Cyan>)</font> <font color=Blue>-- internal to the parser monad</font>+<a name="line-5"></a> <font color=Cyan>,</font> runParser <font color=Blue>-- :: Parser s t a -> s -> [t] -> (Either String a, s, [t])</font>+<a name="line-6"></a> <font color=Blue>-- ** basic parsers</font>+<a name="line-7"></a> <font color=Cyan>,</font> next <font color=Blue>-- :: Parser s t t</font>+<a name="line-8"></a> <font color=Cyan>,</font> satisfy <font color=Blue>-- :: (t->Bool) -> Parser s t t</font>+<a name="line-9"></a> <font color=Cyan>,</font> manyFinally <font color=Blue>-- :: Parser s t a -> Parser s t z -> Parser s t [a]</font>+<a name="line-10"></a> <font color=Blue>-- ** State-handling</font>+<a name="line-11"></a> <font color=Cyan>,</font> stUpdate <font color=Blue>-- :: (s->s) -> Parser s t ()</font>+<a name="line-12"></a> <font color=Cyan>,</font> stQuery <font color=Blue>-- :: (s->a) -> Parser s t a</font>+<a name="line-13"></a> <font color=Cyan>,</font> stGet <font color=Blue>-- :: Parser s t s</font>+<a name="line-14"></a> <font color=Blue>-- ** re-parsing</font>+<a name="line-15"></a> <font color=Cyan>,</font> reparse <font color=Blue>-- :: [t] -> Parser s t ()</font>+<a name="line-16"></a> <font color=Blue>-- * Re-export all more general combinators</font>+<a name="line-17"></a> <font color=Cyan>,</font> <font color=Green><u>module</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base+<a name="line-18"></a> <font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-19"></a>+<a name="line-20"></a>+<a name="line-21"></a><font color=Green><u>import</u></font> Text<font color=Cyan>.</font>ParserCombinators<font color=Cyan>.</font>Poly<font color=Cyan>.</font>Base hiding <font color=Cyan>(</font>manyFinally<font color=Cyan>)</font>+<a name="line-22"></a>+<a name="line-23"></a><font color=Magenta><em>#if __GLASGOW_HASKELL__</em></font>+<a name="line-24"></a><font color=Green><u>import</u></font> Control<font color=Cyan>.</font>Exception hiding <font color=Cyan>(</font>bracket<font color=Cyan>)</font>+<a name="line-25"></a><a name="throwE"></a><font color=Blue>throwE</font> <font color=Red>::</font> String <font color=Red>-></font> a+<a name="line-26"></a><font color=Blue>throwE</font> msg <font color=Red>=</font> throw <font color=Cyan>(</font>ErrorCall msg<font color=Cyan>)</font>+<a name="line-27"></a><font color=Magenta><em>#else</em></font>+<a name="line-28"></a><font color=Blue>throwE</font> <font color=Red>::</font> String <font color=Red>-></font> a+<a name="line-29"></a><font color=Blue>throwE</font> msg <font color=Red>=</font> error msg+<a name="line-30"></a><font color=Magenta><em>#endif</em></font>+<a name="line-31"></a>+<a name="line-32"></a>+<a name="line-33"></a><a name="Parser"></a><font color=Blue>-- | This @Parser@ datatype is a fairly generic parsing monad with error</font>+<a name="line-34"></a><a name="Parser"></a><font color=Blue>-- reporting. It can be used for arbitrary token types, not just</font>+<a name="line-35"></a><a name="Parser"></a><font color=Blue>-- String input. (If you require a running state, use module PolyState</font>+<a name="line-36"></a><a name="Parser"></a><font color=Blue>-- instead)</font>+<a name="line-37"></a><a name="Parser"></a><font color=Green><u>newtype</u></font> Parser s t a <font color=Red>=</font> P <font color=Cyan>(</font>s <font color=Red>-></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Result <font color=Red>[</font>t<font color=Red>]</font> s a<font color=Cyan>)</font>+<a name="line-38"></a>+<a name="line-39"></a><a name="Result"></a><font color=Blue>-- | A return type like Either, that distinguishes not only between</font>+<a name="line-40"></a><a name="Result"></a><font color=Blue>-- right and wrong answers, but also has gradations of wrongness.</font>+<a name="line-41"></a><a name="Result"></a><font color=Blue>-- This should only be used for writing very primitive</font>+<a name="line-42"></a><a name="Result"></a><font color=Blue>-- parsers - really it is an internal detail of the library.</font>+<a name="line-43"></a><a name="Result"></a><font color=Green><u>data</u></font> Result z s a <font color=Red>=</font> Success z s a+<a name="line-44"></a> <font color=Red>|</font> Failure z s String+<a name="line-45"></a> <font color=Red>|</font> Committed <font color=Cyan>(</font>Result z s a<font color=Cyan>)</font>+<a name="line-46"></a>+<a name="line-47"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Result z s<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-48"></a> fmap f <font color=Cyan>(</font>Success z s a<font color=Cyan>)</font> <font color=Red>=</font> Success z s <font color=Cyan>(</font>f a<font color=Cyan>)</font>+<a name="line-49"></a> fmap f <font color=Cyan>(</font>Failure z s e<font color=Cyan>)</font> <font color=Red>=</font> Failure z s e+<a name="line-50"></a> fmap f <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> Committed <font color=Cyan>(</font>fmap f r<font color=Cyan>)</font>+<a name="line-51"></a>+<a name="line-52"></a><a name="runParser"></a><font color=Blue>-- | Apply a parser to an input token sequence.</font>+<a name="line-53"></a><font color=Blue>runParser</font> <font color=Red>::</font> Parser s t a <font color=Red>-></font> s <font color=Red>-></font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> <font color=Cyan>(</font>a<font color=Cyan>,</font> s<font color=Cyan>,</font> <font color=Red>[</font>t<font color=Red>]</font><font color=Cyan>)</font>+<a name="line-54"></a><font color=Blue>runParser</font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> <font color=Red>\</font>s <font color=Red>-></font> fromResult <font color=Cyan>.</font> p s+<a name="line-55"></a> <font color=Green><u>where</u></font>+<a name="line-56"></a> fromResult <font color=Red>::</font> Result z s a <font color=Red>-></font> <font color=Cyan>(</font>a<font color=Cyan>,</font> s<font color=Cyan>,</font> z<font color=Cyan>)</font>+<a name="line-57"></a> fromResult <font color=Cyan>(</font>Success z s a<font color=Cyan>)</font> <font color=Red>=</font> <font color=Cyan>(</font>a<font color=Cyan>,</font> s<font color=Cyan>,</font> z<font color=Cyan>)</font>+<a name="line-58"></a> fromResult <font color=Cyan>(</font>Failure z s e<font color=Cyan>)</font> <font color=Red>=</font> throwE e+<a name="line-59"></a> fromResult <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> fromResult r+<a name="line-60"></a>+<a name="line-61"></a><font color=Green><u>instance</u></font> Functor <font color=Cyan>(</font>Parser s t<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-62"></a> fmap f <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s <font color=Red>-></font> fmap f <font color=Cyan>.</font> p s<font color=Cyan>)</font>+<a name="line-63"></a>+<a name="line-64"></a><font color=Green><u>instance</u></font> Monad <font color=Cyan>(</font>Parser s t<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-65"></a> return x <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> Success ts s x<font color=Cyan>)</font>+<a name="line-66"></a> fail e <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> Failure ts s e<font color=Cyan>)</font>+<a name="line-67"></a> <font color=Cyan>(</font>P f<font color=Cyan>)</font> <font color=Cyan>>>=</font> g <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s<font color=Red>-></font> continue <font color=Cyan>.</font> f s<font color=Cyan>)</font>+<a name="line-68"></a> <font color=Green><u>where</u></font>+<a name="line-69"></a> continue <font color=Cyan>(</font>Success ts s x<font color=Cyan>)</font> <font color=Red>=</font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P g'<font color=Cyan>)</font> <font color=Red>=</font> g x <font color=Green><u>in</u></font> g' s ts+<a name="line-70"></a> continue <font color=Cyan>(</font>Committed <font color=Cyan>(</font>Committed r<font color=Cyan>)</font><font color=Cyan>)</font> <font color=Red>=</font> continue <font color=Cyan>(</font>Committed r<font color=Cyan>)</font>+<a name="line-71"></a> continue <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> Committed <font color=Cyan>(</font>continue r<font color=Cyan>)</font>+<a name="line-72"></a> continue <font color=Cyan>(</font>Failure ts s e<font color=Cyan>)</font> <font color=Red>=</font> Failure ts s e+<a name="line-73"></a>+<a name="line-74"></a><font color=Green><u>instance</u></font> PolyParse <font color=Cyan>(</font>Parser s t<font color=Cyan>)</font> <font color=Green><u>where</u></font>+<a name="line-75"></a> commit <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s<font color=Red>-></font> Committed <font color=Cyan>.</font> p s<font color=Cyan>)</font>+<a name="line-76"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`adjustErr`</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s<font color=Red>-></font> adjust <font color=Cyan>.</font> p s<font color=Cyan>)</font>+<a name="line-77"></a> <font color=Green><u>where</u></font>+<a name="line-78"></a> adjust <font color=Cyan>(</font>Failure z s e<font color=Cyan>)</font> <font color=Red>=</font> Failure z s <font color=Cyan>(</font>f e<font color=Cyan>)</font>+<a name="line-79"></a> adjust <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> Committed <font color=Cyan>(</font>adjust r<font color=Cyan>)</font>+<a name="line-80"></a> adjust good <font color=Red>=</font> good+<a name="line-81"></a>+<a name="line-82"></a> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Cyan>`onFail`</font> <font color=Cyan>(</font>P q<font color=Cyan>)</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> continue s ts <font color=Cyan>$</font> p s ts<font color=Cyan>)</font>+<a name="line-83"></a> <font color=Green><u>where</u></font>+<a name="line-84"></a> continue s ts <font color=Cyan>(</font>Failure <font color=Green><u>_</u></font> <font color=Green><u>_</u></font> <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>=</font> q s ts+<a name="line-85"></a> <font color=Blue>-- continue _ _ (Committed r) = r -- no, remain Committed</font>+<a name="line-86"></a> continue <font color=Green><u>_</u></font> <font color=Green><u>_</u></font> r <font color=Red>=</font> r+<a name="line-87"></a>+<a name="line-88"></a> oneOf' <font color=Red>=</font> accum []+<a name="line-89"></a> <font color=Green><u>where</u></font> accum errs [] <font color=Red>=</font>+<a name="line-90"></a> fail <font color=Cyan>(</font><font color=Magenta>"failed to parse any of the possible choices:\n"</font>+<a name="line-91"></a> <font color=Cyan>++</font>indent <font color=Magenta>2</font> <font color=Cyan>(</font>concatMap showErr <font color=Cyan>(</font>reverse errs<font color=Cyan>)</font><font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-92"></a> accum errs <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>P p<font color=Cyan>)</font><font color=Red><b>:</b></font>ps<font color=Cyan>)</font> <font color=Red>=</font>+<a name="line-93"></a> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> p s ts <font color=Green><u>of</u></font>+<a name="line-94"></a> Failure <font color=Green><u>_</u></font> <font color=Green><u>_</u></font> err <font color=Red>-></font>+<a name="line-95"></a> <font color=Green><u>let</u></font> <font color=Cyan>(</font>P p<font color=Cyan>)</font> <font color=Red>=</font> accum <font color=Cyan>(</font><font color=Cyan>(</font>e<font color=Cyan>,</font>err<font color=Cyan>)</font><font color=Red><b>:</b></font>errs<font color=Cyan>)</font> ps+<a name="line-96"></a> <font color=Green><u>in</u></font> p s ts+<a name="line-97"></a> r<font color=Red>@</font><font color=Cyan>(</font>Success z <font color=Green><u>_</u></font> a<font color=Cyan>)</font> <font color=Red>-></font> r+<a name="line-98"></a> r<font color=Red>@</font><font color=Cyan>(</font>Committed <font color=Green><u>_</u></font><font color=Cyan>)</font> <font color=Red>-></font> r <font color=Cyan>)</font>+<a name="line-99"></a> showErr <font color=Cyan>(</font>name<font color=Cyan>,</font>err<font color=Cyan>)</font> <font color=Red>=</font> name<font color=Cyan>++</font><font color=Magenta>":\n"</font><font color=Cyan>++</font>indent <font color=Magenta>2</font> err+<a name="line-100"></a>+<a name="line-101"></a> <font color=Blue>-- Apply a parsed function to a parsed value. This version</font>+<a name="line-102"></a> <font color=Blue>-- is strict in the result of the function parser, but</font>+<a name="line-103"></a> <font color=Blue>-- lazy in the result of the argument parser. (Argument laziness is</font>+<a name="line-104"></a> <font color=Blue>-- the distinctive feature over other implementations.)</font>+<a name="line-105"></a> <font color=Cyan>(</font>P pf<font color=Cyan>)</font> <font color=Cyan>`apply`</font> px <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s<font color=Red>-></font> continue <font color=Cyan>.</font> pf s<font color=Cyan>)</font>+<a name="line-106"></a> <font color=Green><u>where</u></font>+<a name="line-107"></a> continue <font color=Cyan>(</font>Success z s f<font color=Cyan>)</font> <font color=Red>=</font> <font color=Green><u>let</u></font> <font color=Cyan>(</font>x<font color=Cyan>,</font>s'<font color=Cyan>,</font>z'<font color=Cyan>)</font> <font color=Red>=</font> runParser px s z+<a name="line-108"></a> <font color=Green><u>in</u></font> Success z' s' <font color=Cyan>(</font>f x<font color=Cyan>)</font>+<a name="line-109"></a> continue <font color=Cyan>(</font>Failure z s e<font color=Cyan>)</font> <font color=Red>=</font> Failure z s e+<a name="line-110"></a> continue <font color=Cyan>(</font>Committed r<font color=Cyan>)</font> <font color=Red>=</font> Committed <font color=Cyan>(</font>continue r<font color=Cyan>)</font>+<a name="line-111"></a>+<a name="line-112"></a><a name="manyFinally"></a><font color=Blue>manyFinally</font> <font color=Red>::</font> Parser s t a <font color=Red>-></font> Parser s t z <font color=Red>-></font> Parser s t <font color=Red>[</font>a<font color=Red>]</font>+<a name="line-113"></a><font color=Blue>{-+<a name="line-114"></a>manyFinally pp@(P p) pt@(P t) = P (\s ts -> item s ts (p s ts))+<a name="line-115"></a> where+<a name="line-116"></a> item _ _ (Success ts s x) = success ts s x+<a name="line-117"></a> item s ts (Failure _ _ e) = terminate (t s ts)+<a name="line-118"></a> item s ts (Committed r) = Committed (within r)+<a name="line-119"></a>+<a name="line-120"></a> success ts s x =+<a name="line-121"></a> let (tail,s',ts') = runParser (manyFinally pp pt) s ts+<a name="line-122"></a> in Success ts' s' (x:tail)+<a name="line-123"></a>+<a name="line-124"></a> terminate (Success ts s _) = Success ts s []+<a name="line-125"></a> terminate (Failure ts s e) = Failure ts s e+<a name="line-126"></a> terminate (Committed r) = Committed (terminate r)+<a name="line-127"></a>+<a name="line-128"></a> within (Success ts s x) = success ts s x+<a name="line-129"></a> within (Failure ts s e) = Failure ts s e+<a name="line-130"></a> within (Committed r) = within r+<a name="line-131"></a>-}</font>+<a name="line-132"></a>+<a name="line-133"></a><font color=Blue>manyFinally</font> p z <font color=Red>=</font>+<a name="line-134"></a> <font color=Cyan>(</font><font color=Green><u>do</u></font> x <font color=Red><-</font> p<font color=Cyan>;</font> return <font color=Cyan>(</font>x<font color=Red><b>:</b></font><font color=Cyan>)</font> <font color=Cyan>`apply`</font> manyFinally p z<font color=Cyan>)</font>+<a name="line-135"></a> <font color=Cyan>`onFail`</font>+<a name="line-136"></a> <font color=Cyan>(</font><font color=Green><u>do</u></font> z<font color=Cyan>;</font> return []<font color=Cyan>)</font>+<a name="line-137"></a> <font color=Cyan>`onFail`</font>+<a name="line-138"></a> oneOf' <font color=Red>[</font> <font color=Cyan>(</font><font color=Magenta>"item in sequence"</font><font color=Cyan>,</font> <font color=Cyan>(</font><font color=Green><u>do</u></font> p<font color=Cyan>;</font> return []<font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-139"></a> <font color=Cyan>,</font> <font color=Cyan>(</font><font color=Magenta>"sequence terminator"</font><font color=Cyan>,</font> <font color=Cyan>(</font><font color=Green><u>do</u></font> z<font color=Cyan>;</font> return []<font color=Cyan>)</font><font color=Cyan>)</font> <font color=Red>]</font>+<a name="line-140"></a>+<a name="line-141"></a><a name="next"></a><font color=Blue>------------------------------------------------------------------------</font>+<a name="line-142"></a><font color=Blue>next</font> <font color=Red>::</font> Parser s t t+<a name="line-143"></a><font color=Blue>next</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> <font color=Green><u>case</u></font> ts <font color=Green><u>of</u></font>+<a name="line-144"></a> [] <font color=Red>-></font> Failure [] s <font color=Magenta>"Ran out of input (EOF)"</font>+<a name="line-145"></a> <font color=Cyan>(</font>t<font color=Red><b>:</b></font>ts'<font color=Cyan>)</font> <font color=Red>-></font> Success ts' s t <font color=Cyan>)</font>+<a name="line-146"></a>+<a name="line-147"></a><a name="satisfy"></a><font color=Blue>satisfy</font> <font color=Red>::</font> <font color=Cyan>(</font>t<font color=Red>-></font>Bool<font color=Cyan>)</font> <font color=Red>-></font> Parser s t t+<a name="line-148"></a><font color=Blue>satisfy</font> pred <font color=Red>=</font> <font color=Green><u>do</u></font> <font color=Cyan>{</font> x <font color=Red><-</font> next+<a name="line-149"></a> <font color=Cyan>;</font> <font color=Green><u>if</u></font> pred x <font color=Green><u>then</u></font> return x <font color=Green><u>else</u></font> fail <font color=Magenta>"Parse.satisfy: failed"</font>+<a name="line-150"></a> <font color=Cyan>}</font>+<a name="line-151"></a><font color=Blue>------------------------------------------------------------------------</font>+<a name="line-152"></a><font color=Blue>-- State handling</font>+<a name="line-153"></a>+<a name="line-154"></a><a name="stUpdate"></a><font color=Blue>-- | Update the internal state.</font>+<a name="line-155"></a><font color=Blue>stUpdate</font> <font color=Red>::</font> <font color=Cyan>(</font>s<font color=Red>-></font>s<font color=Cyan>)</font> <font color=Red>-></font> Parser s t ()+<a name="line-156"></a><font color=Blue>stUpdate</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> Success ts <font color=Cyan>(</font>f s<font color=Cyan>)</font> ()<font color=Cyan>)</font>+<a name="line-157"></a>+<a name="line-158"></a><a name="stQuery"></a><font color=Blue>-- | Query the internal state.</font>+<a name="line-159"></a><font color=Blue>stQuery</font> <font color=Red>::</font> <font color=Cyan>(</font>s<font color=Red>-></font>a<font color=Cyan>)</font> <font color=Red>-></font> Parser s t a+<a name="line-160"></a><font color=Blue>stQuery</font> f <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> Success ts s <font color=Cyan>(</font>f s<font color=Cyan>)</font><font color=Cyan>)</font>+<a name="line-161"></a>+<a name="line-162"></a><a name="stGet"></a><font color=Blue>-- | Deliver the entire internal state.</font>+<a name="line-163"></a><font color=Blue>stGet</font> <font color=Red>::</font> Parser s t s+<a name="line-164"></a><font color=Blue>stGet</font> <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s ts<font color=Red>-></font> Success ts s s<font color=Cyan>)</font>+<a name="line-165"></a>+<a name="line-166"></a><a name="reparse"></a><font color=Blue>------------------------------------------------------------------------</font>+<a name="line-167"></a><font color=Blue>-- | Push some tokens back onto the front of the input stream and reparse.</font>+<a name="line-168"></a><font color=Blue>-- This is useful e.g. for recursively expanding macros. When the</font>+<a name="line-169"></a><font color=Blue>-- user-parser recognises a macro use, it can lookup the macro</font>+<a name="line-170"></a><font color=Blue>-- expansion from the parse state, lex it, and then stuff the</font>+<a name="line-171"></a><font color=Blue>-- lexed expansion back down into the parser.</font>+<a name="line-172"></a><font color=Blue>reparse</font> <font color=Red>::</font> <font color=Red>[</font>t<font color=Red>]</font> <font color=Red>-></font> Parser s t ()+<a name="line-173"></a><font color=Blue>reparse</font> ts <font color=Red>=</font> P <font color=Cyan>(</font><font color=Red>\</font>s inp<font color=Red>-></font> Success <font color=Cyan>(</font>ts<font color=Cyan>++</font>inp<font color=Cyan>)</font> s ()<font color=Cyan>)</font>+<a name="line-174"></a>+<a name="line-175"></a><font color=Blue>------------------------------------------------------------------------</font> </pre>+</body> </html>
docs/index.html view
@@ -31,21 +31,26 @@ widely-used parser libraries available elsewhere. <ul>-<li> <b>Text.ParserCombinators.HuttonMeijer</b> The most venerable of all- monadic parser combinator libraries, this version dates from 1996.- Originally distributed with Gofer, then Hugs, as ParseLib. It uses- the idea of "failure as a list of successes" to give multiple- possible parses through backtracking. (But in practice, almost- nobody wants any parse except the first complete one.)-<li> <b>Text.ParserCombinators.HuttonMeijerWallace</b> The- Hutton/Meijer combinators, extended to take an arbitrary token type- as input (not just characters), plus a running state (e.g. to- collect a symbol table, or macros), plus some facilities for- simple error-reporting.+<li> <b>Text.Parse</b> The Text.Read class from Haskell'98 is widely+ recognised to have many problems. It is inefficient. If a read+ fails, there is no indication of why. Worst of all, a read failure+ crashes your whole program! Text.Parse is a proposed replacement+ for the Read class. It defines a new class, Parse, with methods+ that return an explicit notification of errors, through the Either+ type. It also defines a number of useful helper functions to+ enable the construction of parsers for textual representations of+ Haskell data structures, e.g. named fields. Unsurprisingly,+ Text.Parse is really just a specialisation of the Poly combinators+ for String input, and the entire Poly API is also re-exported.+ The <a href="http://repetae.net/~john/computer/haskell/DrIFT">DrIFT</a>+ tool can derive instances of the Parse class for you+ automatically. (Use the syntax <tt>{-! derive : Parse !-}</tt>) <li> <b>Text.ParserCombinators.Poly</b>+ Currently re-exports Text.ParserCombinators.Poly.Plain. The name Poly comes from the arbitrary token type. Thus, you can write your own lexer if you wish, rather than needing to encode- lexical analysis within the parser itself. This is a fresh+ lexical analysis within the parser itself.+<li> <b>Text.ParserCombinators.Poly.Plain</b> This is a fresh set of combinators, improving on the HuttonMeijer variety by keeping only a single success, not a list of them. This is more space-efficient, whilst still permitting backtracking.@@ -56,9 +61,9 @@ already passed a point of commitment. Thus you can give far more accurate error messages to the user, including multi-layered locations.-<li> <b>Text.ParserCombinators.PolyState</b> is just like Poly, except it+<li> <b>Text.ParserCombinators.Poly.State</b> is just like Poly, except it adds an arbitrary running state parameter.-<li> <b>Text.ParserCombinators.PolyLazy</b> is just like Poly, except it+<li> <b>Text.ParserCombinators.Poly.Lazy</b> is just like Poly, except it does not return explicit failures. Instead, an exception is raised. Thus, it can return a partial parse result, before a full parse is complete. The word partial indicates that, having committed to@@ -69,51 +74,29 @@ space-efficiency - essentially you can stream-process your parsed data-structure within very small constant space. This is especially useful for large structures like e.g. XML trees.-<li> <b>Text.ParserCombinators.PolyStateLazy</b> combines PolyState and- PolyLazy.+<li> <b>Text.ParserCombinators.Poly.StateLazy</b> combines Poly.State and+ Poly.Lazy. <li> <b>Text.ParserCombinators.Poly.Base</b>- Following on from the basic Poly combinators, it became clear that- all of the variations share a lot in common, and that many of the+ All of the Poly variations (Plain, Lazy, State, etc)+ share a lot in common: many of the combinators are indeed implemented identically. To reduce code- duplication in the library, we now provide a class-based interface+ duplication in the library, we provide a class-based interface here. The actual implementations for strict, lazy, and so on, are instances of the class, defined in modules at the same level in the- hierarchy (e.g. T.P.Poly.Lazy etc).-<li> <b>Text.ParserCombinators.Poly.Plain</b>- The class instance for ordinary, strict, parsers, with arbitrary- token type.-<li> <b>Text.ParserCombinators.Poly.Lazy</b>- The class instance for lazy parsers, with arbitrary token type.-<li> <b>Text.ParserCombinators.Poly.State</b>- The class instance for strict parsers, with arbitrary token type- and running state.-<li> <b>Text.ParserCombinators.Poly.StateLazy</b>- The class instance for lazy parsers, with arbitrary token type- and running state.-<li> <b>Text.ParserCombinators.Poly.Stream</b>- The class instance for strict parsers, where input tokens arrive- in a Stream datatype rather than a list.-<li> <b>Text.ParserCombinators.Poly.NoLeak.Plain</b>- An experimental implementation of strict parsers, attempting to- avoid a particular space leak associated with the choice- combinator.-<li> <b>Text.ParserCombinators.Poly.NoLeak.Lazy</b>-<li> <b>Text.ParserCombinators.Poly.NoLeak.State</b>-<li> <b>Text.ParserCombinators.Poly.NoLeak.StateLazy</b>-<li> <b>Text.Parse</b> The Text.Read class from Haskell'98 is widely- recognised to have many problems. It is inefficient. If a read- fails, there is no indication of why. Worst of all, a read failure- crashes your whole program! Text.Parse is a proposed replacement- for the Read class. It defines a new class, Parse, with methods- that return an explicit notification of errors, through the Either- type. It also defines a number of useful helper functions to- enable the construction of parsers for textual representations of- Haskell data structures, e.g. named fields. Unsurprisingly,- Text.Parse is really just a specialisation of the Poly combinators- for String input, and the entire Poly API is also re-exported.- The <a href="http://repetae.net/~john/computer/haskell/DrIFT">DrIFT</a>- tool can derive instances of the Parse class for you- automatically. (Use the syntax <tt>{-! derive : Parse !-}</tt>)+ hierarchy (e.g. T.P.Poly.Lazy etc). Every individual variation+ re-exports these base combinators, so there should be no need to+ import this module directly.+<li> <b>Text.ParserCombinators.HuttonMeijer</b> The most venerable of all+ monadic parser combinator libraries, this version dates from 1996.+ Originally distributed with Gofer, then Hugs, as ParseLib. It uses+ the idea of "failure as a list of successes" to give multiple+ possible parses through backtracking. (But in practice, almost+ nobody wants any parse except the first complete one.)+<li> <b>Text.ParserCombinators.HuttonMeijerWallace</b> The+ Hutton/Meijer combinators, extended to take an arbitrary token type+ as input (not just characters), plus a running state (e.g. to+ collect a symbol table, or macros), plus some facilities for+ simple error-reporting. </ul> <p> All the <b>Poly*</b> variations share the same basic API, so it is easy@@ -178,10 +161,10 @@ <p> <b>Current released version:</b><br>-polyparse-1.1, release date 2007.10.23<br>+polyparse-1.2, release date 2009.03.04<br> By HTTP:-<a href="http://www.cs.york.ac.uk/fp/polyparse-1.1.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/polyparse-1.1.zip">.zip</a>.+<a href="http://www.cs.york.ac.uk/fp/polyparse/polyparse-1.2.tar.gz">.tar.gz</a>,+<a href="http://www.cs.york.ac.uk/fp/polyparse/polyparse-1.2.zip">.zip</a>. <br> By FTP: <a href="ftp://ftp.cs.york.ac.uk/pub/haskell/polyparse/">@@ -189,12 +172,17 @@ <p> <b>Older versions:</b><br>+polyparse-1.1, release date 2007.10.23<br>+By HTTP:+<a href="http://www.cs.york.ac.uk/fp/polyparse/polyparse-1.1.tar.gz">.tar.gz</a>,+<a href="http://www.cs.york.ac.uk/fp/polyparse/polyparse-1.1.zip">.zip</a>.+<br> polyparse-1.0, release date 2007.01.26<br> By HTTP:-<a href="http://www.cs.york.ac.uk/fp/polyparse-1.0.tar.gz">.tar.gz</a>,-<a href="http://www.cs.york.ac.uk/fp/polyparse-1.0.zip">.zip</a>.+<a href="http://www.cs.york.ac.uk/fp/polyparse/polyparse-1.0.tar.gz">.tar.gz</a>,+<a href="http://www.cs.york.ac.uk/fp/polyparse/polyparse-1.0.zip">.zip</a>. <br>-By FTP: +All older versions by FTP: <a href="ftp://ftp.cs.york.ac.uk/pub/haskell/polyparse/"> ftp://ftp.cs.york.ac.uk/pub/haskell/polyparse/</a> @@ -227,6 +215,13 @@ <hr> <center><h3><a name="news">Recent news</a></h3></center>+<p>+Version 1.2 improves the Text.Parse implementation significantly. Where+previously all the parsers for builtin basic datatype (Int,Float,Char)+were just thin wrappers over the H'98 Read instances, now they are all+proper parsers, therefore they should (a) be faster; (b) give better+error messages.+ <p> Version 1.1 much improves the laziness characteristics of the Poly* combinators. There are also a lot of new implementations of the Poly*
polyparse.cabal view
@@ -1,7 +1,6 @@ name: polyparse-version: 1.1-ghc-options: -DVERSION="1.1"-cc-options: -DVERSION="1.1"+version: 1.2+cpp-options: -DVERSION="1.2" nhc98-options: -K6M license: LGPL license-file: COPYRIGHT@@ -21,19 +20,13 @@ Text.ParserCombinators.HuttonMeijer, Text.ParserCombinators.HuttonMeijerWallace, Text.ParserCombinators.Poly,- Text.ParserCombinators.PolyState,- Text.ParserCombinators.PolyLazy,- Text.ParserCombinators.PolyStateLazy, Text.ParserCombinators.Poly.Base, Text.ParserCombinators.Poly.Plain, Text.ParserCombinators.Poly.Lazy, Text.ParserCombinators.Poly.State, Text.ParserCombinators.Poly.StateLazy,- Text.ParserCombinators.Poly.NoLeak.Plain,- Text.ParserCombinators.Poly.NoLeak.State,- Text.ParserCombinators.Poly.NoLeak.Lazy,- Text.ParserCombinators.Poly.NoLeak.StateLazy, Text.Parse-hs-source-dir: src+hs-source-dirs: src build-depends: base, haskell98+build-type: Simple extensions: CPP
src/Makefile view
@@ -1,22 +1,15 @@ SOFTWARE = polyparse-VERSION = 1.1+VERSION = 1.2 LIBSRCS = \ Text/ParserCombinators/HuttonMeijer.hs \ Text/ParserCombinators/HuttonMeijerWallace.hs \ Text/ParserCombinators/Poly.hs \- Text/ParserCombinators/PolyState.hs \- Text/ParserCombinators/PolyLazy.hs \- Text/ParserCombinators/PolyStateLazy.hs \ Text/ParserCombinators/Poly/Base.hs \ Text/ParserCombinators/Poly/Plain.hs \ Text/ParserCombinators/Poly/Lazy.hs \ Text/ParserCombinators/Poly/State.hs \ Text/ParserCombinators/Poly/StateLazy.hs \- Text/ParserCombinators/Poly/NoLeak/Plain.hs \- Text/ParserCombinators/Poly/NoLeak/Lazy.hs \- Text/ParserCombinators/Poly/NoLeak/State.hs \- Text/ParserCombinators/Poly/NoLeak/StateLazy.hs \ Text/Parse.hs \ LIBOBJS = $(patsubst %.hs, %.o, $(LIBSRCS))
src/Text/Parse.hs view
@@ -9,15 +9,26 @@ , word -- :: TextParser String , isWord -- :: String -> TextParser () , optionalParens -- :: TextParser a -> TextParser a+ , parens -- :: Bool -> TextParser a -> TextParser a , field -- :: Parse a => String -> TextParser a , constructors-- :: [(String,TextParser a)] -> TextParser a , enumeration -- :: Show a => String -> [a] -> TextParser a+ -- ** Parsers for literal numerics and characters+ , parseSigned+ , parseInt+ , parseDec+ , parseOct+ , parseHex+ , parseFloat+ , parseLitChar -- ** Re-export all the more general combinators from Poly too , module Text.ParserCombinators.Poly ) where -import Char (isSpace)+import Char (isSpace,toLower,isUpper,isDigit,isOctDigit,isHexDigit,digitToInt+ ,ord,chr) import List (intersperse)+import Ratio import Text.ParserCombinators.Poly ------------------------------------------------------------------------@@ -37,7 +48,17 @@ -- is generated by the corresponding instance of @show@. To apply a parser -- to some text, use @runParser@. class Parse a where+ -- | A straightforward parser for an item. (A minimal definition of+ -- a class instance requires either |parse| or |parsePrec|.) parse :: TextParser a+ parse = parsePrec 0+ -- | A straightforward parser for an item, given the precedence of+ -- any surrounding expression. (Precedence determines whether+ -- parentheses are mandatory or optional.)+ parsePrec :: Int -> TextParser a+ parsePrec _ = parens False parse+ -- | Parsing a list of items by default accepts the [] and comma syntax,+ -- except when the list is really a character string using \"\". parseList :: TextParser [a] -- only to distinguish [] and "" parseList = do { isWord "[]"; return [] } `onFail`@@ -47,21 +68,24 @@ `adjustErr` ("Expected a list, but\n"++) -- | If there already exists a Read instance for a type, then we can make--- a Parser for it, but with only poor error-reporting.+-- a Parser for it, but with only poor error-reporting. The string argument+-- is the expected type or value (for error-reporting only). parseByRead :: Read a => String -> TextParser a parseByRead name = P (\s-> case reads s of- [] -> (Left (False,"no parse, expected a "++name), s)- [(a,s')] -> (Right a, s')- _ -> (Left (False,"ambiguous parse, expected a "++name), s)+ [] -> Failure s ("no parse, expected a "++name)+ [(a,s')] -> Success s' a+ _ -> Failure s ("ambiguous parse, expected a "++name) ) -- | One lexical chunk (Haskell-style lexing). word :: TextParser String word = P (\s-> case lex s of- [] -> (Left (False,"no input? (impossible)"), s)- [("",s')] -> (Left (False,"no input?"), s')- ((x,s'):_) -> (Right x, s') )+ [] -> Failure s ("no input? (impossible)")+ [("","")] -> Failure "" ("no input?")+ [("",s')] -> Failure s ("lexing failed?")+ ((x,s'):_) -> Success s' x+ ) -- | Ensure that the next input word is the given string. (Note the input -- is lexed as haskell, so wordbreaks at spaces, symbols, etc.)@@ -74,6 +98,11 @@ optionalParens :: TextParser a -> TextParser a optionalParens p = bracket (isWord "(") (isWord ")") p `onFail` p +-- | Allow nested parens around an item (one set required when Bool is True).+parens :: Bool -> TextParser a -> TextParser a+parens True p = bracket (isWord "(") (isWord ")") (parens False p)+parens False p = parens True p `onFail` p+ -- | Deal with named field syntax. The string argument is the field name, -- and the parser returns the value of the field. field :: Parse a => String -> TextParser a@@ -93,6 +122,23 @@ } ) +{-+-- | Parse an infix constructor.+infixConstructor :: (Parse a, Parse b) =>+ String -> Int -> (a->b->c) -> Int -> TextParser c+infixConstructor name prec cons = \d->+ parens (prec<d) (do a <- parsePrec (prec+1)+ isWord name `adjustErr`+ (++("expected infix constructor "++name))+ b <- parsePrec (prec+1)+ return (cons a b) )++--infixLeftAssoc :: (Parse a, Parse b) =>+-- String -> Int -> (a->b->a) -> Int -> TextParser a+--infixLeftAssoc name prec cons = \d->+-- parens (prec<d) (do a <- +-}+ -- | Parse one of the given nullary constructors (an enumeration). -- The string argument is the name of the type, and the list argument -- should contain all of the possible enumeration values.@@ -106,17 +152,167 @@ ------------------------------------------------------------------------ -- Instances for all the Standard Prelude types. +-- Numeric types+parseSigned :: Real a => TextParser a -> TextParser a+parseSigned p = do '-' <- next; commit (fmap negate p)+ `onFail`+ do p++parseInt :: (Integral a) => String ->+ a -> (Char -> Bool) -> (Char -> Int) ->+ a -> TextParser a+parseInt base radix isDigit digitToInt n = go n+ where go acc = do cs <- many1 (satisfy isDigit)+ return (foldl1 (\n d-> n*radix+d)+ (map (fromIntegral.digitToInt) cs))+ `adjustErr` (++("\nexpected one or more "++base++" digits"))+parseDec, parseOct, parseHex :: (Integral a) => a -> TextParser a+parseDec = parseInt "decimal" 10 Char.isDigit Char.digitToInt+parseOct = parseInt "octal" 8 Char.isOctDigit Char.digitToInt+parseHex = parseInt "hex" 16 Char.isHexDigit Char.digitToInt++parseFloat :: (RealFrac a) => TextParser a+parseFloat = do ds <- many1 (satisfy isDigit)+ frac <- (do '.' <- next+ many (satisfy isDigit)+ `adjustErrBad` (++"expected digit after .")+ `onFail` return [] )+ exp <- (do 'e' <- fmap toLower next+ commit (do '+' <- next; parseDec 0+ `onFail`+ parseSigned (parseDec 0) ))+ ( return . fromRational . (* (10^^(exp - length frac)))+ . (%1) . (\ (Right x)->x) . fst+ . runParser (parseDec 0) ) (ds++frac)+ `onFail`+ do w <- many (satisfy (not.isSpace))+ case map toLower w of+ "nan" -> return (0/0)+ "infinity" -> return (1/0)+ _ -> fail "expected a floating point number"++parseLitChar :: TextParser Char+parseLitChar = do '\'' <- next `adjustErr` (++"expected a literal char")+ c <- next+ char <- case c of+ '\\' -> next >>= escape+ '\'' -> fail "expected a literal char, got ''"+ _ -> return c+ '\'' <- next `adjustErrBad` (++"literal char has no final '")+ return char+ where+ escape 'a' = return '\a'+ escape 'b' = return '\b'+ escape 'f' = return '\f'+ escape 'n' = return '\n'+ escape 'r' = return '\r'+ escape 't' = return '\t'+ escape 'v' = return '\v'+ escape '\\' = return '\\'+ escape '"' = return '"'+ escape '\'' = return '\''+ escape '^' = do ctrl <- next+ if ctrl >= '@' && ctrl <= '_'+ then return (chr (ord ctrl - ord '@'))+ else fail ("literal char ctrl-escape malformed: \\^"+ ++[ctrl])+ escape d | isDigit d+ = fmap chr $ parseDec (Char.digitToInt d)+ escape 'o' = fmap chr $ parseOct 0+ escape 'x' = fmap chr $ parseHex 0+ escape c | isUpper c+ = mnemonic c+ escape c = fail ("unrecognised escape sequence in literal char: \\"++[c])++ mnemonic 'A' = do 'C' <- next; 'K' <- next; return '\ACK'+ `wrap` "'\\ACK'"+ mnemonic 'B' = do 'E' <- next; 'L' <- next; return '\BEL'+ `onFail`+ do 'S' <- next; return '\BS'+ `wrap` "'\\BEL' or '\\BS'"+ mnemonic 'C' = do 'R' <- next; return '\CR'+ `onFail`+ do 'A' <- next; 'N' <- next; return '\CAN'+ `wrap` "'\\CR' or '\\CAN'"+ mnemonic 'D' = do 'E' <- next; 'L' <- next; return '\DEL'+ `onFail`+ do 'L' <- next; 'E' <- next; return '\DLE'+ `onFail`+ do 'C' <- next; ( do '1' <- next; return '\DC1'+ `onFail`+ do '2' <- next; return '\DC2'+ `onFail`+ do '3' <- next; return '\DC3'+ `onFail`+ do '4' <- next; return '\DC4' )+ `wrap` "'\\DEL' or '\\DLE' or '\\DC[1..4]'"+ mnemonic 'E' = do 'T' <- next; 'X' <- next; return '\ETX'+ `onFail`+ do 'O' <- next; 'T' <- next; return '\EOT'+ `onFail`+ do 'N' <- next; 'Q' <- next; return '\ENQ'+ `onFail`+ do 'T' <- next; 'B' <- next; return '\ETB'+ `onFail`+ do 'M' <- next; return '\EM'+ `onFail`+ do 'S' <- next; 'C' <- next; return '\ESC'+ `wrap` "one of '\\ETX' '\\EOT' '\\ENQ' '\\ETB' '\\EM' or '\\ESC'"+ mnemonic 'F' = do 'F' <- next; return '\FF'+ `onFail`+ do 'S' <- next; return '\FS'+ `wrap` "'\\FF' or '\\FS'"+ mnemonic 'G' = do 'S' <- next; return '\GS'+ `wrap` "'\\GS'"+ mnemonic 'H' = do 'T' <- next; return '\HT'+ `wrap` "'\\HT'"+ mnemonic 'L' = do 'F' <- next; return '\LF'+ `wrap` "'\\LF'"+ mnemonic 'N' = do 'U' <- next; 'L' <- next; return '\NUL'+ `onFail`+ do 'A' <- next; 'K' <- next; return '\NAK'+ `wrap` "'\\NUL' or '\\NAK'"+ mnemonic 'R' = do 'S' <- next; return '\RS'+ `wrap` "'\\RS'"+ mnemonic 'S' = do 'O' <- next; 'H' <- next; return '\SOH'+ `onFail`+ do 'O' <- next; return '\SO'+ `onFail`+ do 'T' <- next; 'X' <- next; return '\STX'+ `onFail`+ do 'I' <- next; return '\SI'+ `onFail`+ do 'Y' <- next; 'N' <- next; return '\SYN'+ `onFail`+ do 'U' <- next; 'B' <- next; return '\SUB'+ `onFail`+ do 'P' <- next; return '\SP'+ `wrap` "'\\SOH' '\\SO' '\\STX' '\\SI' '\\SYN' '\\SUB' or '\\SP'"+ mnemonic 'U' = do 'S' <- next; return '\US'+ `wrap` "'\\US'"+ mnemonic 'V' = do 'T' <- next; return '\VT'+ `wrap` "'\\VT'"+ wrap p s = p `onFail` fail ("expected literal char "++s)+ -- Basic types instance Parse Int where- parse = parseByRead "Int"+ -- parse = parseByRead "Int" -- convert from Integer, deals with minInt+ parse = fmap fromInteger $+ do many (satisfy isSpace); parseSigned (parseDec 0) instance Parse Integer where- parse = parseByRead "Integer"+ -- parse = parseByRead "Integer"+ parse = do many (satisfy isSpace); parseSigned (parseDec 0) instance Parse Float where- parse = parseByRead "Float"+ -- parse = parseByRead "Float"+ parse = do many (satisfy isSpace); parseSigned parseFloat instance Parse Double where- parse = parseByRead "Double"+ -- parse = parseByRead "Double"+ parse = do many (satisfy isSpace); parseSigned parseFloat instance Parse Char where- parse = parseByRead "Char"+-- parse = parseByRead "Char"+ parse = do many (satisfy isSpace); parseLitChar+ -- parse = do { w <- word; if head w == '\'' then readLitChar (tail w)+ -- else fail "expected a char" } -- parseList = bracket (isWord "\"") (satisfy (=='"')) -- (many (satisfy (/='"'))) -- not totally correct for strings...@@ -132,13 +328,12 @@ -- Structural types instance Parse () where parse = P p- where p [] = (Left (False,"no input: expected a ()"), [])+ where p [] = Failure [] "no input: expected a ()" p ('(':cs) = case dropWhile isSpace cs of- (')':s) -> (Right (), s)- _ -> (Left (False,"Expected ) after ("), cs)+ (')':s) -> Success s ()+ _ -> Failure cs "Expected ) after (" p (c:cs) | isSpace c = p cs- | otherwise = ( Left (False,"Expected a (), got "++show c)- , (c:cs))+ | otherwise = Failure (c:cs) ("Expected a (), got "++show c) instance (Parse a, Parse b) => Parse (a,b) where parse = do{ isWord "(" `adjustErr` ("Opening a 2-tuple\n"++)@@ -159,17 +354,19 @@ ; return (x,y,z) } instance Parse a => Parse (Maybe a) where- parse = do { isWord "Nothing"; return Nothing }- `onFail`- do { isWord "Just"- ; fmap Just $ optionalParens parse- `adjustErrBad` ("but within Just, "++)- }- `adjustErr` (("expected a Maybe (Just or Nothing)\n"++).indent 2)+ parsePrec p =+ parens False (do { isWord "Nothing"; return Nothing })+ `onFail`+ parens (p>9) (do { isWord "Just"+ ; fmap Just $ parsePrec 10+ `adjustErrBad` ("but within Just, "++) })+ `adjustErr` (("expected a Maybe (Just or Nothing)\n"++).indent 2) instance (Parse a, Parse b) => Parse (Either a b) where- parse = constructors [ ("Left", do { fmap Left $ optionalParens parse } )- , ("Right", do { fmap Right $ optionalParens parse } )+ parsePrec p =+ parens (p>9) $+ constructors [ ("Left", do { fmap Left $ parsePrec 10 } )+ , ("Right", do { fmap Right $ parsePrec 10 } ) ] instance Parse a => Parse [a] where
src/Text/ParserCombinators/Poly.hs view
@@ -1,247 +1,5 @@ module Text.ParserCombinators.Poly- ( -- * The Parser datatype- Parser(P) -- datatype, instance of: Functor, Monad- , runParser -- :: Parser t a -> [t] -> (Either String a, [t])- , failBad -- :: String -> Parser t a- , commit -- :: Parser t a -> Parser t a-- -- * Combinators:- -- ** Primitives- , next -- :: Parser t t- , satisfy -- :: (t->Bool) -> Parser t t- , apply -- :: Parser t (a->b) -> Parser t a -> Parser t b- , discard -- :: Parser t a -> Parser t b -> Parser t a- -- ** Error-handling- , adjustErr -- :: Parser t a -> (String->String) -> Parser t a- , adjustErrBad-- :: Parser t a -> (String->String) -> Parser t a- , indent -- :: Int -> String -> String- -- ** Choices- , onFail -- :: Parser t a -> Parser t a -> Parser t a- , oneOf -- :: Show t => [Parser t a] -> Parser t a- , oneOf' -- :: [(String,Parser t a)] -> Parser t a- , optional -- :: Parser t a -> Parser t (Maybe a)- -- ** Sequences- , exactly -- :: Int -> Parser t a -> Parser t [a]- , many -- :: Parser t a -> Parser t [a]- , many1 -- :: Parser t a -> Parser t [a]- , sepBy -- :: Parser t a -> Parser t sep -> Parser t [a]- , sepBy1 -- :: Parser t a -> Parser t sep -> Parser t [a]- , bracketSep -- :: Parser t bra -> Parser t sep -> Parser t ket- -- -> Parser t a -> Parser t [a]- , bracket -- :: Parser t bra -> Parser t ket -> Parser t a- -- -> Parser t a- , manyFinally -- :: Parser t a -> Parser t z -> Parser t [a]- -- ** re-parsing- , reparse -- :: [t] -> Parser t ()+ ( module Text.ParserCombinators.Poly.Plain ) where ---- | The @Parser@ datatype is a fairly generic parsing monad with error--- reporting. It can be used for arbitrary token types, not just--- String input. (If you require a running state, use module PolyState--- instead)-newtype Parser t a = P ([t] -> (EitherE String a, [t]))---- A return type like Either, that distinguishes not only between--- right and wrong answers, but also has gradations of wrongness.-type EitherE a b = Either (Bool,a) b---- | Apply a parser to an input token sequence.-runParser :: Parser t a -> [t] -> (Either String a, [t])-runParser (P p) =- (\ (e,ts)-> (case e of {Left (_,m)->Left m; Right m->Right m}, ts) )- . p--instance Functor (Parser t) where- fmap f (P p) = P (\ts-> case p ts of- (Left msg, ts') -> (Left msg, ts')- (Right x, ts') -> (Right (f x), ts'))-instance Monad (Parser t) where- return x = P (\ts-> (Right x, ts))- (P f) >>= g = P (\ts-> case f ts of- (Left msg, ts') -> (Left msg, ts')- (Right x, ts') -> let (P g') = g x in g' ts')- fail e = P (\ts-> (Left (False,e), ts))---- | When a simple fail is not strong enough, use failBad for emphasis.--- An emphasised (severe) error can propagate out through choice operators.-failBad :: String -> Parser t a-failBad msg = P (\ts-> (Left (True,msg), ts))---- | Commit is a way of raising the severity of any errors found within--- its argument. Used in the middle of a parser definition, it means that--- any operations prior to commitment fail softly, but after commitment,--- they fail hard.-commit :: Parser t a -> Parser t a-commit (P p) = P (\ts-> case p ts of- (Left (_,e), ts') -> (Left (True,e), ts')- right -> right )----- Combinators---- | One token-next :: Parser t t-next = P (\ts-> case ts of- [] -> (Left (False,"Ran out of input (EOF)"), [])- (t:ts') -> (Right t, ts') )---- | One token satifying a predicate-satisfy :: (t->Bool) -> Parser t t-satisfy p = do{ x <- next- ; if p x then return x else fail "Parse.satisfy: failed"- }--infixl 3 `apply`--- | Apply a parsed function to a parsed value-apply :: Parser t (a->b) -> Parser t a -> Parser t b-pf `apply` px = do { f <- pf; x <- px; return (f x) }--infixl 3 `discard`--- | @x `discard` y@ parses both x and y, but discards the result of y-discard :: Parser t a -> Parser t b -> Parser t a-px `discard` py = do { x <- px; _ <- py; return x }---- | @p `adjustErr` f@ applies the transformation @f@ to any error message--- generated in @p@, having no effect if @p@ succeeds.-adjustErr :: Parser t a -> (String->String) -> Parser t a-(P p) `adjustErr` f = P (\ts-> case p ts of- (Left (b,msg), ts') -> (Left (b,(f msg)), ts')- right -> right )---- | @adjustErrBad@ is just like @adjustErr@ except it also raises the--- severity of the error.-adjustErrBad :: Parser t a -> (String->String) -> Parser t a-p `adjustErrBad` f = commit (p `adjustErr` f)--infixl 6 `onFail` -- not sure about precedence 6?--- | @p `onFail` q@ means parse p unless p fails in which case parse q instead.--- Can be chained together to give multiple attempts to parse something.--- (Note that q could itself be a failing parser, e.g. to change the error--- message from that defined in p to something different.)--- However, a *severe* failure in p cannot be ignored.-onFail :: Parser t a -> Parser t a -> Parser t a-(P p) `onFail` (P q) = P (\ts-> case p ts of- r@(Left (True,_), _) -> r- (Left _, _) -> q ts- right -> right )---- | Parse the first alternative in the list that succeeds.-oneOf :: [Parser t a] -> Parser t a-oneOf [] = do { n <- next- ; fail ("failed to parse any of the possible choices")- }---oneOf :: Show t => [Parser t a] -> Parser t a---oneOf [] = do { n <- next--- ; fail ("failed to parse any of the possible choices"--- ++"\n next token is "++show n)--- }-oneOf (p:ps) = p `onFail` oneOf ps---- | Parse the first alternative that succeeds, but if none succeed,--- report only the severe errors, and if none of those, then report--- all the soft errors.-oneOf' :: [(String, Parser t a)] -> Parser t a-oneOf' = accum []- where accum errs [] =- case filter isBad errs of- [] -> fail ("failed to parse any of the possible choices:\n"- ++indent 2 (concatMap showErr (reverse errs)))- [(_,(_,e))] -> failBad e- es -> failBad ("one of the following failures occurred:\n"- ++indent 2 (concatMap showErr (reverse es)))- accum errs ((e,P p):ps) =- P (\ts-> case p ts of- (Left err,_) -> let (P p) = accum ((e,err):errs) ps- in p ts- right -> right )- showErr (name,(_,err)) = name++":\n"++indent 2 err- isBad (_,(b,_)) = b---- | Helper for formatting error messages: indents all lines by a fixed amount.-indent :: Int -> String -> String-indent n = unlines . map (replicate n ' ' ++) . lines---- | 'optional' indicates whether the parser succeeded through the Maybe type.-optional :: Parser t a -> Parser t (Maybe a)-optional p = fmap Just p `onFail` return Nothing---- | 'exactly n p' parses a precise number of items, n, using the parser--- p, in sequence.-exactly :: Int -> Parser t a -> Parser t [a]-exactly 0 p = return []-exactly n p = do x <- p- xs <- exactly (n-1) p- return (x:xs)---- | 'many p' parses a list of elements with individual parser p.--- Cannot fail, since an empty list is a valid return value.-many :: Parser t a -> Parser t [a]-many p = many1 p `onFail` return []---- | Parse a non-empty list of items.-many1 :: Parser t a -> Parser t [a]-many1 p = do { x <- p `adjustErr` (("In a sequence:\n"++). indent 2)- ; xs <- many p- ; return (x:xs)- }--- `adjustErr` ("When looking for a non-empty sequence:\n\t"++)---- | Parse a list of items separated by discarded junk.-sepBy :: Parser t a -> Parser t sep -> Parser t [a]-sepBy p sep = do sepBy1 p sep `onFail` return []---- | Parse a non-empty list of items separated by discarded junk.-sepBy1 :: Parser t a -> Parser t sep -> Parser t [a]-sepBy1 p sep = do { x <- p- ; xs <- many (do {sep; p})- ; return (x:xs)- }- `adjustErr` ("When looking for a non-empty sequence with separators:\n\t"++)- --- | Parse a list of items, discarding the start, end, and separator--- items.-bracketSep :: Parser t bra -> Parser t sep -> Parser t ket- -> Parser t a -> Parser t [a]-bracketSep open sep close p =- do { open; close; return [] }- `onFail`- do { open `adjustErr` ("Missing opening bracket:\n\t"++)- ; x <- p `adjustErr` ("After first bracket in a group:\n\t"++)- ; xs <- many (do {sep; p})- ; close `adjustErrBad` ("When looking for closing bracket:\n\t"++)- ; return (x:xs)- }---- | Parse a bracketed item, discarding the brackets.-bracket :: Parser t bra -> Parser t ket -> Parser t a -> Parser t a-bracket open close p = do- do { open `adjustErr` ("Missing opening bracket:\n\t"++)- ; x <- p- ; close `adjustErrBad` ("Missing closing bracket:\n\t"++)- ; return x- }---- | 'manyFinally e t' parses a possibly-empty sequence of e's,--- terminated by a t. Any parse failures could be due either to--- a badly-formed terminator or a badly-formed element, so raise--- both possible errors.-manyFinally :: Parser t a -> Parser t z -> Parser t [a]-manyFinally p t =- do { xs <- many p- ; oneOf' [ ("sequence terminator", do { t; return () } )- , ("item in a sequence", do { p; return () } )- ]- ; return xs- }----------------------------------------------------------------------------- | Push some tokens back onto the front of the input stream and reparse.--- This is useful e.g. for recursively expanding macros. When the--- user-parser recognises a macro use, it can lookup the macro--- expansion from the parse state, lex it, and then stuff the--- lexed expansion back down into the parser.-reparse :: [t] -> Parser t ()-reparse ts = P (\inp-> (Right (), ts++inp))--------------------------------------------------------------------------+import Text.ParserCombinators.Poly.Plain
src/Text/ParserCombinators/Poly/Base.hs view
@@ -23,6 +23,11 @@ , manyFinally -- :: PolyParse p => p a -> p z -> p [a] ) where +#ifdef __NHC__+default (Integer,Double,[]) -- hack to avoid bizarre type defaulting error+instance PolyParse []+#endif+ -- | The @PolyParse@ class is an abstraction over all the current -- concrete representations of monadic parser combinators in this -- package. The common feature is two-level error-handling.
src/Text/ParserCombinators/Poly/Lazy.hs view
@@ -1,22 +1,21 @@ module Text.ParserCombinators.Poly.Lazy- ( -- * The Parser datatype.- -- $parser- Parser(P) -- datatype, instance of: Functor, Monad- , runParser -- :: Parser t a -> [t] -> (a, [t])+ ( -- * The Parser datatype+ Parser(P) -- datatype, instance of: Functor, Monad, PolyParse+ , Result(..) -- internal to the parser monad+ , runParser -- :: Parser t a -> [t] -> (Either String a, [t]) -- ** basic parsers , next -- :: Parser t t , satisfy -- :: (t->Bool) -> Parser t t- -- one defn from 'Base' is overridden here, because it depends- -- on the representation of the Lazy parser monad- , manyFinally -- :: Parser t a -> Parser t z -> Parser t [a]- -- ** Re-parsing++ -- ** re-parsing , reparse -- :: [t] -> Parser t () -- * Re-export all more general combinators , module Text.ParserCombinators.Poly.Base ) where -import Text.ParserCombinators.Poly.Base hiding ( manyFinally ) +import Text.ParserCombinators.Poly.Base+ #if __GLASGOW_HASKELL__ import Control.Exception hiding (bracket) throwE :: String -> a@@ -26,103 +25,97 @@ throwE msg = error msg #endif --- $parser--- When applied, these parsers do not return explicit failure.--- An exception is--- raised instead. This allows partial results to be returned--- before a full parse is complete.--- One of the key ways to ensure that your parser is properly lazy,--- is to parse the initial portion of text returning a function, then--- use the @apply@ combinator to build the final value. --- | The @Parser@ datatype is a fairly generic parsing monad with error+-- | This @Parser@ datatype is a fairly generic parsing monad with error -- reporting. It can be used for arbitrary token types, not just--- String input. (If you require a running state, use module PolyStateLazy--- instead.)-newtype Parser t a = P ([t] -> (Either String a, [t]))+-- String input. (If you require a running state, use module PolyState+-- instead)+newtype Parser t a = P ([t] -> Result [t] a) --- | Apply a parser to an input token sequence. The parser cannot return--- an error value explicitly, so errors raise an exception. Thus, results--- can be partial (lazily constructed, but containing undefined).+-- | A return type like Either, that distinguishes not only between+-- right and wrong answers, but also has gradations of wrongness.+-- This should only be used for writing very primitive+-- parsers - really it is an internal detail of the library.+data Result z a = Success z a+ | Failure z String+ | Committed (Result z a) -- still needed++instance Functor (Result z) where+ fmap f (Success z a) = Success z (f a)+ fmap f (Failure z e) = Failure z e+ fmap f (Committed r) = Committed (fmap f r)++-- | Apply a parser to an input token sequence. runParser :: Parser t a -> [t] -> (a, [t])-runParser (P p) =- (\ (e,ts)-> (case e of {Left m->throwE m; Right x->x}, ts) )- . p+runParser (P p) = fromResult . p+ where+ fromResult :: Result z a -> (a, z)+ fromResult (Success z a) = (a, z)+ fromResult (Failure z e) = throwE e+ fromResult (Committed r) = fromResult r instance Functor (Parser t) where- fmap f (P p) = P (\ts-> case p ts of- (Left msg, ts') -> (Left msg, ts')- (Right x, ts') -> (Right (f x), ts'))-instance Monad (Parser t) where- return x = P (\ts-> (Right x, ts))- (P f) >>= g = P (\ts-> case f ts of- (Left msg, ts') -> (Left msg, ts')- (Right x, ts') -> let (P g') = g x in g' ts')- fail e = P (\ts-> (Left e, ts))+ fmap f (P p) = P (fmap f . p) +instance Monad (Parser t) where+ return x = P (\ts-> Success ts x)+ fail e = P (\ts-> Failure ts e)+ (P f) >>= g = P (continue . f)+ where+ continue (Success ts x) = let (P g') = g x in g' ts+ continue (Committed (Committed r)) = continue (Committed r)+ continue (Committed r) = Committed (continue r)+ continue (Failure ts e) = Failure ts e instance PolyParse (Parser t) where- commit (P p) = P (\ts-> case p ts of- (Left e, ts') -> (throwE e, ts')- right -> right )- (P p) `onFail` (P q) = P (\ts-> case p ts of- (Left _, _) -> q ts- right -> right )- (P p) `adjustErr` f = P (\ts-> case p ts of- (Left msg, ts') -> (Left (f msg), ts')- right -> right )- oneOf' ps = accum [] ps+ commit (P p) = P (Committed . p)+ (P p) `adjustErr` f = P (adjust . p)+ where+ adjust (Failure z e) = Failure z (f e)+ adjust (Committed r) = Committed (adjust r)+ adjust good = good++ (P p) `onFail` (P q) = P (\ts-> continue ts $ p ts)+ where+ continue ts (Failure z e) = q ts+ -- continue _ (Committed r) = r -- no, remain Committed+ continue _ r = r++ oneOf' = accum [] where accum errs [] =- case errs of- [] -> failBad ("internal failure in parser (oneOf'):\n"- ++indent 2 (show (map fst ps)))- [(_,e)] -> fail e- es -> fail ("one of the following failures occurred:\n"- ++indent 2 (concatMap showErr (reverse es)))+ fail ("failed to parse any of the possible choices:\n"+ ++indent 2 (concatMap showErr (reverse errs))) accum errs ((e,P p):ps) = P (\ts-> case p ts of- (Left err,_) -> let (P p) = accum ((e,err):errs) ps- in p ts- right -> right )+ Failure _ err ->+ let (P p) = accum ((e,err):errs) ps+ in p ts+ r@(Success z a) -> r+ r@(Committed _) -> r ) showErr (name,err) = name++":\n"++indent 2 err- -- This version of "apply"++ -- Apply a parsed function to a parsed value. This version -- is strict in the result of the function parser, but -- lazy in the result of the argument parser. (Argument laziness is -- the distinctive feature over other implementations.)- (P pf) `apply` (P px) = P (\ts->- case pf ts of- (Left msg, ts') -> (Left msg, ts')- (Right f, ts') -> let (x',ts'') = px ts'- x = case x' of { Right x -> x- ; Left e -> throwE e }- in (Right (f x), ts'') )+ (P pf) `apply` px = P (continue . pf)+ where+ continue (Success z f) = let (x,z') = runParser px z+ in Success z' (f x)+ continue (Committed r) = Committed (continue r)+ continue (Failure z e) = Failure z e --- | Next token++------------------------------------------------------------------------+next :: Parser t t next = P (\ts-> case ts of- [] -> (Left "Ran out of input (EOF)", [])- (t:ts') -> (Right t, ts') )+ [] -> Failure [] "Ran out of input (EOF)"+ (t:ts') -> Success ts' t ) --- | One token satifying a predicate satisfy :: (t->Bool) -> Parser t t-satisfy p = do{ x <- next- ; if p x then return x else fail "Parse.satisfy: failed"- }---- | 'manyFinally e t' parses a possibly-empty sequence of e's,--- terminated by a t. Any parse failures could be due either to--- a badly-formed terminator or a badly-formed element, so raise--- both possible errors.-manyFinally :: Parser t a -> Parser t z -> Parser t [a]-manyFinally pp@(P p) pt@(P t) = P (\ts ->- case p ts of- (Left e, _) ->- case t ts of- (Right _, ts') -> (Right [], ts')- (Left e, ts') -> (Left e, ts')- (Right x, ts') ->- let (tail,ts'') = runParser (manyFinally pp pt) ts'- in (Right (x:tail), ts'') )-+satisfy pred = do { x <- next+ ; if pred x then return x else fail "Parse.satisfy: failed"+ } ------------------------------------------------------------------------ -- | Push some tokens back onto the front of the input stream and reparse.@@ -131,6 +124,6 @@ -- expansion from the parse state, lex it, and then stuff the -- lexed expansion back down into the parser. reparse :: [t] -> Parser t ()-reparse ts = P (\inp-> (Right (), ts++inp))+reparse ts = P (\inp-> Success (ts++inp) ()) ------------------------------------------------------------------------
− src/Text/ParserCombinators/Poly/NoLeak/Lazy.hs
@@ -1,126 +0,0 @@-module Text.ParserCombinators.Poly.NoLeak.Lazy- ( -- * The Parser datatype- Parser(P) -- datatype, instance of: Functor, Monad, PolyParse- , runParser -- :: Parser t a -> [t] -> (Either String a, [t])- -- ** basic parsers- , next -- :: Parser t t- , satisfy -- :: (t->Bool) -> Parser t t-- -- ** re-parsing- , reparse -- :: [t] -> Parser t ()- -- * Re-export all more general combinators- , module Text.ParserCombinators.Poly.Base- ) where---import Text.ParserCombinators.Poly.Base--#if __GLASGOW_HASKELL__-import Control.Exception hiding (bracket)-throwE :: String -> a-throwE msg = throw (ErrorCall msg)-#else-throwE :: String -> a-throwE msg = error msg-#endif----- | This @Parser@ datatype is a fairly generic parsing monad with error--- reporting. It can be used for arbitrary token types, not just--- String input. (If you require a running state, use module PolyState--- instead)-newtype Parser t a = P ([t] -> Result [t] a)---- A return type like Either, that distinguishes not only between--- right and wrong answers, but also has gradations of wrongness.-data Result z a = Success z a- | Failure z String- | Committed (Result z a) -- still needed--instance Functor (Result z) where- fmap f (Success z a) = Success z (f a)- fmap f (Failure z e) = Failure z e- fmap f (Committed r) = Committed (fmap f r)---- | Apply a parser to an input token sequence.-runParser :: Parser t a -> [t] -> (a, [t])-runParser (P p) = fromResult . p- where- fromResult :: Result z a -> (a, z)- fromResult (Success z a) = (a, z)- fromResult (Failure z e) = throwE e- fromResult (Committed r) = fromResult r--instance Functor (Parser t) where- fmap f (P p) = P (fmap f . p)--instance Monad (Parser t) where- return x = P (\ts-> Success ts x)- fail e = P (\ts-> Failure ts e)- (P f) >>= g = P (continue . f)- where- continue (Success ts x) = let (P g') = g x in g' ts- continue (Committed (Committed r)) = continue (Committed r)- continue (Committed r) = Committed (continue r)- continue (Failure ts e) = Failure ts e--instance PolyParse (Parser t) where- commit (P p) = P (Committed . p)- (P p) `adjustErr` f = P (adjust . p)- where- adjust (Failure z e) = Failure z (f e)- adjust (Committed r) = Committed (adjust r)- adjust good = good-- (P p) `onFail` (P q) = P (\ts-> continue ts $ p ts)- where- continue ts (Failure z e) = q ts- -- continue _ (Committed r) = r -- no, remain Committed- continue _ r = r-- oneOf' = accum []- where accum errs [] =- fail ("failed to parse any of the possible choices:\n"- ++indent 2 (concatMap showErr (reverse errs)))- accum errs ((e,P p):ps) =- P (\ts-> case p ts of- Failure _ err ->- let (P p) = accum ((e,err):errs) ps- in p ts- r@(Success z a) -> r- r@(Committed _) -> r )- showErr (name,err) = name++":\n"++indent 2 err-- -- Apply a parsed function to a parsed value. This version- -- is strict in the result of the function parser, but- -- lazy in the result of the argument parser. (Argument laziness is- -- the distinctive feature over other implementations.)- (P pf) `apply` px = P (continue . pf)- where- continue (Success z f) = let (x,z') = runParser px z- in Success z' (f x)- continue (Committed r) = Committed (continue r)- continue (Failure z e) = Failure z e----------------------------------------------------------------------------next :: Parser t t-next = P (\ts-> case ts of- [] -> Failure [] "Ran out of input (EOF)"- (t:ts') -> Success ts' t )--satisfy :: (t->Bool) -> Parser t t-satisfy pred = do { x <- next- ; if pred x then return x else fail "Parse.satisfy: failed"- }----------------------------------------------------------------------------- | Push some tokens back onto the front of the input stream and reparse.--- This is useful e.g. for recursively expanding macros. When the--- user-parser recognises a macro use, it can lookup the macro--- expansion from the parse state, lex it, and then stuff the--- lexed expansion back down into the parser.-reparse :: [t] -> Parser t ()-reparse ts = P (\inp-> Success (ts++inp) ())--------------------------------------------------------------------------
− src/Text/ParserCombinators/Poly/NoLeak/Plain.hs
@@ -1,105 +0,0 @@-module Text.ParserCombinators.Poly.NoLeak.Plain- ( -- * The Parser datatype- Parser(P) -- datatype, instance of: Functor, Monad, PolyParse- , runParser -- :: Parser t a -> [t] -> (Either String a, [t])- -- ** basic parsers- , next -- :: Parser t t- , satisfy -- :: (t->Bool) -> Parser t t-- -- ** re-parsing- , reparse -- :: [t] -> Parser t ()- -- * Re-export all more general combinators- , module Text.ParserCombinators.Poly.Base- ) where---import Text.ParserCombinators.Poly.Base---- | This @Parser@ datatype is a fairly generic parsing monad with error--- reporting. It can be used for arbitrary token types, not just--- String input. (If you require a running state, use module PolyState--- instead)-newtype Parser t a = P ([t] -> Result [t] a)---- A return type like Either, that distinguishes not only between--- right and wrong answers, but also has commitment, so that a failure--- cannot be undone.-data Result z a = Success z a- | Failure z String- | Committed (Result z a)--instance Functor (Result z) where- fmap f (Success z a) = Success z (f a)- fmap f (Failure z e) = Failure z e- fmap f (Committed r) = Committed (fmap f r)---- | Apply a parser to an input token sequence.-runParser :: Parser t a -> [t] -> (Either String a, [t])-runParser (P p) = resultToEither . p- where- resultToEither :: Result z a -> (Either String a, z)- resultToEither (Success z a) = (Right a, z)- resultToEither (Failure z e) = (Left e, z)- resultToEither (Committed r) = resultToEither r--instance Functor (Parser t) where- fmap f (P p) = P (fmap f . p)--instance Monad (Parser t) where- return x = P (\ts-> Success ts x)- fail e = P (\ts-> Failure ts e)- (P f) >>= g = P (continue . f)- where- continue (Success ts x) = let (P g') = g x in g' ts- continue (Committed (Committed r)) = continue (Committed r)- continue (Committed r) = Committed (continue r)- continue (Failure ts e) = Failure ts e--instance PolyParse (Parser t) where- commit (P p) = P (Committed . p)- (P p) `adjustErr` f = P (adjust . p)- where- adjust (Failure z e) = Failure z (f e)- adjust (Committed r) = Committed (adjust r)- adjust good = good-- (P p) `onFail` (P q) = P (\ts-> continue ts $ p ts)- where- continue ts (Failure z e) = q ts- -- continue _ (Committed r) = r -- no, remain Committed- continue _ r = r-- oneOf' = accum []- where accum errs [] =- fail ("failed to parse any of the possible choices:\n"- ++indent 2 (concatMap showErr (reverse errs)))- accum errs ((e,P p):ps) =- P (\ts-> case p ts of- Failure _ err ->- let (P p) = accum ((e,err):errs) ps- in p ts- r@(Success z a) -> r- r@(Committed _) -> r )- showErr (name,err) = name++":\n"++indent 2 err---------------------------------------------------------------------------next :: Parser t t-next = P (\ts-> case ts of- [] -> Failure [] "Ran out of input (EOF)"- (t:ts') -> Success ts' t )--satisfy :: (t->Bool) -> Parser t t-satisfy pred = do { x <- next- ; if pred x then return x else fail "Parse.satisfy: failed"- }----------------------------------------------------------------------------- | Push some tokens back onto the front of the input stream and reparse.--- This is useful e.g. for recursively expanding macros. When the--- user-parser recognises a macro use, it can lookup the macro--- expansion from the parse state, lex it, and then stuff the--- lexed expansion back down into the parser.-reparse :: [t] -> Parser t ()-reparse ts = P (\inp-> Success (ts++inp) ())--------------------------------------------------------------------------
− src/Text/ParserCombinators/Poly/NoLeak/State.hs
@@ -1,122 +0,0 @@-module Text.ParserCombinators.Poly.NoLeak.State- ( -- * The Parser datatype- Parser(P) -- datatype, instance of: Functor, Monad, PolyParse- , runParser -- :: Parser s t a -> s -> [t] -> (Either String a, s, [t])- -- ** basic parsers- , next -- :: Parser s t t- , satisfy -- :: (t->Bool) -> Parser s t t- -- ** State-handling- , stUpdate -- :: (s->s) -> Parser s t ()- , stQuery -- :: (s->a) -> Parser s t a- , stGet -- :: Parser s t s- -- ** re-parsing- , reparse -- :: [t] -> Parser s t ()- -- * Re-export all more general combinators- , module Text.ParserCombinators.Poly.Base- ) where---import Text.ParserCombinators.Poly.Base---- | This @Parser@ datatype is a fairly generic parsing monad with error--- reporting. It can be used for arbitrary token types, not just--- String input. (If you require a running state, use module PolyState--- instead)-newtype Parser s t a = P (s -> [t] -> Result [t] s a)---- A return type like Either, that distinguishes not only between--- right and wrong answers, but also has gradations of wrongness.-data Result z s a = Success z s a- | Failure z s String- | Committed (Result z s a)--instance Functor (Result z s) where- fmap f (Success z s a) = Success z s (f a)- fmap f (Failure z s e) = Failure z s e- fmap f (Committed r) = Committed (fmap f r)---- | Apply a parser to an input token sequence.-runParser :: Parser s t a -> s -> [t] -> (Either String a, s, [t])-runParser (P p) = \s-> resultToEither . p s- where- resultToEither :: Result z s a -> (Either String a, s, z)- resultToEither (Success z s a) = (Right a, s, z)- resultToEither (Failure z s e) = (Left e, s, z)- resultToEither (Committed r) = resultToEither r--instance Functor (Parser s t) where- fmap f (P p) = P (\s-> fmap f . p s)--instance Monad (Parser s t) where- return x = P (\s ts-> Success ts s x)- fail e = P (\s ts-> Failure ts s e)- (P f) >>= g = P (\s-> continue . f s)- where- continue (Success ts s x) = let (P g') = g x in g' s ts- continue (Committed (Committed r)) = continue (Committed r)- continue (Committed r) = Committed (continue r)- continue (Failure ts s e) = Failure ts s e--instance PolyParse (Parser s t) where- commit (P p) = P (\s-> Committed . p s)- (P p) `adjustErr` f = P (\s-> adjust . p s)- where- adjust (Failure z s e) = Failure z s (f e)- adjust (Committed r) = Committed (adjust r)- adjust good = good-- (P p) `onFail` (P q) = P (\s ts-> continue s ts $ p s ts)- where- continue s ts (Failure _ _ _) = q s ts- -- continue _ _ (Committed r) = r -- no, remain Committed- continue _ _ r = r-- oneOf' = accum []- where accum errs [] =- fail ("failed to parse any of the possible choices:\n"- ++indent 2 (concatMap showErr (reverse errs)))- accum errs ((e,P p):ps) =- P (\s ts-> case p s ts of- Failure _ _ err ->- let (P p) = accum ((e,err):errs) ps- in p s ts- r@(Success z _ a) -> r- r@(Committed _) -> r )- showErr (name,err) = name++":\n"++indent 2 err---------------------------------------------------------------------------next :: Parser s t t-next = P (\s ts-> case ts of- [] -> Failure [] s "Ran out of input (EOF)"- (t:ts') -> Success ts' s t )--satisfy :: (t->Bool) -> Parser s t t-satisfy pred = do { x <- next- ; if pred x then return x else fail "Parse.satisfy: failed"- }---------------------------------------------------------------------------- State handling---- | Update the internal state.-stUpdate :: (s->s) -> Parser s t ()-stUpdate f = P (\s ts-> Success ts (f s) ())---- | Query the internal state.-stQuery :: (s->a) -> Parser s t a-stQuery f = P (\s ts-> Success ts s (f s))---- | Deliver the entire internal state.-stGet :: Parser s t s-stGet = P (\s ts-> Success ts s s)------------------------------------------------------------------------------ | Push some tokens back onto the front of the input stream and reparse.--- This is useful e.g. for recursively expanding macros. When the--- user-parser recognises a macro use, it can lookup the macro--- expansion from the parse state, lex it, and then stuff the--- lexed expansion back down into the parser.-reparse :: [t] -> Parser s t ()-reparse ts = P (\s inp-> Success (ts++inp) s ())--------------------------------------------------------------------------
− src/Text/ParserCombinators/Poly/NoLeak/StateLazy.hs
@@ -1,172 +0,0 @@-module Text.ParserCombinators.Poly.NoLeak.StateLazy- ( -- * The Parser datatype- Parser(P) -- datatype, instance of: Functor, Monad, PolyParse- , runParser -- :: Parser s t a -> s -> [t] -> (Either String a, s, [t])- -- ** basic parsers- , next -- :: Parser s t t- , satisfy -- :: (t->Bool) -> Parser s t t- , manyFinally -- :: Parser s t a -> Parser s t z -> Parser s t [a]- -- ** State-handling- , stUpdate -- :: (s->s) -> Parser s t ()- , stQuery -- :: (s->a) -> Parser s t a- , stGet -- :: Parser s t s- -- ** re-parsing- , reparse -- :: [t] -> Parser s t ()- -- * Re-export all more general combinators- , module Text.ParserCombinators.Poly.Base- ) where---import Text.ParserCombinators.Poly.Base hiding (manyFinally)--#if __GLASGOW_HASKELL__-import Control.Exception hiding (bracket)-throwE :: String -> a-throwE msg = throw (ErrorCall msg)-#else-throwE :: String -> a-throwE msg = error msg-#endif----- | This @Parser@ datatype is a fairly generic parsing monad with error--- reporting. It can be used for arbitrary token types, not just--- String input. (If you require a running state, use module PolyState--- instead)-newtype Parser s t a = P (s -> [t] -> Result [t] s a)---- A return type like Either, that distinguishes not only between--- right and wrong answers, but also has gradations of wrongness.-data Result z s a = Success z s a- | Failure z s String- | Committed (Result z s a)--instance Functor (Result z s) where- fmap f (Success z s a) = Success z s (f a)- fmap f (Failure z s e) = Failure z s e- fmap f (Committed r) = Committed (fmap f r)---- | Apply a parser to an input token sequence.-runParser :: Parser s t a -> s -> [t] -> (a, s, [t])-runParser (P p) = \s -> fromResult . p s- where- fromResult :: Result z s a -> (a, s, z)- fromResult (Success z s a) = (a, s, z)- fromResult (Failure z s e) = throwE e- fromResult (Committed r) = fromResult r--instance Functor (Parser s t) where- fmap f (P p) = P (\s -> fmap f . p s)--instance Monad (Parser s t) where- return x = P (\s ts-> Success ts s x)- fail e = P (\s ts-> Failure ts s e)- (P f) >>= g = P (\s-> continue . f s)- where- continue (Success ts s x) = let (P g') = g x in g' s ts- continue (Committed (Committed r)) = continue (Committed r)- continue (Committed r) = Committed (continue r)- continue (Failure ts s e) = Failure ts s e--instance PolyParse (Parser s t) where- commit (P p) = P (\s-> Committed . p s)- (P p) `adjustErr` f = P (\s-> adjust . p s)- where- adjust (Failure z s e) = Failure z s (f e)- adjust (Committed r) = Committed (adjust r)- adjust good = good-- (P p) `onFail` (P q) = P (\s ts-> continue s ts $ p s ts)- where- continue s ts (Failure _ _ _) = q s ts- -- continue _ _ (Committed r) = r -- no, remain Committed- continue _ _ r = r-- oneOf' = accum []- where accum errs [] =- fail ("failed to parse any of the possible choices:\n"- ++indent 2 (concatMap showErr (reverse errs)))- accum errs ((e,P p):ps) =- P (\s ts-> case p s ts of- Failure _ _ err ->- let (P p) = accum ((e,err):errs) ps- in p s ts- r@(Success z _ a) -> r- r@(Committed _) -> r )- showErr (name,err) = name++":\n"++indent 2 err-- -- Apply a parsed function to a parsed value. This version- -- is strict in the result of the function parser, but- -- lazy in the result of the argument parser. (Argument laziness is- -- the distinctive feature over other implementations.)- (P pf) `apply` px = P (\s-> continue . pf s)- where- continue (Success z s f) = let (x,s',z') = runParser px s z- in Success z' s' (f x)- continue (Failure z s e) = Failure z s e- continue (Committed r) = Committed (continue r)--manyFinally :: Parser s t a -> Parser s t z -> Parser s t [a]-{--manyFinally pp@(P p) pt@(P t) = P (\s ts -> item s ts (p s ts))- where- item _ _ (Success ts s x) = success ts s x- item s ts (Failure _ _ e) = terminate (t s ts)- item s ts (Committed r) = Committed (within r)-- success ts s x =- let (tail,s',ts') = runParser (manyFinally pp pt) s ts- in Success ts' s' (x:tail)-- terminate (Success ts s _) = Success ts s []- terminate (Failure ts s e) = Failure ts s e- terminate (Committed r) = Committed (terminate r)-- within (Success ts s x) = success ts s x- within (Failure ts s e) = Failure ts s e- within (Committed r) = within r--}--manyFinally p z =- (do x <- p; return (x:) `apply` manyFinally p z)- `onFail`- (do z; return [])- `onFail`- oneOf' [ ("item in sequence", (do p; return []))- , ("sequence terminator", (do z; return [])) ]---------------------------------------------------------------------------next :: Parser s t t-next = P (\s ts-> case ts of- [] -> Failure [] s "Ran out of input (EOF)"- (t:ts') -> Success ts' s t )--satisfy :: (t->Bool) -> Parser s t t-satisfy pred = do { x <- next- ; if pred x then return x else fail "Parse.satisfy: failed"- }---------------------------------------------------------------------------- State handling---- | Update the internal state.-stUpdate :: (s->s) -> Parser s t ()-stUpdate f = P (\s ts-> Success ts (f s) ())---- | Query the internal state.-stQuery :: (s->a) -> Parser s t a-stQuery f = P (\s ts-> Success ts s (f s))---- | Deliver the entire internal state.-stGet :: Parser s t s-stGet = P (\s ts-> Success ts s s)----------------------------------------------------------------------------- | Push some tokens back onto the front of the input stream and reparse.--- This is useful e.g. for recursively expanding macros. When the--- user-parser recognises a macro use, it can lookup the macro--- expansion from the parse state, lex it, and then stuff the--- lexed expansion back down into the parser.-reparse :: [t] -> Parser s t ()-reparse ts = P (\s inp-> Success (ts++inp) s ())--------------------------------------------------------------------------
src/Text/ParserCombinators/Poly/Plain.hs view
@@ -1,6 +1,7 @@ module Text.ParserCombinators.Poly.Plain ( -- * The Parser datatype Parser(P) -- datatype, instance of: Functor, Monad, PolyParse+ , Result(..) -- internal to the Parser Monad. , runParser -- :: Parser t a -> [t] -> (Either String a, [t]) -- ** basic parsers , next -- :: Parser t t@@ -19,61 +20,75 @@ -- reporting. It can be used for arbitrary token types, not just -- String input. (If you require a running state, use module PolyState -- instead)-newtype Parser t a = P ([t] -> (EitherE String a, [t]))+newtype Parser t a = P ([t] -> Result [t] a) --- A return type like Either, that distinguishes not only between--- right and wrong answers, but also has gradations of wrongness.-type EitherE a b = Either (Bool,a) b+-- | A return type like Either, that distinguishes not only between+-- right and wrong answers, but also has commitment, so that a failure+-- cannot be undone. This should only be used for writing very primitive+-- parsers - really it is an internal detail of the library.+data Result z a = Success z a+ | Failure z String+ | Committed (Result z a) +instance Functor (Result z) where+ fmap f (Success z a) = Success z (f a)+ fmap f (Failure z e) = Failure z e+ fmap f (Committed r) = Committed (fmap f r)+ -- | Apply a parser to an input token sequence. runParser :: Parser t a -> [t] -> (Either String a, [t])-runParser (P p) =- (\ (e,ts)-> (case e of {Left (_,m)->Left m; Right m->Right m}, ts) )- . p+runParser (P p) = resultToEither . p+ where+ resultToEither :: Result z a -> (Either String a, z)+ resultToEither (Success z a) = (Right a, z)+ resultToEither (Failure z e) = (Left e, z)+ resultToEither (Committed r) = resultToEither r instance Functor (Parser t) where- fmap f (P p) = P (\ts-> case p ts of- (Left msg, ts') -> (Left msg, ts')- (Right x, ts') -> (Right (f x), ts'))+ fmap f (P p) = P (fmap f . p)+ instance Monad (Parser t) where- return x = P (\ts-> (Right x, ts))- (P f) >>= g = P (\ts-> case f ts of- (Left msg, ts') -> (Left msg, ts')- (Right x, ts') -> let (P g') = g x in g' ts')- fail e = P (\ts-> (Left (False,e), ts))+ return x = P (\ts-> Success ts x)+ fail e = P (\ts-> Failure ts e)+ (P f) >>= g = P (continue . f)+ where+ continue (Success ts x) = let (P g') = g x in g' ts+ continue (Committed (Committed r)) = continue (Committed r)+ continue (Committed r) = Committed (continue r)+ continue (Failure ts e) = Failure ts e instance PolyParse (Parser t) where- commit (P p) = P (\ts-> case p ts of- (Left (_,e), ts') -> (Left (True,e), ts')- right -> right )- (P p) `adjustErr` f = P (\ts-> case p ts of- (Left (b,msg), ts') -> (Left (b,(f msg)), ts')- right -> right )- (P p) `onFail` (P q) = P (\ts-> case p ts of- r@(Left (True,_), _) -> r- (Left _, _) -> q ts- right -> right )+ commit (P p) = P (Committed . p)+ (P p) `adjustErr` f = P (adjust . p)+ where+ adjust (Failure z e) = Failure z (f e)+ adjust (Committed r) = Committed (adjust r)+ adjust good = good++ (P p) `onFail` (P q) = P (\ts-> continue ts $ p ts)+ where+ continue ts (Failure z e) = q ts+ -- continue _ (Committed r) = r -- no, remain Committed+ continue _ r = r+ oneOf' = accum [] where accum errs [] =- case filter isBad errs of- [] -> fail ("failed to parse any of the possible choices:\n"+ fail ("failed to parse any of the possible choices:\n" ++indent 2 (concatMap showErr (reverse errs)))- [(_,(_,e))] -> failBad e- es -> failBad ("one of the following failures occurred:\n"- ++indent 2 (concatMap showErr (reverse es))) accum errs ((e,P p):ps) = P (\ts-> case p ts of- (Left err,_) -> let (P p) = accum ((e,err):errs) ps- in p ts- right -> right )- showErr (name,(_,err)) = name++":\n"++indent 2 err- isBad (_,(b,_)) = b+ Failure _ err ->+ let (P p) = accum ((e,err):errs) ps+ in p ts+ r@(Success z a) -> r+ r@(Committed _) -> r )+ showErr (name,err) = name++":\n"++indent 2 err ------------------------------------------------------------------------ next :: Parser t t next = P (\ts-> case ts of- [] -> (Left (False,"Ran out of input (EOF)"), [])- (t:ts') -> (Right t, ts') )+ [] -> Failure [] "Ran out of input (EOF)"+ (t:ts') -> Success ts' t ) satisfy :: (t->Bool) -> Parser t t satisfy pred = do { x <- next@@ -87,6 +102,6 @@ -- expansion from the parse state, lex it, and then stuff the -- lexed expansion back down into the parser. reparse :: [t] -> Parser t ()-reparse ts = P (\inp-> (Right (), ts++inp))+reparse ts = P (\inp-> Success (ts++inp) ()) ------------------------------------------------------------------------
src/Text/ParserCombinators/Poly/State.hs view
@@ -1,102 +1,118 @@ module Text.ParserCombinators.Poly.State ( -- * The Parser datatype- Parser(P) -- datatype, instance of: Functor, Monad+ Parser(P) -- datatype, instance of: Functor, Monad, PolyParse+ , Result(..) -- internal to the parser monad , runParser -- :: Parser s t a -> s -> [t] -> (Either String a, s, [t]) -- ** basic parsers , next -- :: Parser s t t , satisfy -- :: (t->Bool) -> Parser s t t -- ** State-handling- , stUpdate -- :: (s->s) -> Parser s t ()- , stQuery -- :: (s->a) -> Parser s t a- , stGet -- :: Parser s t s- -- ** Re-parsing+ , stUpdate -- :: (s->s) -> Parser s t ()+ , stQuery -- :: (s->a) -> Parser s t a+ , stGet -- :: Parser s t s+ -- ** re-parsing , reparse -- :: [t] -> Parser s t ()- -- * Re-export all more general combinators.+ -- * Re-export all more general combinators , module Text.ParserCombinators.Poly.Base ) where + import Text.ParserCombinators.Poly.Base --- | The @Parser@ datatype is a fairly generic parsing monad with error--- reporting and a running state. It can be used for arbitrary token--- types, not just String input.-newtype Parser s t a = P (s -> [t] -> (EitherE String a, s, [t]))+-- | This @Parser@ datatype is a fairly generic parsing monad with error+-- reporting. It can be used for arbitrary token types, not just+-- String input. (If you require a running state, use module PolyState+-- instead)+newtype Parser s t a = P (s -> [t] -> Result [t] s a) -- | A return type like Either, that distinguishes not only between--- right and wrong answers, but also had gradations of wrongness.-type EitherE a b = Either (Bool,a) b+-- right and wrong answers, but also has gradations of wrongness.+-- This should only be used for writing very primitive+-- parsers - really it is an internal detail of the library.+data Result z s a = Success z s a+ | Failure z s String+ | Committed (Result z s a) --- | Apply a parser to an initial state and input token sequence.+instance Functor (Result z s) where+ fmap f (Success z s a) = Success z s (f a)+ fmap f (Failure z s e) = Failure z s e+ fmap f (Committed r) = Committed (fmap f r)++-- | Apply a parser to an input token sequence. runParser :: Parser s t a -> s -> [t] -> (Either String a, s, [t])-runParser (P p) s =- (\ (e,s,ts)-> (case e of Left (_,m)->Left m; Right m->Right m- ,s,ts))- . p s+runParser (P p) = \s-> resultToEither . p s+ where+ resultToEither :: Result z s a -> (Either String a, s, z)+ resultToEither (Success z s a) = (Right a, s, z)+ resultToEither (Failure z s e) = (Left e, s, z)+ resultToEither (Committed r) = resultToEither r instance Functor (Parser s t) where- fmap f (P p) = P (\s ts-> case p s ts of- (Left msg, s', ts') -> (Left msg, s', ts')- (Right x, s', ts') -> (Right (f x), s', ts'))+ fmap f (P p) = P (\s-> fmap f . p s)+ instance Monad (Parser s t) where- return x = P (\s ts-> (Right x, s, ts))- (P f) >>= g = P (\s ts-> case f s ts of- (Left msg, s', ts') -> (Left msg, s', ts')- (Right x, s', ts') -> let (P g') = g x- in g' s' ts')- fail msg = P (\s ts-> (Left (False,msg), s, ts))+ return x = P (\s ts-> Success ts s x)+ fail e = P (\s ts-> Failure ts s e)+ (P f) >>= g = P (\s-> continue . f s)+ where+ continue (Success ts s x) = let (P g') = g x in g' s ts+ continue (Committed (Committed r)) = continue (Committed r)+ continue (Committed r) = Committed (continue r)+ continue (Failure ts s e) = Failure ts s e instance PolyParse (Parser s t) where- commit (P p) = P (\s ts-> case p s ts of- (Left (_,e), s', ts') -> (Left (True,e), s', ts')- right -> right )- (P p) `onFail` (P q) = P (\s ts-> case p s ts of- r@(Left (True,_), _, _) -> r- (Left _, _, _) -> q s ts- right -> right )- (P p) `adjustErr` f = P (\s ts-> case p s ts of- (Left (b,msg), s', ts')- -> (Left (b,(f msg)), s, ts')- right -> right )+ commit (P p) = P (\s-> Committed . p s)+ (P p) `adjustErr` f = P (\s-> adjust . p s)+ where+ adjust (Failure z s e) = Failure z s (f e)+ adjust (Committed r) = Committed (adjust r)+ adjust good = good++ (P p) `onFail` (P q) = P (\s ts-> continue s ts $ p s ts)+ where+ continue s ts (Failure _ _ _) = q s ts+ -- continue _ _ (Committed r) = r -- no, remain Committed+ continue _ _ r = r+ oneOf' = accum [] where accum errs [] =- case filter isBad errs of- [] -> fail ("failed to parse any of the possible choices:\n"- ++indent 2 (concatMap showErr (reverse errs)))- [(_,(_,e))] -> failBad e- es -> failBad ("one of the following failures occurred:\n"- ++indent 2 (concatMap showErr (reverse es)))+ fail ("failed to parse any of the possible choices:\n"+ ++indent 2 (concatMap showErr (reverse errs))) accum errs ((e,P p):ps) =- P (\u ts-> case p u ts of- (Left err,_,_) -> let (P p) = accum ((e,err):errs) ps- in p u ts- right -> right )- showErr (name,(_,err)) = name++":\n"++indent 2 err- isBad (_,(b,_)) = b+ P (\s ts-> case p s ts of+ Failure _ _ err ->+ let (P p) = accum ((e,err):errs) ps+ in p s ts+ r@(Success z _ a) -> r+ r@(Committed _) -> r )+ showErr (name,err) = name++":\n"++indent 2 err ------------------------------------------------------------------------+next :: Parser s t t next = P (\s ts-> case ts of- [] -> (Left (False,"Ran out of input (EOF)"), s, [])- (t:ts') -> (Right t, s, ts') )+ [] -> Failure [] s "Ran out of input (EOF)"+ (t:ts') -> Success ts' s t ) satisfy :: (t->Bool) -> Parser s t t-satisfy p = do{ x <- next- ; if p x then return x else fail "Parse.satisfy: failed"- }+satisfy pred = do { x <- next+ ; if pred x then return x else fail "Parse.satisfy: failed"+ } ------------------------------------------------------------------------ -- State handling -- | Update the internal state. stUpdate :: (s->s) -> Parser s t ()-stUpdate f = P (\s ts-> (Right (), f s, ts))+stUpdate f = P (\s ts-> Success ts (f s) ()) -- | Query the internal state. stQuery :: (s->a) -> Parser s t a-stQuery f = P (\s ts-> (Right (f s), s, ts))+stQuery f = P (\s ts-> Success ts s (f s)) -- | Deliver the entire internal state. stGet :: Parser s t s-stGet = P (\s ts-> (Right s, s, ts))+stGet = P (\s ts-> Success ts s s) + ------------------------------------------------------------------------ -- | Push some tokens back onto the front of the input stream and reparse. -- This is useful e.g. for recursively expanding macros. When the@@ -104,6 +120,6 @@ -- expansion from the parse state, lex it, and then stuff the -- lexed expansion back down into the parser. reparse :: [t] -> Parser s t ()-reparse ts = P (\s inp-> (Right (), s, ts++inp))+reparse ts = P (\s inp-> Success (ts++inp) s ()) ------------------------------------------------------------------------
src/Text/ParserCombinators/Poly/StateLazy.hs view
@@ -1,24 +1,25 @@ module Text.ParserCombinators.Poly.StateLazy- ( -- * The Parser datatype.- -- $parser- Parser(P) -- datatype, instance of: Functor, Monad- , runParser -- :: Parser s t a -> s -> [t] -> (a, s, [t])- -- * Combinators:- -- ** Primitives+ ( -- * The Parser datatype+ Parser(P) -- datatype, instance of: Functor, Monad, PolyParse+ , Result(..) -- internal to the parser monad+ , runParser -- :: Parser s t a -> s -> [t] -> (Either String a, s, [t])+ -- ** basic parsers , next -- :: Parser s t t , satisfy -- :: (t->Bool) -> Parser s t t+ , manyFinally -- :: Parser s t a -> Parser s t z -> Parser s t [a] -- ** State-handling- , stUpdate -- :: (s->s) -> Parser s t ()- , stQuery -- :: (s->a) -> Parser s t a- , stGet -- :: Parser s t s- -- ** Re-parsing+ , stUpdate -- :: (s->s) -> Parser s t ()+ , stQuery -- :: (s->a) -> Parser s t a+ , stGet -- :: Parser s t s+ -- ** re-parsing , reparse -- :: [t] -> Parser s t () -- * Re-export all more general combinators , module Text.ParserCombinators.Poly.Base ) where -import Text.ParserCombinators.Poly.Base +import Text.ParserCombinators.Poly.Base hiding (manyFinally)+ #if __GLASGOW_HASKELL__ import Control.Exception hiding (bracket) throwE :: String -> a@@ -28,105 +29,139 @@ throwE msg = error msg #endif --- $parser--- Parsers do not return explicit failure. An exception is raised--- instead. This allows partial results to be returned before a--- full parse is complete. --- | The @Parser@ datatype is a fairly generic parsing monad with error--- reporting and a running state. It can be used for arbitrary token--- types, not just String input.-newtype Parser s t a = P (s -> [t] -> (Either String a, s, [t]))+-- | This @Parser@ datatype is a fairly generic parsing monad with error+-- reporting. It can be used for arbitrary token types, not just+-- String input. (If you require a running state, use module PolyState+-- instead)+newtype Parser s t a = P (s -> [t] -> Result [t] s a) -- | A return type like Either, that distinguishes not only between--- right and wrong answers, but also had gradations of wrongness.--- Not used in this library. !!!!!!!!!!!!!!!!!!!!!!!!!!-type EitherE a b = Either (Bool,a) b+-- right and wrong answers, but also has gradations of wrongness.+-- This should only be used for writing very primitive+-- parsers - really it is an internal detail of the library.+data Result z s a = Success z s a+ | Failure z s String+ | Committed (Result z s a) --- | Apply a parser to an initial state and input token sequence.--- The parser cannot return an error value explicitly, so errors--- raise an exception. Thus, results can be partial (lazily constructed,--- but containing undefined).+instance Functor (Result z s) where+ fmap f (Success z s a) = Success z s (f a)+ fmap f (Failure z s e) = Failure z s e+ fmap f (Committed r) = Committed (fmap f r)++-- | Apply a parser to an input token sequence. runParser :: Parser s t a -> s -> [t] -> (a, s, [t])-runParser (P p) s =- (\ (e,s,ts)-> (case e of {Left m->throwE m; Right x->x}, s, ts))- . p s+runParser (P p) = \s -> fromResult . p s+ where+ fromResult :: Result z s a -> (a, s, z)+ fromResult (Success z s a) = (a, s, z)+ fromResult (Failure z s e) = throwE e+ fromResult (Committed r) = fromResult r instance Functor (Parser s t) where- fmap f (P p) = P (\s ts-> case p s ts of- (Left msg, s', ts') -> (Left msg, s', ts')- (Right x, s', ts') -> (Right (f x), s', ts'))+ fmap f (P p) = P (\s -> fmap f . p s)+ instance Monad (Parser s t) where- return x = P (\s ts-> (Right x, s, ts))- (P f) >>= g = P (\s ts-> case f s ts of- (Left msg, s', ts') -> (Left msg, s', ts')- (Right x, s', ts') -> let (P g') = g x- in g' s' ts')- fail msg = P (\s ts-> (Left msg, s, ts))+ return x = P (\s ts-> Success ts s x)+ fail e = P (\s ts-> Failure ts s e)+ (P f) >>= g = P (\s-> continue . f s)+ where+ continue (Success ts s x) = let (P g') = g x in g' s ts+ continue (Committed (Committed r)) = continue (Committed r)+ continue (Committed r) = Committed (continue r)+ continue (Failure ts s e) = Failure ts s e instance PolyParse (Parser s t) where- commit (P p) = P (\s ts-> case p s ts of- (Left e, s', ts') -> (throwE e, s', ts')- right -> right )- (P p) `adjustErr` f =- P (\s ts-> case p s ts of- (Left msg, s', ts') -> (Left (f msg), s, ts')- right -> right )- (P p) `onFail` (P q) = P (\s ts-> case p s ts of- (Left _, _, _) -> q s ts- right -> right )- oneOf' ps = accum [] ps+ commit (P p) = P (\s-> Committed . p s)+ (P p) `adjustErr` f = P (\s-> adjust . p s)+ where+ adjust (Failure z s e) = Failure z s (f e)+ adjust (Committed r) = Committed (adjust r)+ adjust good = good++ (P p) `onFail` (P q) = P (\s ts-> continue s ts $ p s ts)+ where+ continue s ts (Failure _ _ _) = q s ts+ -- continue _ _ (Committed r) = r -- no, remain Committed+ continue _ _ r = r++ oneOf' = accum [] where accum errs [] =- case errs of- [] -> failBad ("internal failure in parser (oneOf'):\n"- ++indent 2 (show (map fst ps)))- [(_,e)] -> fail e- es -> fail ("one of the following failures occurred:\n"- ++indent 2 (concatMap showErr (reverse es)))+ fail ("failed to parse any of the possible choices:\n"+ ++indent 2 (concatMap showErr (reverse errs))) accum errs ((e,P p):ps) =- P (\u ts-> case p u ts of- (Left err,_,_) -> let (P p) = accum ((e,err):errs) ps- in p u ts- right -> right )+ P (\s ts-> case p s ts of+ Failure _ _ err ->+ let (P p) = accum ((e,err):errs) ps+ in p s ts+ r@(Success z _ a) -> r+ r@(Committed _) -> r ) showErr (name,err) = name++":\n"++indent 2 err- (P pf) `apply` (P px) = P (\s ts->- case pf s ts of- (Left msg, s', ts') -> (Left msg, s', ts')- (Right f, s', ts') -> let (x',s'',ts'') = px s' ts'- x = case x' of { Right x -> x- ; Left e -> throwE e }- in (Right (f x), s'', ts'') ) + -- Apply a parsed function to a parsed value. This version+ -- is strict in the result of the function parser, but+ -- lazy in the result of the argument parser. (Argument laziness is+ -- the distinctive feature over other implementations.)+ (P pf) `apply` px = P (\s-> continue . pf s)+ where+ continue (Success z s f) = let (x,s',z') = runParser px s z+ in Success z' s' (f x)+ continue (Failure z s e) = Failure z s e+ continue (Committed r) = Committed (continue r) --- Combinators+manyFinally :: Parser s t a -> Parser s t z -> Parser s t [a]+{-+manyFinally pp@(P p) pt@(P t) = P (\s ts -> item s ts (p s ts))+ where+ item _ _ (Success ts s x) = success ts s x+ item s ts (Failure _ _ e) = terminate (t s ts)+ item s ts (Committed r) = Committed (within r) --- | Yield one token.+ success ts s x =+ let (tail,s',ts') = runParser (manyFinally pp pt) s ts+ in Success ts' s' (x:tail)++ terminate (Success ts s _) = Success ts s []+ terminate (Failure ts s e) = Failure ts s e+ terminate (Committed r) = Committed (terminate r)++ within (Success ts s x) = success ts s x+ within (Failure ts s e) = Failure ts s e+ within (Committed r) = within r+-}++manyFinally p z =+ (do x <- p; return (x:) `apply` manyFinally p z)+ `onFail`+ (do z; return [])+ `onFail`+ oneOf' [ ("item in sequence", (do p; return []))+ , ("sequence terminator", (do z; return [])) ]++------------------------------------------------------------------------ next :: Parser s t t next = P (\s ts-> case ts of- [] -> (Left "Ran out of input (EOF)", s, [])- (t:ts') -> (Right t, s, ts') )+ [] -> Failure [] s "Ran out of input (EOF)"+ (t:ts') -> Success ts' s t ) --- | Yield one token if it satisfies a predicate. satisfy :: (t->Bool) -> Parser s t t-satisfy p = do{ x <- next- ; if p x then return x else fail "Parse.satisfy: failed"- }--+satisfy pred = do { x <- next+ ; if pred x then return x else fail "Parse.satisfy: failed"+ } ------------------------------------------------------------------------ -- State handling -- | Update the internal state. stUpdate :: (s->s) -> Parser s t ()-stUpdate f = P (\s ts-> (Right (), f s, ts))+stUpdate f = P (\s ts-> Success ts (f s) ()) -- | Query the internal state. stQuery :: (s->a) -> Parser s t a-stQuery f = P (\s ts-> (Right (f s), s, ts))+stQuery f = P (\s ts-> Success ts s (f s)) -- | Deliver the entire internal state. stGet :: Parser s t s-stGet = P (\s ts-> (Right s, s, ts))+stGet = P (\s ts-> Success ts s s) ------------------------------------------------------------------------ -- | Push some tokens back onto the front of the input stream and reparse.@@ -135,6 +170,6 @@ -- expansion from the parse state, lex it, and then stuff the -- lexed expansion back down into the parser. reparse :: [t] -> Parser s t ()-reparse ts = P (\s inp-> (Right (), s, ts++inp))+reparse ts = P (\s inp-> Success (ts++inp) s ()) ------------------------------------------------------------------------
− src/Text/ParserCombinators/PolyLazy.hs
@@ -1,275 +0,0 @@-module Text.ParserCombinators.PolyLazy- ( -- * The Parser datatype.- -- $parser- Parser(P) -- datatype, instance of: Functor, Monad- , runParser -- :: Parser t a -> [t] -> (a, [t])- , failBad -- :: String -> Parser t a- , commit -- :: Parser t a -> Parser t a- -- * Combinators:- -- ** Primitives- , next -- :: Parser t t- , satisfy -- :: (t->Bool) -> Parser t t- , apply -- :: Parser t (a->b) -> Parser t a -> Parser t b- , discard -- :: Parser t a -> Parser t b -> Parser t a- -- ** Error-handling- , adjustErr -- :: Parser t a -> (String->String) -> Parser t a- , adjustErrBad-- :: Parser t a -> (String->String) -> Parser t a- , indent -- :: Int -> String -> String- -- ** Choices- , onFail -- :: Parser t a -> Parser t a -> Parser t a- , oneOf -- :: Show t => [Parser t a] -> Parser t a- , oneOf' -- :: [(String,Parser t a)] -> Parser t a- , optional -- :: Parser t a -> Parser t (Maybe a)- -- ** Sequences- , exactly -- :: Int -> Parser t a -> Parser t [a]- , many -- :: Parser t a -> Parser t [a]- , many1 -- :: Parser t a -> Parser t [a]- , sepBy -- :: Parser t a -> Parser t sep -> Parser t [a]- , sepBy1 -- :: Parser t a -> Parser t sep -> Parser t [a]- , bracketSep -- :: Parser t bra -> Parser t sep -> Parser t ket- -- -> Parser t a -> Parser t [a]- , bracket -- :: Parser t bra -> Parser t ket -> Parser t a- -- -> Parser t a- , manyFinally -- :: Parser t a -> Parser t z -> Parser t [a]- -- ** Re-parsing- , reparse -- :: [t] -> Parser t ()- ) where--#if __GLASGOW_HASKELL__-import Control.Exception hiding (bracket)-throwE :: String -> a-throwE msg = throw (ErrorCall msg)-#else-throwE :: String -> a-throwE msg = error msg-#endif---- $parser--- When applied, these parsers do not return explicit failure.--- An exception is--- raised instead. This allows partial results to be returned--- before a full parse is complete.--- One of the key ways to ensure that your parser is properly lazy,--- is to parse the initial portion of text returning a function, then--- use the @apply@ combinator to build the final value.---- | The @Parser@ datatype is a fairly generic parsing monad with error--- reporting. It can be used for arbitrary token types, not just--- String input. (If you require a running state, use module PolyStateLazy--- instead.)-newtype Parser t a = P ([t] -> (Either String a, [t]))---- A return type like Either, that distinguishes not only between--- right and wrong answers, but also had gradations of wrongness.--- Not used in this library. !!!!!!!!!!!!!!!!!!!!!!!!!!!-type EitherE a b = Either (Bool,a) b---- | Apply a parser to an input token sequence. The parser cannot return--- an error value explicitly, so errors raise an exception. Thus, results--- can be partial (lazily constructed, but containing undefined).-runParser :: Parser t a -> [t] -> (a, [t])-runParser (P p) =- (\ (e,ts)-> (case e of {Left m->throwE m; Right x->x}, ts) )- . p--instance Functor (Parser t) where- fmap f (P p) = P (\ts-> case p ts of- (Left msg, ts') -> (Left msg, ts')- (Right x, ts') -> (Right (f x), ts'))-instance Monad (Parser t) where- return x = P (\ts-> (Right x, ts))- (P f) >>= g = P (\ts-> case f ts of- (Left msg, ts') -> (Left msg, ts')- (Right x, ts') -> let (P g') = g x in g' ts')- fail e = P (\ts-> (Left e, ts))---- | Simple failure can be corrected, but when a simple fail is not strong--- enough, use failBad for emphasis. It guarantees parsing will--- terminate with an exception.--failBad :: String -> Parser t a-failBad msg = P (\ts-> (throwE msg, ts))---- | Commit is a way of raising the severity of any errors found within--- its argument. Used in the middle of a parser definition, it means that--- any operations prior to commitment fail softly, but after commitment,--- they fail hard.-commit :: Parser t a -> Parser t a-commit (P p) = P (\ts-> case p ts of- (Left e, ts') -> (throwE e, ts')- right -> right )----- Combinators---- | One token-next :: Parser t t-next = P (\ts-> case ts of- [] -> (Left "Ran out of input (EOF)", [])- (t:ts') -> (Right t, ts') )---- | One token satifying a predicate-satisfy :: (t->Bool) -> Parser t t-satisfy p = do{ x <- next- ; if p x then return x else fail "Parse.satisfy: failed"- }--infixl 3 `apply`--- | Apply a parsed function to a parsed value-apply :: Parser t (a->b) -> Parser t a -> Parser t b---pf `apply` px = do { f <- pf; x <- px; return (f x) }--- Needs to be lazier! Must not force the argument value too early. -(P pf) `apply` (P px) = P (\ts->- case pf ts of- (Left msg, ts') -> (Left msg, ts')- (Right f, ts') -> let (x',ts'') = px ts'- x = case x' of { Right x -> x; Left e -> throwE e }- in (Right (f x), ts'') )--infixl 3 `discard`--- | @x `discard` y@ parses both x and y, but discards the result of y-discard :: Parser t a -> Parser t b -> Parser t a---px `discard` py = do { x <- px; _ <- py; return x }--- Needs to be lazier! Do not force the discarded portion too early.-px `discard` py = do { x <- px; return (\_-> x) `apply` py }---- | @p `adjustErr` f@ applies the transformation @f@ to any error message--- generated in @p@, having no effect if @p@ succeeds.-adjustErr :: Parser t a -> (String->String) -> Parser t a-(P p) `adjustErr` f = P (\ts-> case p ts of- (Left msg, ts') -> (Left (f msg), ts')- right -> right )---- | @adjustErrBad@ is just like @adjustErr@ except it also raises the--- severity of the error.-adjustErrBad :: Parser t a -> (String->String) -> Parser t a-p `adjustErrBad` f = commit (p `adjustErr` f)--infixl 6 `onFail` -- not sure about precedence 6?--- | @p `onFail` q@ means parse p unless p fails in which case parse q instead.--- Can be chained together to give multiple attempts to parse something.--- (Note that q could itself be a failing parser, e.g. to change the error--- message from that defined in p to something different.)--- However, a *severe* failure in p cannot be ignored.-onFail :: Parser t a -> Parser t a -> Parser t a-(P p) `onFail` (P q) = P (\ts-> case p ts of- (Left _, _) -> q ts- right -> right )---- | Parse the first alternative in the list that succeeds.-oneOf :: [Parser t a] -> Parser t a-oneOf [] = do { n <- next- ; fail ("failed to parse any of the possible choices")- }---oneOf :: Show t => [Parser t a] -> Parser t a---oneOf [] = do { n <- next--- ; fail ("failed to parse any of the possible choices"--- ++"\n next token is "++show n)--- }-oneOf (p:ps) = p `onFail` oneOf ps---- | Parse the first alternative that succeeds, but if none succeed,--- report only the severe errors, and if none of those, then report--- all the soft errors.-oneOf' :: [(String, Parser t a)] -> Parser t a-oneOf' ps = accum [] ps- where accum errs [] =- case errs of- [] -> failBad ("internal failure in parser (oneOf'):\n"- ++indent 2 (show (map fst ps)))- [(_,e)] -> fail e- es -> fail ("one of the following failures occurred:\n"- ++indent 2 (concatMap showErr (reverse es)))- accum errs ((e,P p):ps) =- P (\ts-> case p ts of- (Left err,_) -> let (P p) = accum ((e,err):errs) ps- in p ts- right -> right )- showErr (name,err) = name++":\n"++indent 2 err---- | Helper for formatting error messages: indents all lines by a fixed amount.-indent :: Int -> String -> String-indent n = unlines . map (replicate n ' ' ++) . lines---- | 'optional' indicates whether the parser succeeded through the Maybe type.-optional :: Parser t a -> Parser t (Maybe a)-optional p = fmap Just p `onFail` return Nothing---- | 'exactly n p' parses a precise number of items, n, using the parser--- p, in sequence.-exactly :: Int -> Parser t a -> Parser t [a]-exactly 0 p = return []-exactly n p = return (:) `apply` p `apply` exactly (n-1) p---- | 'many p' parses a list of elements with individual parser p.--- Cannot fail, since an empty list is a valid return value.-many :: Parser t a -> Parser t [a]-many p = many1 p `onFail` return []- where many1 p = do { x <- p- ; return (x:) `apply` many p- }---- | Parse a non-empty list of items.-many1 :: Parser t a -> Parser t [a]-many1 p = do { x <- p `adjustErr` (("In a sequence:\n"++). indent 2)- ; return (x:) `apply` many p- }--- `adjustErr` ("When looking for a non-empty sequence:\n\t"++)---- | Parse a list of items separated by discarded junk.-sepBy :: Parser t a -> Parser t sep -> Parser t [a]-sepBy p sep = do sepBy1 p sep `onFail` return []---- | Parse a non-empty list of items separated by discarded junk.-sepBy1 :: Parser t a -> Parser t sep -> Parser t [a]-sepBy1 p sep = do { x <- p- ; return (x:) `apply` many (do {sep; p})- }- `adjustErr` ("When looking for a non-empty sequence with separators:\n\t"++)- --- | Parse a list of items, discarding the start, end, and separator--- items.-bracketSep :: Parser t bra -> Parser t sep -> Parser t ket- -> Parser t a -> Parser t [a]-bracketSep open sep close p =- do { open; close; return [] }- `onFail`- do { open `adjustErr` ("Missing opening bracket:\n\t"++)- ; x <- p `adjustErr` ("After first bracket in a group:\n\t"++)- ; return (x:) `apply`- manyFinally (do {sep; p})- (close `adjustErrBad` ("When looking for closing bracket:\n\t"++))- }---- | Parse a bracketed item, discarding the brackets.-bracket :: Parser t bra -> Parser t ket -> Parser t a -> Parser t a-bracket open close p = do- do { open `adjustErr` ("Missing opening bracket:\n\t"++)- ; p `discard` (close `adjustErrBad` ("Missing closing bracket:\n\t"++))- }---- | 'manyFinally e t' parses a possibly-empty sequence of e's,--- terminated by a t. Any parse failures could be due either to--- a badly-formed terminator or a badly-formed element, so raise--- both possible errors.-manyFinally :: Parser t a -> Parser t z -> Parser t [a]-manyFinally pp@(P p) pt@(P t) = P (\ts ->- case p ts of- (Left e, _) ->- case t ts of- (Right _, ts') -> (Right [], ts')- (Left e, ts') -> (Left e, ts')- (Right x, ts') ->- let (tail,ts'') = runParser (manyFinally pp pt) ts'- in (Right (x:tail), ts'') )----------------------------------------------------------------------------- | Push some tokens back onto the front of the input stream and reparse.--- This is useful e.g. for recursively expanding macros. When the--- user-parser recognises a macro use, it can lookup the macro--- expansion from the parse state, lex it, and then stuff the--- lexed expansion back down into the parser.-reparse :: [t] -> Parser t ()-reparse ts = P (\inp-> (Right (), ts++inp))--------------------------------------------------------------------------
− src/Text/ParserCombinators/PolyState.hs
@@ -1,257 +0,0 @@-module Text.ParserCombinators.PolyState- ( -- * The Parser datatype- Parser(P) -- datatype, instance of: Functor, Monad- , runParser -- :: Parser s t a -> s -> [t] -> (Either String a, s, [t])- , failBad -- :: String -> Parser s t a- , commit -- :: Parser s t a -> Parser s t a- -- * Combinators:- -- ** Primitives- , next -- :: Parser s t t- , satisfy -- :: (t->Bool) -> Parser s t t- , apply -- :: Parser t (a->b) -> Parser s t a -> Parser s t b- , discard -- :: Parser s t a -> Parser s t b -> Parser s t a- -- ** Error-handling- , adjustErr -- :: Parser s t a -> (String->String) -> Parser s t a- , adjustErrBad-- :: Parser s t a -> (String->String) -> Parser s t a- , indent -- :: Int -> String -> String- -- ** Choices- , onFail -- :: Parser s t a -> Parser s t a -> Parser s t a- , oneOf -- :: [Parser s t a] -> Parser s t a- , oneOf' -- :: [(String, Parser s t a)] -> Parser s t a- -- ** Sequences- , exactly -- :: Int -> Parser s t a -> Parser s t [a]- , many -- :: Parser s t a -> Parser s t [a]- , many1 -- :: Parser s t a -> Parser s t [a]- , sepBy -- :: Parser s t a -> Parser s t sep -> Parser s t [a]- , sepBy1 -- :: Parser s t a -> Parser s t sep -> Parser s t [a]- , bracketSep -- :: Parser s t bra -> Parser s t sep -> Parser s t ket- -- -> Parser s t a -> Parser s t [a]- , bracket -- :: Parser s t bra -> Parser s t ket -> Parser s t a- -- -> Parser s t a- , manyFinally -- :: Parser s t a -> Parser s t z -> Parser s t [a]- -- ** State-handling- , stUpdate -- :: (s->s) -> Parser s t ()- , stQuery -- :: (s->a) -> Parser s t a- , stGet -- :: Parser s t s- -- ** Re-parsing- , reparse -- :: [t] -> Parser s t ()- ) where---- | The @Parser@ datatype is a fairly generic parsing monad with error--- reporting and a running state. It can be used for arbitrary token--- types, not just String input.-newtype Parser s t a = P (s -> [t] -> (EitherE String a, s, [t]))---- | A return type like Either, that distinguishes not only between--- right and wrong answers, but also had gradations of wrongness.-type EitherE a b = Either (Bool,a) b---- | Apply a parser to an initial state and input token sequence.-runParser :: Parser s t a -> s -> [t] -> (Either String a, s, [t])-runParser (P p) s =- (\ (e,s,ts)-> (case e of Left (_,m)->Left m; Right m->Right m- ,s,ts))- . p s--instance Functor (Parser s t) where- fmap f (P p) = P (\s ts-> case p s ts of- (Left msg, s', ts') -> (Left msg, s', ts')- (Right x, s', ts') -> (Right (f x), s', ts'))-instance Monad (Parser s t) where- return x = P (\s ts-> (Right x, s, ts))- (P f) >>= g = P (\s ts-> case f s ts of- (Left msg, s', ts') -> (Left msg, s', ts')- (Right x, s', ts') -> let (P g') = g x- in g' s' ts')- fail msg = P (\s ts-> (Left (False,msg), s, ts))---- | When a simple fail is not strong enough, use failBad for emphasis.--- An emphasised (severe) error can propagate out through choice operators.-failBad :: String -> Parser s t a-failBad msg = P (\s ts-> (Left (True,msg), s, ts))---- | Commit is a way of raising the severity of any errors found within--- its argument. Used in the middle of a parser definition, it means that--- any operations prior to commitment fail softly, but after commitment,--- they fail hard.-commit :: Parser s t a -> Parser s t a-commit (P p) = P (\s ts-> case p s ts of- (Left (_,e), s', ts') -> (Left (True,e), s', ts')- right -> right )---- Combinators---- | One token-next :: Parser s t t-next = P (\s ts-> case ts of- [] -> (Left (False,"Ran out of input (EOF)"), s, [])- (t:ts') -> (Right t, s, ts') )---- | One token satifying a predicate-satisfy :: (t->Bool) -> Parser s t t-satisfy p = do{ x <- next- ; if p x then return x else fail "Parse.satisfy: failed"- }--infixl 3 `apply`--- | Apply a parsed function to a parsed value-apply :: Parser s t (a->b) -> Parser s t a -> Parser s t b-pf `apply` px = do { f <- pf; x <- px; return (f x) }--infixl 3 `discard`--- | @x `discard` y@ parses both x and y, but discards the result of y-discard :: Parser s t a -> Parser s t b -> Parser s t a-px `discard` py = do { x <- px; _ <- py; return x }---- | @p `adjustErr` f@ applies the transformation @f@ to any error message--- generated in @p@, having no effect if @p@ succeeds.-adjustErr :: Parser s t a -> (String->String) -> Parser s t a-(P p) `adjustErr` f =- P (\s ts-> case p s ts of- (Left (b,msg), s', ts') -> (Left (b,(f msg)), s, ts')- right -> right )---- | @adjustErrBad@ is just like @adjustErr@ except it also raises the--- severity of the error.-adjustErrBad :: Parser s t a -> (String->String) -> Parser s t a--- p `adjustErrBad` f = commit (p `adjustErr` f)-(P p) `adjustErrBad` f =- P (\s ts-> case p s ts of- (Left (_,msg), s', ts') -> (Left (True,(f msg)), s, ts')- right -> right )--infixl 6 `onFail` -- not sure about precedence 6?--- | @p `onFail` q@ means parse p unless p fails in which case parse q instead.--- Can be chained together to give multiple attempts to parse something.--- (Note that q could itself be a failing parser, e.g. to change the error--- message from that defined in p to something different.)--- However, a severe failure in p cannot be ignored.-onFail :: Parser s t a -> Parser s t a -> Parser s t a-(P p) `onFail` (P q) = P (\s ts-> case p s ts of- r@(Left (True,_), _, _) -> r- (Left _, _, _) -> q s ts- right -> right )---- | Parse the first alternative in the list that succeeds.-oneOf :: [Parser s t a] -> Parser s t a-oneOf [] = fail ("Failed to parse any of the possible choices")-oneOf (p:ps) = p `onFail` oneOf ps---- | Parse the first alternative that succeeds, but if none succeed,--- report only the severe errors, and if none of those, then report--- all the soft errors.-oneOf' :: [(String, Parser s t a)] -> Parser s t a-oneOf' = accum []- where accum errs [] =- case filter isBad errs of- [] -> fail ("failed to parse any of the possible choices:\n"- ++indent 2 (concatMap showErr (reverse errs)))- [(_,(_,e))] -> failBad e- es -> failBad ("one of the following failures occurred:\n"- ++indent 2 (concatMap showErr (reverse es)))- accum errs ((e,P p):ps) =- P (\u ts-> case p u ts of- (Left err,_,_) -> let (P p) = accum ((e,err):errs) ps- in p u ts- right -> right )- showErr (name,(_,err)) = name++":\n"++indent 2 err- isBad (_,(b,_)) = b---- | Helper for formatting error messages: indents all lines by a fixed amount.-indent :: Int -> String -> String-indent n = unlines . map (replicate n ' ' ++) . lines---- | 'exactly n p' parses a precise number of items, n, using the parser--- p, in sequence.-exactly :: Int -> Parser s t a -> Parser s t [a]-exactly 0 p = return []-exactly n p = do x <- p- xs <- exactly (n-1) p- return (x:xs)---- | 'many p' parses a list of elements with individual parser p.--- Cannot fail, since an empty list is a valid return value.-many :: Parser s t a -> Parser s t [a]-many p = many1 p `onFail` return []---- | Parse a non-empty list of items.-many1 :: Parser s t a -> Parser s t [a]-many1 p = do { x <- p `adjustErr` (("In a sequence:\n"++). indent 2)- ; xs <- many p- ; return (x:xs)- }--- `adjustErr` ("When looking for a non-empty sequence:\n"++)---- | Parse a list of items separated by discarded junk.-sepBy :: Parser s t a -> Parser s t sep -> Parser s t [a]-sepBy p sep = do sepBy1 p sep `onFail` return []---- | Parse a non-empty list of items separated by discarded junk.-sepBy1 :: Parser s t a -> Parser s t sep -> Parser s t [a]-sepBy1 p sep = do { x <- p- ; xs <- many (do {sep; p})- ; return (x:xs)- }- `adjustErr` ("When looking for a non-empty sequence with separators:\n"++)- --- | Parse a list of items, discarding the start, end, and separator--- items.-bracketSep :: Parser s t bra -> Parser s t sep -> Parser s t ket- -> Parser s t a -> Parser s t [a]-bracketSep open sep close p =- do { open; close; return [] }- `onFail`- do { open `adjustErr` ("Missing opening bracket:\n"++)- ; x <- p `adjustErr` ("After first bracket in a group:\n"++)- ; xs <- many (do {sep; p})- ; close `adjustErrBad` ("When looking for closing bracket:\n"++)- ; return (x:xs)- }---- | Parse a bracketed item, discarding the brackets.-bracket :: Parser s t bra -> Parser s t ket -> Parser s t a -> Parser s t a-bracket open close p = do- do { open `adjustErr` ("Missing opening bracket:\n"++)- ; x <- p- ; close `adjustErrBad` ("Missing closing bracket:\n"++)- ; return x- }---- | 'manyFinally e t' parses a possibly-empty sequence of e's,--- terminated by a t. Any parse failures could be due either to--- a badly-formed terminator or a badly-formed element, so raise--- both possible errors.-manyFinally :: Parser s t a -> Parser s t z -> Parser s t [a]-manyFinally p t =- do { xs <- many p- ; oneOf' [ ("sequence terminator", do { t; return () } )- , ("item in a sequence", do { p; return () } )- ]- ; return xs- }----------------------------------------------------------------------------- State handling---- | Update the internal state.-stUpdate :: (s->s) -> Parser s t ()-stUpdate f = P (\s ts-> (Right (), f s, ts))---- | Query the internal state.-stQuery :: (s->a) -> Parser s t a-stQuery f = P (\s ts-> (Right (f s), s, ts))---- | Deliver the entire internal state.-stGet :: Parser s t s-stGet = P (\s ts-> (Right s, s, ts))----------------------------------------------------------------------------- | Push some tokens back onto the front of the input stream and reparse.--- This is useful e.g. for recursively expanding macros. When the--- user-parser recognises a macro use, it can lookup the macro--- expansion from the parse state, lex it, and then stuff the--- lexed expansion back down into the parser.-reparse :: [t] -> Parser s t ()-reparse ts = P (\s inp-> (Right (), s, ts++inp))--------------------------------------------------------------------------
− src/Text/ParserCombinators/PolyStateLazy.hs
@@ -1,290 +0,0 @@-module Text.ParserCombinators.PolyStateLazy- ( -- * The Parser datatype.- -- $parser- Parser(P) -- datatype, instance of: Functor, Monad- , runParser -- :: Parser s t a -> s -> [t] -> (a, s, [t])- , failBad -- :: String -> Parser s t a- , commit -- :: Parser s t a -> Parser s t a- -- * Combinators:- -- ** Primitives- , next -- :: Parser s t t- , satisfy -- :: (t->Bool) -> Parser s t t- , apply -- :: Parser t (a->b) -> Parser s t a -> Parser s t b- , discard -- :: Parser s t a -> Parser s t b -> Parser s t a- -- ** Error-handling- , adjustErr -- :: Parser s t a -> (String->String) -> Parser s t a- , adjustErrBad-- :: Parser s t a -> (String->String) -> Parser s t a- , indent -- :: Int -> String -> String- -- ** Choices- , onFail -- :: Parser s t a -> Parser s t a -> Parser s t a- , oneOf -- :: [Parser s t a] -> Parser s t a- , oneOf' -- :: [(String, Parser s t a)] -> Parser s t a- , optional -- :: Parser s t a -> Parser s t (Maybe a)- -- ** Sequences- , exactly -- :: Int -> Parser s t a -> Parser s t [a]- , many -- :: Parser s t a -> Parser s t [a]- , many1 -- :: Parser s t a -> Parser s t [a]- , sepBy -- :: Parser s t a -> Parser s t sep -> Parser s t [a]- , sepBy1 -- :: Parser s t a -> Parser s t sep -> Parser s t [a]- , bracketSep -- :: Parser s t bra -> Parser s t sep -> Parser s t ket- -- -> Parser s t a -> Parser s t [a]- , bracket -- :: Parser s t bra -> Parser s t ket -> Parser s t a- -- -> Parser s t a- , manyFinally -- :: Parser s t a -> Parser s t z -> Parser s t [a]- -- ** State-handling- , stUpdate -- :: (s->s) -> Parser s t ()- , stQuery -- :: (s->a) -> Parser s t a- , stGet -- :: Parser s t s- -- ** Re-parsing- , reparse -- :: [t] -> Parser s t ()- ) where--#if __GLASGOW_HASKELL__-import Control.Exception hiding (bracket)-throwE :: String -> a-throwE msg = throw (ErrorCall msg)-#else-throwE :: String -> a-throwE msg = error msg-#endif---- $parser--- Parsers do not return explicit failure. An exception is raised--- instead. This allows partial results to be returned before a--- full parse is complete.---- | The @Parser@ datatype is a fairly generic parsing monad with error--- reporting and a running state. It can be used for arbitrary token--- types, not just String input.-newtype Parser s t a = P (s -> [t] -> (Either String a, s, [t]))---- | A return type like Either, that distinguishes not only between--- right and wrong answers, but also had gradations of wrongness.--- Not used in this library. !!!!!!!!!!!!!!!!!!!!!!!!!!-type EitherE a b = Either (Bool,a) b---- | Apply a parser to an initial state and input token sequence.--- The parser cannot return an error value explicitly, so errors--- raise an exception. Thus, results can be partial (lazily constructed,--- but containing undefined).-runParser :: Parser s t a -> s -> [t] -> (a, s, [t])-runParser (P p) s =- (\ (e,s,ts)-> (case e of {Left m->throwE m; Right x->x}, s, ts))- . p s--instance Functor (Parser s t) where- fmap f (P p) = P (\s ts-> case p s ts of- (Left msg, s', ts') -> (Left msg, s', ts')- (Right x, s', ts') -> (Right (f x), s', ts'))-instance Monad (Parser s t) where- return x = P (\s ts-> (Right x, s, ts))- (P f) >>= g = P (\s ts-> case f s ts of- (Left msg, s', ts') -> (Left msg, s', ts')- (Right x, s', ts') -> let (P g') = g x- in g' s' ts')- fail msg = P (\s ts-> (Left msg, s, ts))---- | Simple failure can be corrected, but when a simple fail is not strong--- enough, use failBad for emphasis. It guarantees parsing will terminate--- with an exception.-failBad :: String -> Parser s t a-failBad msg = P (\s ts-> (throwE msg, s, ts))---- | Commit is a way of raising the severity of any errors found within--- its argument. Used in the middle of a parser definition, it means that--- any operations prior to commitment fail softly, but after commitment,--- they fail hard.-commit :: Parser s t a -> Parser s t a-commit (P p) = P (\s ts-> case p s ts of- (Left e, s', ts') -> (throwE e, s', ts')- right -> right )---- Combinators---- | One token-next :: Parser s t t-next = P (\s ts-> case ts of- [] -> (Left "Ran out of input (EOF)", s, [])- (t:ts') -> (Right t, s, ts') )---- | One token satifying a predicate-satisfy :: (t->Bool) -> Parser s t t-satisfy p = do{ x <- next- ; if p x then return x else fail "Parse.satisfy: failed"- }--infixl 3 `apply`--- | Apply a parsed function to a parsed value-apply :: Parser s t (a->b) -> Parser s t a -> Parser s t b---pf `apply` px = do { f <- pf; x <- px; return (f x) }--- Needs to be lazier! Must not force the argument value too early.-(P pf) `apply` (P px) = P (\s ts->- case pf s ts of- (Left msg, s', ts') -> (Left msg, s', ts')- (Right f, s', ts') -> let (x',s'',ts'') = px s' ts'- x = case x' of- Right x -> x- Left e -> throwE e- in (Right (f x), s'', ts''))--infixl 3 `discard`--- | @x `discard` y@ parses both x and y, but discards the result of y-discard :: Parser s t a -> Parser s t b -> Parser s t a-px `discard` py = do { x <- px; _ <- py; return x }---- | @p `adjustErr` f@ applies the transformation @f@ to any error message--- generated in @p@, having no effect if @p@ succeeds.-adjustErr :: Parser s t a -> (String->String) -> Parser s t a-(P p) `adjustErr` f =- P (\s ts-> case p s ts of- (Left msg, s', ts') -> (Left (f msg), s, ts')- right -> right )---- | @adjustErrBad@ is just like @adjustErr@ except it also raises the--- severity of the error.-adjustErrBad :: Parser s t a -> (String->String) -> Parser s t a--- p `adjustErrBad` f = commit (p `adjustErr` f)-(P p) `adjustErrBad` f =- P (\s ts-> case p s ts of- (Left msg, s', ts') -> (throwE (f msg), s, ts')- right -> right )--infixl 6 `onFail` -- not sure about precedence 6?--- | @p `onFail` q@ means parse p unless p fails in which case parse q instead.--- Can be chained together to give multiple attempts to parse something.--- (Note that q could itself be a failing parser, e.g. to change the error--- message from that defined in p to something different.)--- However, a *severe* failure in p cannot be ignored.-onFail :: Parser s t a -> Parser s t a -> Parser s t a-(P p) `onFail` (P q) = P (\s ts-> case p s ts of- (Left _, _, _) -> q s ts- right -> right )---- | Parse the first alternative in the list that succeeds.-oneOf :: [Parser s t a] -> Parser s t a-oneOf [] = fail ("Failed to parse any of the possible choices")-oneOf (p:ps) = p `onFail` oneOf ps---- | Parse the first alternative that succeeds, but if none succeed,--- report only the severe errors, and if none of those, then report--- all the soft errors.-oneOf' :: [(String, Parser s t a)] -> Parser s t a-oneOf' ps = accum [] ps- where accum errs [] =- case errs of- [] -> failBad ("internal failure in parser (oneOf'):\n"- ++indent 2 (show (map fst ps)))- [(_,e)] -> fail e- es -> fail ("one of the following failures occurred:\n"- ++indent 2 (concatMap showErr (reverse es)))- accum errs ((e,P p):ps) =- P (\u ts-> case p u ts of- (Left err,_,_) -> let (P p) = accum ((e,err):errs) ps- in p u ts- right -> right )- showErr (name,err) = name++":\n"++indent 2 err---- | Helper for formatting error messages: indents all lines by a fixed amount.-indent :: Int -> String -> String-indent n = unlines . map (replicate n ' ' ++) . lines---- | 'optional' indicates whether the parser succeeded through the Maybe type.-optional :: Parser s t a -> Parser s t (Maybe a)-optional p = fmap Just p `onFail` return Nothing---- | 'exactly n p' parses a precise number of items, n, using the parser--- p, in sequence.-exactly :: Int -> Parser s t a -> Parser s t [a]-exactly 0 p = return []-exactly n p = do x <- p- xs <- exactly (n-1) p- return (x:xs)---- | 'many p' parses a list of elements with individual parser p.--- Cannot fail, since an empty list is a valid return value.-many :: Parser s t a -> Parser s t [a]-many p = many1 p `onFail` return []---- | Parse a non-empty list of items.-many1 :: Parser s t a -> Parser s t [a]-many1 p = do { x <- p `adjustErr` (("In a sequence:\n"++). indent 2)- ; xs <- many p- ; return (x:xs)- }--- `adjustErr` ("When looking for a non-empty sequence:\n"++)---- | Parse a list of items separated by discarded junk.-sepBy :: Parser s t a -> Parser s t sep -> Parser s t [a]-sepBy p sep = do sepBy1 p sep `onFail` return []---- | Parse a non-empty list of items separated by discarded junk.-sepBy1 :: Parser s t a -> Parser s t sep -> Parser s t [a]-sepBy1 p sep = do { x <- p- ; xs <- many (do {sep; p})- ; return (x:xs)- }- `adjustErr` ("When looking for a non-empty sequence with separators:\n"++)- --- | Parse a list of items, discarding the start, end, and separator--- items.-bracketSep :: Parser s t bra -> Parser s t sep -> Parser s t ket- -> Parser s t a -> Parser s t [a]-bracketSep open sep close p =- do { open; close; return [] }- `onFail`- do { open `adjustErr` ("Missing opening bracket:\n"++)- ; x <- p `adjustErr` ("After first bracket in a group:\n"++)- ; xs <- many (do {sep; p})- ; close `adjustErrBad` ("When looking for closing bracket:\n"++)- ; return (x:xs)- }---- | Parse a bracketed item, discarding the brackets.-bracket :: Parser s t bra -> Parser s t ket -> Parser s t a -> Parser s t a-bracket open close p = do- do { open `adjustErr` ("Missing opening bracket:\n"++)- ; x <- p- ; close `adjustErrBad` ("Missing closing bracket:\n"++)- ; return x- }---- | 'manyFinally e t' parses a possibly-empty sequence of e's,--- terminated by a t. Any parse failures could be due either to--- a badly-formed terminator or a badly-formed element, so raise--- both possible errors.-manyFinally :: Parser s t a -> Parser s t z -> Parser s t [a]-manyFinally pp@(P p) pt@(P t) = P (\s ts ->- case p s ts of- (Left e, _, _) ->- case t s ts of- (Right _, s', ts') -> (Right [], s', ts')- (Left e, s', ts') -> (Left e, s', ts')- (Right x, s', ts') ->- let (tail,s'',ts'') = runParser (manyFinally pp pt) s' ts'- in (Right (x:tail), s'', ts'') )----------------------------------------------------------------------------- State handling---- | Update the internal state.-stUpdate :: (s->s) -> Parser s t ()-stUpdate f = P (\s ts-> (Right (), f s, ts))---- | Query the internal state.-stQuery :: (s->a) -> Parser s t a-stQuery f = P (\s ts-> (Right (f s), s, ts))---- | Deliver the entire internal state.-stGet :: Parser s t s-stGet = P (\s ts-> (Right s, s, ts))----------------------------------------------------------------------------- | Push some tokens back onto the front of the input stream and reparse.--- This is useful e.g. for recursively expanding macros. When the--- user-parser recognises a macro use, it can lookup the macro--- expansion from the parse state, lex it, and then stuff the--- lexed expansion back down into the parser.-reparse :: [t] -> Parser s t ()-reparse ts = P (\s inp-> (Right (), s, ts++inp))--------------------------------------------------------------------------