Language.Noodle.Parsing.Generic

GParser is a generalized backtracking parser combinator with state, error propogation and easy to use associativity primitves.

Documentation

data Result st tok res

Result encompases error propogation, parameterized over st state type, tok token type, and res the monadic return value

Constructors

Success res st [tok]

'Success result state token_stream'

Failure String st

'Failure error_message state'

Instances

(Show st, Show tok, Show res) => Show (Result st tok res)

newtype GParser st tok res

a GParser computes some result res, based on a stream of tokens tok having a state of type st

Constructors

P ((st, [tok]) -> Result st tok res)

Instances

Monad (GParser s t)

getTok :: GParser st tok tok

consume one token and return it

lookToks :: GParser st tok [tok]

lookahead at the rest of the tokens left in the input

getTokIf :: (tok -> Bool) -> GParser st tok tok

consume one token and return it if the result of applying the predicate to it is true, otherwise fail with 'unexpected token'

inputEnd :: GParser st tok ()

succeed if all of the input has been consumed, otherwise complain about expecting the end of the input

getSt :: GParser st tok st

return the current state

putSt :: st -> GParser st tok ()

change the value of the current state

modSt :: (st -> st) -> GParser st tok ()

apply some update function to the current state

many :: GParser st tok res -> GParser st tok [res]

apply the parser as many times as is possible, and return a list of the results

many1 :: GParser st tok res -> GParser st tok [res]

apply the parser one or more times, and return a list of the results. Fails the first application fails

sepBy1 :: GParser st tok res -> GParser st tok b -> GParser st tok [res]

parse many1 p's seperated by sep

sepBy :: GParser st tok res -> GParser st tok b -> GParser st tok [res]

parse many p's seperated by sep

(<|>) :: GParser st tok res -> GParser st tok res -> GParser st tok res

if the left operand | results in failure, apply the right operand. state and token stream changes are not carried over to right operand

choice :: [GParser st tok res] -> GParser st tok res

the first successful parser to succeed is parsed, if none, fail

pMaybe :: GParser st tok res -> GParser st tok (Maybe res)

try to apply parser p, return Just res on success, or Nothing on fail

pEither :: GParser st tok a -> GParser st tok b -> GParser st tok (Either a b)

try to parse either p1 or p2, returning Left a for p1, or Right b for p2

runp :: GParser st tok res -> st -> [tok] -> Result st tok res

apply a GParser computation to state and a token stream, returning a value of type Result