Language.Rust.Parser.ParseMonad

Both the lexer and the parser run inside of the P monad. As detailed in the section on on threaded-lexers in Happy's instruction manual, the benefits of this are that:

• Lexical errors can be treated in the same way as parse errors
• Information such as the current position in the file shared between the lexer and parser
• General information can be passed back from the parser to the lexer too

In our case, this shared information is held in PState.

Parsing monad

data P a

Parsing and lexing monad. A value of type P a represents a parser that can be run (using execParser) to possibly produce a value of type a.

Instances

Monad P

Defined in Language.Rust.Parser.ParseMonad

Methods

(>>=) :: P a -> (a -> P b) -> P b

(>>) :: P a -> P b -> P b

return :: a -> P a

fail :: String -> P a

Functor P

Defined in Language.Rust.Parser.ParseMonad

Methods

fmap :: (a -> b) -> P a -> P b

(<$) :: a -> P b -> P a

MonadFail P

Defined in Language.Rust.Parser.ParseMonad

Methods

fail :: String -> P a

Applicative P

Defined in Language.Rust.Parser.ParseMonad

Methods

pure :: a -> P a

(<*>) :: P (a -> b) -> P a -> P b

liftA2 :: (a -> b -> c) -> P a -> P b -> P c

(*>) :: P a -> P b -> P b

(<*) :: P a -> P b -> P a

execParser :: P a -> InputStream -> Position -> Either ParseFail a

Execute the given parser on the supplied input stream at the given start position, returning either the position of an error and the error message, or the value parsed.

execParser' :: P a -> InputStream -> Position -> (Token -> Token) -> Either ParseFail a

Generalized version of execParser that expects an extra argument that lets you hot-swap a token that was just lexed before it gets passed to the parser.

initPos :: Position

Starting position in a file.

data PState

State that the lexer and parser share

Constructors

PState

Fields

• curPos :: !Position

  position at current input location

• curInput :: !InputStream

  the current input

• prevPos :: Position

  position at previous input location

• pushedTokens :: [Spanned Token]

  tokens manually pushed by the user

• swapFunction :: Token -> Token

  function to swap token

Monadic operations

getPState :: P PState

Extract the state stored in the parser.

setPState :: PState -> P ()

Update the state stored in the parser.

getPosition :: P Position

Retrieve the current position of the parser.

setPosition :: Position -> P ()

Update the current position of the parser.

getInput :: P InputStream

Retrieve the current InputStream of the parser.

setInput :: InputStream -> P ()

Update the current InputStream of the parser.

popToken :: P (Maybe (Spanned Token))

Manually pop a Spanned Token (if there are no tokens to pop, returns Nothing). See pushToken for more details.

pushToken :: Spanned Token -> P ()

Manually push a Spanned Token. This turns out to be useful when parsing tokens that need to be broken up. For example, when seeing a GreaterEqual token but only expecting a Greater token, one can consume the GreaterEqual token and push back an Equal token.

swapToken :: Token -> P Token

Swap a token using the swap function.

Error reporting

data ParseFail

Exceptions that occur during parsing

Constructors

ParseFail Position String

Instances

Eq ParseFail

Defined in Language.Rust.Parser.ParseMonad

Methods

(==) :: ParseFail -> ParseFail -> Bool

(/=) :: ParseFail -> ParseFail -> Bool

Show ParseFail

Defined in Language.Rust.Parser.ParseMonad

Methods

showsPrec :: Int -> ParseFail -> ShowS

show :: ParseFail -> String

showList :: [ParseFail] -> ShowS

Exception ParseFail

Defined in Language.Rust.Parser.ParseMonad

Methods

toException :: ParseFail -> SomeException

fromException :: SomeException -> Maybe ParseFail

displayException :: ParseFail -> String

parseError :: Show b => b -> P a

Signal a syntax error.