paco.core — com.fbeyer/paco 0.3.104

* clj/s

(* p)

Returns a parser that parses zero or more occurrances of p, and returns a collection of the return values.

This is a 'sequence expression' parser, see cat.

Similar to:

• parsec, fparsec: many

*sep-by clj/s

(*sep-by p psep)

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

Returns a parser that parses p zero or more times, separated by the parser psep. Returns a collection of the return values of p. The return value of psep is discarded.

When sep-may-end? is true, allows the sequence to end with psep. Otherwise, expects p to succeed after every psep.

This is a 'sequence expression' parser, see cat.

Similar to:

• parsec, fparsec: sepBy, sepEndBy

*skip clj/s

(*skip p)

Like *, but discards p's results and returns nil.

Simillar to:

• fparsec: skipMany

*skip-sep-by clj/s

(*skip-sep-by p psep)

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

Like *sep-by, but discards all results and returns nil.

Similar to:

• fparsec: skipSepBy, skipSepEndBy

*skip-until clj/s

(*skip-until p pend)

Like *until, but discards all results and returns nil.

Similar to:

• fparsec: skipManyTill

*until clj/s

(*until p pend)

(*until p pend include-end?)

Returns a parser that repeatedly applies the parser p for as long as pend fails (without changing the parser state). It returns a collection of the results returned by p.

When include-end? is true, also includes the result of pend in the returned collection.

Similar to:

• parsec, fparsec: manyTill

+ clj/s

(+ p)

Returns a parser that parses one or more occurrances of p, and returns a collection of the return values.

This is a 'sequence expression' parser, see cat.

Similar to:

• parsec, fparsec: many1

+sep-by clj/s

(+sep-by p psep)

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

Like *sep-by, but requires p to suceed at least once.

Similar to:

• parsec, fparsec: sepBy1, sepEndBy1

+skip clj/s

(+skip p)

Like +, but discards p's results and returns nil.

Simillar to:

• fparsec: skipMany1

+skip-sep-by clj/s

(+skip-sep-by p psep)

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

Like +sep-by, but discards all results and returns nil.

Similar to:

• fparsec: skipSepBy1, skipSepEndBy1

+skip-until clj/s

(+skip-until p pend)

Like +until, but discards all results and returns nil.

Similar to:

• fparsec: skipMany1Till

+until clj/s

(+until p pend)

(+until p pend include-end?)

Like *until, but requires p to succeed at least once.

Similar to:

• fparsec: many1Till

? clj/s

(? p)

(? p not-found)

Returns a parser that parses an optional occurrence of p.

When p fails without changing parser state, (? p) succeeds with nil. When p fails after changing parser state, so will (? p).

This is a 'sequence expression' parser, see cat.

Similar to:

• parsec, fparsec: option, optional

?atomic clj/s

(?atomic p)

(?atomic p not-found)

Returns a parser that applies the optional parser p. 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)

Returns a parser that applies the parsers until the first one succeeds or fails after changing the parser state.

Similar to:

• parsec, fparsec: <|>, choice

alts clj/s

(alts ps)

(alts ps label')

Like alt, but takes a sequence of parsers.

Providing a label is slightly faster, because the parser doesn't have to aggregate error messages.

• choice, choiceL (parsec, fparsec)

any-token clj/s

(any-token source reply)

This parser accepts and returns any token from the input stream.

atomic clj/s

(atomic p)

Returns a parser that behaves like p, but is atomic: When p fails after changing the parser state, backtracks to undo the change.

Similar to:

• parsec: try
• fparsec: attempt

between clj/s

(between p pdelim)

(between p popen pclose)

Returns a parser that applies the parsers popen, p and pclose in sequence and returns the result of p.

When called with two args, uses pdelim for both popen and pclose.

bind clj/s

(bind p f)

Returns a parser that first applies the parser p to the input, then calls the function f with the result value of p and finally applies the parser returned by f to the input.

Similar to:

• >>= (parsec, fparsec)

cat clj/s

(cat & ps)

Returns a parser that applies the given parsers in sequence, and returns a collection of their result values (concatenation).

This is a 'sequence expression' parser: the result of nested sequence expressions are flattened in this parser's return value. (cat p1 (cat p2 p3)) is logically equivalent to (cat p1 p2 p3).

cats clj/s

(cats ps)

Like cat, but takes a sequence of parsers.

cond clj/s

(cond p pthen pelse)

Returns a parser that first applies p. If p succeeds, applies pthen. Otherwise, when p fails without changing the parser state, applies pelse.

cond-bind clj/s

(cond-bind p then-fn pelse)

Returns a parser that first applies p. If p succeeds, applies the parser returned by calling f with the result of p. Otherwise, when p fails without changing the parser state, applies pelse.

deref clj/s

(deref ref)

Returns a parser that de-references ref on demand, allowing for recursive or mutable parsers.

Similar to:

• fparsec: createParserForwardedToRef

end clj/s

(end source reply)

The end parser only succeeds a the end of the input stream and returns nil.

Similar to:

• parsec, fparsec: eof

eps clj/s

The eps(ilon) parser accepts the empty word (i.e. it always succeeds) and returns nil.

Similar to:

• fparsec: pzero (but succeeds)

fail clj/s

(fail message)

Returns a parser that always fails with given error message.

followed-by clj/s

(followed-by p)

(followed-by p label)

EXPERIMENTAL: The difference between followed-by and peek (lookAhead) is subtle: fparsec's followedBy is an assertion and returns nothing, while lookAhead returns the wrapped parser's result. Do we need both?

Returns a parser that succeeds if p succeeds, but does not change the parser state. Returns nil.

Similar to:

• fparsec: followedBy, followedByL

force clj/s

(force d)

Returns a parser that realizes and applies a delayed parser on demand.

fwd clj/s macro

(fwd expr)

Returns a parser that applies the parser obtained by evaluating expr, delaying evaluation until it is needed.

Useful for recursive parsers, to use a parser that has been declared but not yet defined, usually in a var:

(def expr (alt digit (between (fwd expr) (char \() (char \)))))

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

index clj/s

(index source reply)

This parser returns the index of the next token in the input stream.

label clj/s

(label p label)

Returns a parser that behaves like p, but replaces errors with (expected label) when p not change the parser state.

Similar to:

• fparsec: `<?>

label-compound clj/s

(label-compound p label)

Returns a parser that behaves like (label p), but generates a "compund error" message with both the given string label and the error messages generated by p.

Similar to:

• fparsec: `<??>

lazy clj/s macro

(lazy & body)

Returns a parser that evaluates body the first time it is needed, and caches the resulting parser.

let-parser clj/s macro

(let-parser bindings & body)

Similar to let, but for parsers. The expressions in bindings must evaluate to parsers. The with parser sequentially applies these parsers to the input, and binds their result values to their binding forms. Every expression can use the preceding bindings.

Finally evaluates body with all bindings, which must yield a parser that is then applied to the input.

Expands to a chain of bind calls.

Use this to create parsers dynamically depending on the return value of a previously succeeded parser. If you don't need this functionality, consider using map instead.

let-return clj/s macro

(let-return bindings & body)

Like let-parser, but evaluates body as the resulting parser's result value, instead of expecting a final parser to apply.

The parser (let-return [x p] (f x)) is an optimised version of (let-parser [x p] (return (f x))).

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 parser p and returns the return value of calling f with the result value of p.

When multiple parsers are given, applies them in sequence and calls f with all result values. The arity of f must match the number of supplied parsers.

Similar to:

• parsec : fmap
• fparsec: |>>, pipe2, pipe3, pipe4, pipe5

max clj/s

(max p n)

Returns a parser that applies p at most n times, and returns a collection of the result values.

This is a 'sequence expression' parser, see cat.

min clj/s

(min p n)

Returns a parser that applies p n or more times, and returns a collection of the result values.

This is a 'sequence expression' parser, see cat.

not clj/s

(not p)

(not 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. Returns nil.

Similar to:

• parsec: notFollowedBy
• fparsec: notFollowedBy, notFollowedByL

not-empty clj/s

(not-empty p)

Returns a parser that behaves like p, but fails when p 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.

peek clj/s

(peek p)

Returns a parser that behaves like p, but always restores the parser state.

• lookAhead (parsec, fparsec)

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 alt or similar to eventually stop the recursion. For example:

(def parens (rec #(? (between % (char \() (char \))))))

repeat clj/s

(repeat p n)

(repeat p min max)

When called with two args, returns a parser that applies p n times.

When called with three args, returns a parser that applies p at least min times and at most max times (until it fails).

This is a 'sequence expression' parser, see cat.

Similar to:

• fparsec: parray

return clj/s

(return x)

(return p x)

With one arg, returns a parser that consumes nothing and returns x.

With two args, returns a parser that behaves like p, but returns x when p succeeds.

Similar to:

• fparsec: preturn, >>%

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)

Returns a parser that unconditionally sets the user state to x and returns swapped-in user state.

skip-any-token clj/s

(skip-any-token source reply)

This parser skips the next token from the input stream and returns nil.

swap-user-state clj/s

(swap-user-state f & args)

Returns a parser that sets ths user state to (apply f user-state args), and returns the swapped-in user state.

then clj/s

(then p)

(then p1 p2)

(then p1 p2 p3)

(then p1 p2 p3 p4 & more)

Returns a parser that applies the parsers ps in sequence and returns the result of the last one.

Similar to:

• parsec: >>
• fparsec: >>.

then-skip clj/s

(then-skip p)

(then-skip p1 p2)

(then-skip p1 p2 p3)

(then-skip p1 p2 p3 p4 & more)

Returns a parser that applies the parsers ps in sequence and returns the result of the first one.

Similar to:

• fparsec: .>>

token clj/s

(token token)

Returns a parser that accepts and returns token.

token-return clj/s

(token-return token value)

Returns a parser that expects token to come next in the input stream and returns value.

tuple clj/s

(tuple p)

(tuple p1 p2)

(tuple p1 p2 p3)

(tuple p1 p2 p3 p4 & more)

Returns a parser that applies the parsers in sequence and returns a vector of their return values.

Similar to:

• parsec: <*>
• fparsec: .>>., tuple2, tuple3, tuple4, tuple5

tuples clj/s

(tuples ps)

Returns a parser that applies the parsers ps in sequence and returns a vector of their return values.

user-state clj/s

(user-state source reply)

This parser returns the current user state.

user-state-satisfy clj/s

(user-state-satisfy pred)

Returns a parser that succeeds if pred returns logical true when called with the current user state, otherwise it fails. Returns the return value of pred.