Abstract
Abstract
feedIncrementally parses as much input
as possible, and returns another
Parser
that represents the continuation of how to parse additional
Input
. If input
enters the done state, feed
must return a
terminated Parser
, i.e. a Parser
in the done state, or in the
error state. The given input
is only guaranteed to be valid for the
duration of the method call; references to input
must not be stored.
Static
doneStatic
errorReturns a Parser
in the error state that trap
s the given parse error
.
Generated using TypeDoc
Continuation of how to parse subsequent [[Input]] tokens from a stream.
Parser
enables efficient, interruptible parsing of network protocols and data formats, without intermediate buffering.Input tokens
A
Parser
reads tokens from anInput
reader. Input tokens are modeled as primitive numbers, commonly representing Unicode code points, or raw octets. EachParser
implementation specifies the semantic type of input tokens it consumes.Parser states
A
Parser
is always in one of three states: _cont_​inue, done, or error. The cont state indicates that [[feed]] is ready to consumeInput
; the done state indicates that parsing terminated successfully, and that [[bind]] will return the parsed result; the error state indicates that parsing terminated in failure, and that [[trap]] will return the parse error.Parser
subclasses default to the cont state.Feeding input
The [[feed]] method incrementally parses as much
Input
as it can, before returning anotherParser
that represents the continuation of how to parse additionalInput
. TheInput
passed tofeed
is only guaranteed to be valid for the duration of the method call; references to the providedInput
instance must not be stored.Parser results
A
Parser
produces a parsed result of typeO
, obtained via the [[bind]] method.bind
is only guaranteed to return a result when in the done state; thoughbind
may optionally make available partial results in other states. A failedParser
provides a parse error via the [[trap]] method.trap
is only guaranteed to return an error when in the error state.Continuations
A
Parser
instance represents a continuation of how to parse remainingInput
. Rather than parsing a complete input in one go, aParser
takes anInput
chunk and returns anotherParser
instance that knows how to parse subsequentInput
chunks. This enables non-blocking, incremental parsing that can be interrupted whenever anInput
reader runs out of immediately available data. AParser
terminates by returning a continuation in either the done state, or the error state. [[Parser.done]] returns aParser
in the done state. [[Parser.error]] returns aParser
in the error state.Iteratees
Parser
is an Iteratee. Though unlike strictly functional iteratees, aParser
statefully iterates over itsInput
, rather than allocating an object for each incremental input continutaion. This internal mutability minimizes garbage collector memory pressure, without violating the functional Iteratee abstraction, provided thatfeed
logically takes exclusive ownership of itsInput
when invoked, and logically returns ownership of theInput
in a state that's consistent with the returnedParser
continuation.Immutability
A
Parser
should be immutable. Specifically, an invocation offeed
should not alter the behavior of future calls tofeed
on the sameParser
instance. AParser
should only mutate its internal state if it's essential to do so, such as for critical path performance reasons.Backtracking
feed
can internally [[Input.clone clone]] itsInput
, if it might need to backtrack. Keep in mind that, becauseInput
is only valid for the duration of a call tofeed
, input must be internally buffered if it needs to be preserved betweenfeed
invocations.Forking
The [[fork]] method passes an out-of-band condition to a
Parser
, yielding aParser
continuation whose behavior may be altered by the given condition. For example, an HTMLParser
mightfork
an inner text parser to directly parse an embedded micro format out of an HTML element, based on some out-of-band schema information. The types of conditions accepted byfork
, and their intended semantics, are implementation defined.