Skip to content

HORIZON HASKELL Docs lts/ghc-10.0.x8fef28d2026-11-02Search packagesCtrl K

Theme: |

GHC 10.0.0.20260917 · lts/ghc-10.0.x · 8fef28d · 2026-11-02

Modulepolyparse-1.13.1Haskell2010

Text.ParserCombinators.HuttonMeijerWallace

This library of monadic parser combinators is based on the ones defined by Graham Hutton and Erik Meijer. It has been extended by Malcolm Wallace to use an abstract token type (no longer just a string) as input, and to incorporate state in the monad, useful for symbol tables, macros, and so on. Basic facilities for error reporting have also been added, and later extended by Graham Klyne to return the errors through an Either type, rather than just calling error.

Contents

The parser monad
Primitive parser combinators
Derived combinators
Error handling
State handling
Re-parsing

Synopsis

newtype Parser
value item
value eof
value papply
value papply'
value +++
value tok
value nottok
value many
value many1
value sepby
value sepby1
value chainl
value chainl1
value chainr
value chainr1
value ops
value bracket
value toEOF
value elserror
value stupd
value stquery
value stget
value reparse

Packagepolyparse-1.13.1
Exports24
LanguageHaskell2010
LicenceLicenseRef-LGPL
SourceHuttonMeijerWallace.hs

The parser monad

newtypenewtype Parser s t e a

Constructors

P (s -> [Either e t] -> ParseResult s t e a)
The parser type is parametrised on the types of the state s, the input tokens t, error-type e, and the result value a. The state and remaining input are threaded through the monad.

Instances6Monad, Functor, MonadFail, Applicative, Alternative, MonadPlus

Monad (Parser s t e)Defined in polyparse-1.13.1 · Text.ParserCombinators.HuttonMeijerWallace
Functor (Parser s t e)Defined in polyparse-1.13.1 · Text.ParserCombinators.HuttonMeijerWallace
MonadFail (Parser s t e)Defined in polyparse-1.13.1 · Text.ParserCombinators.HuttonMeijerWallace
Applicative (Parser s t e)Defined in polyparse-1.13.1 · Text.ParserCombinators.HuttonMeijerWallace
Alternative (Parser s t e)Defined in polyparse-1.13.1 · Text.ParserCombinators.HuttonMeijerWallace
MonadPlus (Parser s t e)Defined in polyparse-1.13.1 · Text.ParserCombinators.HuttonMeijerWallace

Primitive parser combinators

valueitem :: Parser s t e t

Deliver the first remaining token.

valueeof :: Show p => Parser s (p, t) String ()

Fail if end of input is not reached

valuepapply

:: Parser s t String a
-> s
-> [Either String t]
-> [(a, s, [Either String t])]

Apply the parser to some real input, given an initial state value. If the parser fails, raise error to halt the program. (This is the original exported behaviour - to allow the caller to deal with the error differently, see papply'.)

valuepapply'

:: Parser s t e a
-> s
-> [Either e t]
-> Either e [(a, s, [Either e t])]

Apply the parser to some real input, given an initial state value. If the parser fails, return a diagnostic message to the caller.

Derived combinators

value(+++) :: Parser s t e a -> Parser s t e a -> Parser s t e a

A choice between parsers. Keep only the first success.

valuetok :: Eq t => t -> Parser s (p, t) e t

Deliver the first token if it equals the argument.

valuenottok :: Eq t => [t] -> Parser s (p, t) e t

Deliver the first token if it does not equal the argument.

valuemany :: Parser s t e a -> Parser s t e [a]

Deliver zero or more values of a.

valuemany1 :: Parser s t e a -> Parser s t e [a]

Deliver one or more values of a.

valuesepby :: Parser s t e a -> Parser s t e b -> Parser s t e [a]

Deliver zero or more values of a separated by b's.

valuesepby1 :: Parser s t e a -> Parser s t e b -> Parser s t e [a]

Deliver one or more values of a separated by b's.

valuechainl

:: Parser s t e a
-> Parser s t e (a -> a -> a)
-> a
-> Parser s t e a

valuechainl1 :: Parser s t e a -> Parser s t e (a -> a -> a) -> Parser s t e a

valuechainr

:: Parser s t e a
-> Parser s t e (a -> a -> a)
-> a
-> Parser s t e a

valuechainr1 :: Parser s t e a -> Parser s t e (a -> a -> a) -> Parser s t e a

valueops :: [(Parser s t e a, b)] -> Parser s t e b

valuebracket

:: (Show p, Show t)
=> Parser s (p, t) e a
-> Parser s (p, t) e b
-> Parser s (p, t) e c
-> Parser s (p, t) e b

valuetoEOF :: Show p => Parser s (p, t) String a -> Parser s (p, t) String a

Accept a complete parse of the input only, no partial parses.

Error handling

valueelserror

:: (Show p, Show t)
=> Parser s (p, t) String a
-> String
-> Parser s (p, t) String a

If the parser fails, generate an error message.

State handling

valuestupd :: (s -> s) -> Parser s t e ()

Update the internal state.

valuestquery :: (s -> a) -> Parser s t e a

Query the internal state.

valuestget :: Parser s t e s

Deliver the entire internal state.

Re-parsing

valuereparse :: [Either e t] -> Parser s t e ()

This is useful 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.