Text.Trifecta.Parser

The type of a trifecta parser

The first four arguments are behavior continuations:

• epsilon success: the parser has consumed no input and has a result as well as a possible Err; the position and chunk are unchanged (see pure)

• epsilon failure: the parser has consumed no input and is failing with the given Err; the position and chunk are unchanged (see empty)

• committed success: the parser has consumed input and is yielding the result, set of expected strings that would have permitted this parse to continue, new position, and residual chunk to the continuation.

• committed failure: the parser has consumed input and is failing with a given ErrInfo (user-facing error message)

The remaining two arguments are

• the current position

• the chunk of input currently under analysis

Parser is an Alternative; trifecta's backtracking behavior encoded as <|> is to behave as the leftmost parser which yields a value (regardless of any input being consumed) or which consumes input and fails. That is, a choice of parsers will only yield an epsilon failure if *all* parsers in the choice do. If that is not the desired behavior, see try, which turns a committed parser failure into an epsilon failure (at the cost of error information).

A Step allows for incremental parsing, since the parser

• can be done with a final result

• have errored

• can have yielded a partial result with possibly more to come

Feed some additional input to a Step to continue parsing a bit further.

Assume all possible input has been given to the parser, execute it to yield a final result.

Incremental parsing. A Step can be supplied with new input using feed, the final Result is obtained using starve.

Run a Parser on input that can be reduced to a Rope, e.g. String, or ByteString. See also the monomorphic versions parseString and parseByteString.

(parseFromFile p filePath) runs a parser p on the input read from filePath using ByteString.readFile. All diagnostic messages emitted over the course of the parse attempt are shown to the user on the console.

main = do
  result <- parseFromFile numbers "digits.txt"
  case result of
    Nothing -> return ()
    Just a  -> print $ sum a

(parseFromFileEx p filePath) runs a parser p on the input read from filePath using ByteString.readFile. Returns all diagnostic messages emitted over the course of the parse and the answer if the parse was successful.

main = do
  result <- parseFromFileEx (many number) "digits.txt"
  case result of
    Failure xs -> displayLn xs
    Success a  -> print (sum a)

Fully parse a String to a Result.

parseByteString p delta i runs a parser p on i.

Fully parse a ByteString to a Result.

parseByteString p delta i runs a parser p on i.