the.parsatron — org.clojars.quoll/parsatron 0.0.9

>> clj/s macro

(>> m)

(>> m n)

(>> m n & ms)

Expands into nested nxt forms

always clj/s

(always x)

A parser that always succeeds with the value given and consumes no input

any-char clj/s

(any-char)

Consume any character

attempt clj/s

(attempt p)

A parser that will attempt to parse p, and upon failure never consume any input

between clj/s

(between open close p)

Parse p after parsing open and before parsing close, returning the value of p and discarding the values of open and close

bind clj/s

(bind p f)

Parse p, and then q. The function f must be of one argument, it will be given the value of p and must return the q to follow p

ch clj/s

(ch c)

Consume the given character

ch? clj/s≠

clj

cljs

(ch? x)

Test for a single-character string. ClojureScript doesn't support a character type, so we pretend it does

choice clj/s

(choice & parsers)

A varargs version of either that tries each given parser in turn, returning the value of the first one that succeeds

Continue cljs

defparser clj/s macro

(defparser name args & body)

Defines a new parser. Parsers are simply functions that accept the 5 arguments state, cok, cerr, eok, eerr but this macro takes care of writing that ceremony for you and wraps the body in a >>

digit clj/s

(digit)

Consume a digit [0-9] character

digit? clj/s

(digit? c)

Tests if a character is a digit: [0-9]

either clj/s

(either p q)

A parser that tries p, upon success, returning its value, and upon failure (if no input was consumed) tries to parse q

eof clj/s

(eof)

A parser to detect the end of input. If there is nothing more to consume from the underlying input, this parser suceeds with a nil value, otherwise it fails

Err cljs

examine clj/s

(examine)

Return the Parser's current state

expect-error clj/s

(expect-error msg pos)

extract clj/s

(extract f)

Extract information from the Parser's current state. f should be a fn of one argument, the parser's current state, and any value that it deems worthy of returning will be returned by the entire parser. No input is consumed by this parser, and the state itself is not altered.

inc-sourcepos clj/s

(inc-sourcepos {:keys [line column]} c)

Increment the source position by a single character, c. On newline, increments the SourcePos's line number and resets the column, on all other characters, increments the column

InputState cljs

let->> clj/s macro

(let->> [& bindings] & body)

Expands into nested bind forms

letter clj/s

(letter)

Consume a letter [a-zA-Z] character

letter? clj/s

(letter? c)

Tests if a character is a letter: [a-zA-Z]

lineno clj/s

(lineno)

A parser that returns the current line number. It consumes no input

lookahead clj/s

(lookahead p)

A parser that upon success consumes no input, but returns what was parsed

many clj/s

(many p)

Consume zero or more p. A RuntimeException will be thrown if this combinator is applied to a parser that accepts the empty string, as that would cause the parser to loop forever

many1 clj/s

(many1 p)

Consume 1 or more p

merge-errors clj/s

(merge-errors {:keys [pos] :as err} other-err)

never clj/s

(never)

A parser that always fails, consuming no input

nxt clj/s

(nxt p q)

Parse p and then q, returning q's value and discarding p's

Ok cljs

parsatron-poline clj/s

(parsatron-poline f & args)

A trampoline for executing potentially stack-blowing recursive functions without running out of stack space. This particular trampoline differs from clojure.core/trampoline by requiring continuations to be wrapped in a Continue record. Will loop until the value is no longer a Continue record, returning that.

ParseError cljs

run clj/s

(run p input)

Run a parser p over some input. The input can be a string or a seq of tokens, if the parser produces an error, its message is wrapped in a RuntimeException and thrown, and if the parser succeeds, its value is returned

run-parser clj/s

(run-parser p state)

Execute a parser p, given some state, Returns Ok or Err

sequentially clj/s

(sequentially f value)

ShowableError clj/s≠ protocol

show-error clj/s

(show-error this)

SourcePos cljs

string clj/s

(string s)

Consume the given string

times clj/s

(times n p)

Consume exactly n number of p

token clj/s

(token consume?)

Consume a single item from the head of the input if (consume? item) is not nil. This parser will fail to consume if either the consume? test returns nil or if the input is empty

unexpect-error clj/s

(unexpect-error msg pos)

unknown-error clj/s

(unknown-error {:keys [pos] :as state})