Parser

An intermediate object for creating sequence-based combination methods for a Parser or Consumer.

An internally-mutable representation of a Parser, which reacts to inputs from a data stream and eventually produces a result.

Adds followedBy and followedByStream to Parser (they aren't defined in the Parser trait due to the In type needing to be invariant here)

Specialization for Parsers which require no mutable state. A "stateless" parser acts as its own handler.

Convenience for creating parsers whose input type is bound to In.

This is particularly nice when the Out type can be inferred by the compiler, e.g.

Parser[Int].fold(1)(_ + _)
// versus
Parser.fold[Int, Int](1)(_ + _)

Creates a parser which delegates to the given call-by-name p parser. The p expression isn't evaluated until a handler created by this parser is created - that handler will be p's handler. The underlying parser is not memoized, so if a new handler is constructed, the p expression will be re-evaluated.

Creates a parser from a call-by-name handler construction expression. This is effectively doing

new Parser[In, Out] {
 def newHandler = h
}

Creates a parser which evaluates the call-by-name value expression. The value expression won't be evaluated until a handler created by this parser is asked to step or finish. The value is not memoized, so if a new handler is created, that handler will re-evaluate the value.

Create a parser which will consume the entire input stream, ignoring each value, yielding a Unit result when the stream ends.

Creates a parser which returns the first input for which the predicate function returns true.

Creates a parser which returns the first input it receives, or throws a SpacException.MissingFirstException when handling an empty stream.

Creates a parser which returns the first input it receives, or None when handling an empty stream.

Creates a parser which folds inputs into its state according to the op function, returning its final state when the input stream ends.

Creates a parser whose handlers which will construct a new builder via the call-by-name b expression. The builder's result will be used as the result of the handler.

Create a single parser which will attempt to run each of the given parsers in parallel, yielding the result from the first of the parsers that successfully completes. If multiple parsers return a result for the same input, priority is determined by their order when given to this method. If all of the parsers fail by throwing exceptions, all but the latest exception will be swallowed, and the last exception will be rethrown.

Creates a parser which always results in value.

Create a parser which runs the side-effecting function f for each input it receives, yielding a Unit result.

Creates a parser that builds a cats.data.Chain from the inputs it receives.

Creates a parser that builds a List from the inputs it receives.

Creates a parser that builds a Map from the (key, value) tuple inputs it receives.

Adds followedBy and followedByStream to Parser (they aren't defined in the Parser trait due to the In type needing to be invariant here)

Applicative for Parser with a fixed In type.