paco.core — com.fbeyer/paco 0.2.97

* clj/s

(* p)

Zero or more.

*sep-by clj/s

(*sep-by p psep)

(*sep-by p psep end?)

*skip clj/s

(*skip p)

*skip-sep-by clj/s

(*skip-sep-by p psep)

(*skip-sep-by p psep end?)

*skip-until clj/s

(*skip-until p pend)

*until clj/s

(*until p pend)

(*until p pend include-end?)

+ clj/s

(+ p)

One or more.

+sep-by clj/s

(+sep-by p psep)

(+sep-by p psep end?)

+skip clj/s

(+skip p)

+skip-sep-by clj/s

(+skip-sep-by p psep)

(+skip-sep-by p psep end?)

+skip-until clj/s

(+skip-until p pend)

+until clj/s

(+until p pend)

(+until p pend include-end?)

? clj/s

(? p)

(? p not-found)

Optional: zero or one.

?atomic clj/s

(?atomic p)

(?atomic p not-found)

Returns a parser that applies p and if p fails, backtracks to the original state and succeeds with value not-found (default: nil).

(?atomic p) is an optimized implementation of (? (atomic p)).

alt clj/s

(alt p1)

(alt p1 p2)

(alt p1 p2 p3)

(alt p1 p2 p3 & more)

alts clj/s

(alts ps)

(alts ps label')

any-token clj/s

(any-token source reply)

atomic clj/s

(atomic p)

Returns a parser that behaves like p, except that it backtracks to the original parser state when p fails with changing the parser state.

between clj/s

(between p psurround)

(between p popen pclose)

bind clj/s

(bind p f)

cat clj/s

(cat & ps)

cat* clj/s

(cat* ps)

deref clj/s

(deref ref)

Returns a parser that forwards all calls to the parser returned by @ref. Useful to construct recursive parsers.

end clj/s

(end source reply)

This parser succeeds a the end of the input stream.

fail clj/s

(fail message)

followed-by clj/s

(followed-by p)

(followed-by p label)

Returns a parser that succeeds if it is followed by p, e.g. if p succeeds next. Does not change the parser state.

fwd clj/s macro

(fwd expr)

Returns a parser that forwards to expr. Useful for recursive parsers to use a parser that has been declared but not yet defined:

(def expr (p/alt c/digit
                 (p/between (p/fwd expr) (c/char \() (c/char \)))))

Warning: Left-recursive parsers are not supported and will lead to infinite loops / stack overflows.

index clj/s

(index source reply)

Returns the index of the next token in the input stream.

label clj/s

(label p label)

If p does not change the parser state, the errors are replaced with `(expected label).

label-compound clj/s

(label-compound p label)

lazy clj/s macro

(lazy & body)

look-ahead clj/s

(look-ahead p)

map clj/s

(map p f)

(map p1 p2 f)

(map p1 p2 p3 f)

(map p1 p2 p3 p4 & more)

Returns a parser that applies the provided parsers in sequence and returns the return value of calling f with the return values.

max clj/s

(max p n)

min clj/s

(min p n)

not-empty clj/s

(not-empty p)

Like p, but fails when p does not change the parser state.

not-followed-by clj/s

(not-followed-by p)

(not-followed-by p label)

Returns a parser that succeeds if the parser p fails, and fails otherwise. In both cases, it does not change the parser state.

parse clj/s

(parse p input & {:as opts})

Applies the parser p to input and returns its result value. Throws an exception when p fails.

pforce clj/s

(pforce d)

Returns a parser that forwards to (force d).

pnil clj/s

This parser always succeeds and returns nil.

pos clj/s

(pos source reply)

Returns the current position in the input stream.

rec clj/s

(rec f)

Creates a recursive parser. Calls f with one arg, a parser to recur, and returns the parser returned by f.

It is assumed that f uses p/alt or similar to eventually stop the recursion.

repeat clj/s

(repeat p n)

(repeat p min max)

return clj/s

(return x)

(return p x)

run clj/s

(run p input & {:as opts})

Applies the parser p to input and returns a map representing the parser result.

set-user-state clj/s

(set-user-state u)

Sets the user source to u.

skip-any-token clj/s

(skip-any-token source reply)

swap-user-state clj/s

(swap-user-state f & args)

Sets ths user source to (apply f user-state args).

then clj/s

(then p)

(then p1 p2)

(then p1 p2 p3)

(then p1 p2 p3 p4 & more)

Applies the parsers in sequence and returns the result of the last one.

then-skip clj/s

(then-skip p)

(then-skip p1 p2)

(then-skip p1 p2 p3)

(then-skip p1 p2 p3 p4 & more)

Applies the parsers in sequence and returns the result of the first one.

token clj/s

(token token)

token-return clj/s

(token-return token value)

tuple clj/s

(tuple p)

(tuple p1 p2)

(tuple p1 p2 p3)

(tuple p1 p2 p3 p4 & more)

tuple* clj/s

(tuple* ps)

Applies the parsers ps in sequence and returns a vector of their return values.

user-state clj/s

(user-state source reply)

Returns the current user state.

user-state-satisfy clj/s

(user-state-satisfy pred)

Succeeds if pred returns logical true when called with the current user source, otherwise it fails. Returns the return value of pred.

with clj/s macro

(with bindings & body)