Parsing - purescript-parsing - Pursuit (original) (raw)

Package

purescript-parsing

Repository

purescript-contrib/purescript-parsing

Types and operations for monadic parsing.

Combinators are in the Parsing.Combinators module.

Primitive parsers for String input streams are in the Parsing.Stringmodule.

#Parser Source

type Parser s = ParserT s Identity

The Parser s monad, where s is the type of the input stream.

A synonym for the ParserT monad transformer applied to the Identity monad.

#Position Source

newtype Position

Position represents the position of the parser in the input stream.

Constructors

Instances

#consume Source

consume :: forall s m. ParserT s m Unit

Set the consumed flag.

Setting the consumed flag means that we're committed to this parsing branch of an alternative (<|>), so that if this branch fails then we want to fail the entire parse instead of trying the other alternative.

#region Source

region :: forall m s a. (ParseError -> ParseError) -> ParserT s m a -> ParserT s m a

Contextualize parsing failures inside a region. If a parsing failure occurs, then the ParseError will be transformed by each containingregion as the parser backs out the call stack.

For example, here’s a helper function inContext which uses region to add some string context to the error messages.

let
  inContext :: forall s m a. (String -> String) -> ParserT s m a -> ParserT s m a
  inContext context = region \(ParseError message pos) ->
    ParseError (context message) pos

  input = "Tokyo thirty-nine million"

lmap (parseErrorHuman input 30) $ runParser input do
  inContext ("Megacity list: " <> _) do
    cityname <- inContext ("city name: " <> _) (takeWhile isLetter)
    skipSpaces
    population <- inContext ("population: " <> _) intDecimal
    pure $ Tuple cityname population

Megacity list: population: Expected Int at position index:6 (line:1, column:7)
      ▼
Tokyo thirty-nine million

#liftMaybe Source

liftMaybe :: forall s m a. Monad m => (Unit -> String) -> Maybe a -> ParserT s m a

Lift a Maybe a computation into a ParserT, with a note for the ParseError message in case of Nothing.

Consumes no parsing input, does not change the parser state at all. If the Maybe computation is Nothing, then this will fail in theParserT monad with the given error message String at the current inputPosition.

This is a “validation” function, for when we want to produce some data from the parsing input or fail at the current parsing position if that’s impossible.

For example, parse an integerBoundedEnumcode and validate it by turning it into a MyEnum. Use tryRethrow to position the parse error at the beginning of the integer in the input String if the toEnum fails.

runParser "3" do
  myenum :: MyEnum <- tryRethrow do
    x <- intDecimal
    liftMaybe (\_ -> "Bad MyEnum " <> show x) $ toEnum x

#liftEither Source

liftEither :: forall s m a. Monad m => Either String a -> ParserT s m a

Lift an Either String a computation into a ParserT.

Consumes no parsing input, does not change the parser state at all. If the Either computation is Left String, then this will fail in theParserT monad at the current input Position.

This is a “validation” function, for when we want to produce some data from the parsing input or fail at the current parsing position if that’s impossible.

#liftExceptT Source

liftExceptT :: forall s m a. Monad m => ExceptT String m a -> ParserT s m a

Lift an ExceptT String m a computation into a ParserT.

Consumes no parsing input, does not change the parser state at all. If the ExceptT computation is Left String, then this will fail in theParserT monad at the current input Position.

This is a “validation” function, for when we want to produce some data from the parsing input or fail at the current parsing position if that’s impossible.

#ParseState Source

data ParseState s

The internal state of the ParserT s m monad.

Contains the remaining input and current position and the consumed flag.

The consumed flag is used to implement the rule for alt that

Constructors