The number of columns to advance for a tab character.
By default, a tab takes four columns.

Positional factory function for class blancas.kern.core.PError.

Positional factory function for class blancas.kern.core.PMessage.

Positional factory function for class blancas.kern.core.PPosition.

Positional factory function for class blancas.kern.core.PState.

Parses p; if successful, it applies f to the value parsed by p.

Applies one or more parsers; collects the results in a
vector, including nil values. If any parser fails, it
stops immediately and fails.

Applies one or more parsers stopping at the first failure.
Flattens the result and converts it to a string.

Parses p; on failure it pretends it did not consume any input.

Parses p followed by q; keeps p, skips q. If more parsers are
given, it keeps the first result and skips the rest.

If parser p fails consuming no input, it replaces any Expecting
errors with a single Expecting with message msg. This helps to
produce more abstract and accurate error messages.

Tries p; if it fails without consuming any input, it tries q.
With more parsers, it will stop and succeed if a parser succeeds;
it will stop and fail if a parser fails consuming input; or it
will try the next one if a parser fails without consuming input.

Parses p followed by q; skips p, keeps q. If more parsers are
given, it skips all but last and keeps the result of the last.

Binds parser p to function f which gets p's value and returns
a new parser. Function p must define a single parameter. The
argument it receives is the value parsed by p, not ps' return
value, which is a parser state record.

Parses a letter or digit.

Succeeds with any character.

Applies open, p, close; returns the value of p.

Expands into nested >>= forms and a function body. The pattern:

(>>= p1 (fn [v1]
(>>= p2 (fn [v2]
...
  (return (f v1 v2 ...))))))

can be more conveniently be written as:

(bind [v1 p1 v2 p2 ...] (return (f v1 v2 ...)))

Returns characters from rdr as a lazy sequence.
rdr must implement java.io.Reader

Sets the parser state as not empty. Needed in compound parsers
where optional parsers at the end may leave an incorrect :empty
state for the parser as a whole.

Parses a decimal integer delimited by any character that
is not a decimal digit.

Same as def, yielding a private def.

Same as def, yielding a dynamic def.

Parses a digit.

Parses p zero or more times, separated and ended by applications
of sep; returns the results of p in a vector.

Parses p one or more times, separated and ended by applications
of sep; returns the results of p in a vector.

Succeeds on end of input.

Applies parser p; if it fails (regardless of input consumed)
it replaces any expecting errors with expecting msg. This is
similar to <?> but works even if some input was consumed.

Sets s as expecting msg.

Gets a character sequence from a file-like object.

Fails without consuming any input, having a single error
record with the passed messge msg.

Tests if s failed without consuming any input.

Parses an unquoted text field terminated by any character in cs.

Parses a simple fractional number without an exponent.
It is delimited by any character that is not a decimal
digit. It cannot start with a period; the first period
found must be followed by at least one digit.

Delays the evaluation of a parser that was forward (declare)d and
it has not been defined yet. For use in (def)s of no-arg parsers,
since the parser expression evaluates immediately.

Gets the input stream from a parser state.

Gets the position in the input stream of a parser state.

Get the user state from the parser state record.

Parses a hexadecimal digit.

Parses a hex integer delimited by any character that
is not a hex digit.

Parses a letter.

Applies p and returns the result; it consumes no input.

Parses a lower-case letter.

Parses p zero or more times; returns the result(s) in a
vector. It stops when p fails, but this parser succeeds.

Parses zero or more p while trying end, until end succeeds.
Returns the results in a vector.

Like (many) but it won't set the state to :empty. Use instead of
(many) if it comes last to avoid overriding non-empty parsing.

Parses p one or more times and returns the result(s) in a
vector. It stops when p fails, but this parser succeeds.

Factory function for class blancas.kern.core.PError, taking a map of keywords to field values.

Factory function for class blancas.kern.core.PMessage, taking a map of keywords to field values.

Factory function for class blancas.kern.core.PPosition, taking a map of keywords to field values.

Factory function for class blancas.kern.core.PState, taking a map of keywords to field values.

Succeeds with a punctuation mark.

Tests if x is a member of coll.

Modify the user state with the result of f, which takes the old
user state plus any additional arguments.

Succeeds on a new line.

Succeeds if the next character is not in the supplied string.

Succeeds only if p fails; consumes no input.

Parses an octal digit.

Parses an octal integer delimited by any character that
is not an octal digit.

Succeeds if the next character is in the supplied string.

Applies p; if it fails without consuming input, it returns a
parser state record with the :value x as default.

Succeeds if p succeeds or if p fails without consuming input.

Parses a character sequence; takes an optional label and a user
state initial value, which default to nil. Returns a PState record.

cs    A seqable object; parse calls (seq) on this value.
src   Identifies the source of the text, e.g. a filename.
us    Initializes a field that is maintained by client code.

Works like (parse) but with error diagnostics disabled for
better performance. It's intended for data that can be
assumed to be correct or its diagnosis postponed.

Works like (parse-file) but with error diagnostics disabled for
better performance. It's intended for data files that can be
assumed to be correct or its diagnosis postponed.

Parses a file; takes an optional encoding and user state,
which default to utf-8 and nil. Returns a PState record.

Applies p; if it succeeds it consumes no input.

Prints error messages in a PState record.

Put u as the new value for user state in the parser state record.

Makes s succeed with value v.

Succeeds without consuming any input. Any carried errors
are removed.

For testing parsers, e.g. at the REPL. Calls (parse) on the
arguments and prints the result. If p succeeds it prints the
parsed value; if it fails it prints any error messages.

For testing parsers, e.g. at the REPL. Works like (run) but
on success it pretty-prints the resulting parser state.

For testing, e.g. at the REPL, with input from files.
Prints the results.

For testing, e.g. at the REPL, with input from files.
Pretty-prints the results.

Succeeds if the next character satisfies the predicate pred,
in which case advances the position of the input stream. It
may fail on an unexpected end of input.

Applies a parser p, traversing the input as necessary,
until it succeeds or it reaches the end of input.

Parses p zero or more times while parsing sep in between;
collects the results of p in a vector.

Parses p one or more times while parsing sep in between;
collects the results of p in a vector.

Parses p zero or more times separated, and optionally ended by sep;
collects the results in a vector.

Parses p one or more times separated, and optionally ended by sep;
collects the results in a vector.

Sets the input stream in a parser state.

Sets the position in the input stream of a parser state.

Applies one or more parsers and skips the result. That is, it
returns a parser state record with a :value nil.

Parses p zero or more times and skips the results. This is
like skip but it can apply p zero, one, or many times.

Parses p one or more times and skips the results.

Skips whitespaces before parsing p.

Parses the space character.

Splits a string on whitespace.

Splits a string on one of the given characters and whitespace.
Removes empty strings from the result.

Parses a single symbol x (a character).

Parses a single symbol x (a character); not case-sensitive.

Parses the tab character.

Applies p n times; collects the results in a vector.

Parses a specific string, not necessarily delimited. If more
than one are given it will try each choice in turn.

Parses a specific string, not necessarily delimited; not
case-sensitive. If more than one are given it will try
each choice in turn.

Sets s as failed because an unexpected reason.

Sets s as failed because of an unexpected input.

Parses an upper-case letter.

Calls (parse) on the arguments and returns the actual parsed
value, not the PState record.

Parses a whitespace character.

Parses a specific string, delimited by letter. If more than
one are given it will try each choice in turn.

Parses a specific string, delimited by letter; not case-sensitive.
If more than one are given it will try each choice in turn.