(index ("result" 0) ("fail" 188) ("item" 272) ("end-of-input" 532) ("bind" 742) ("satisfies" 1023) ("is" 1371) ("in" 1529) ("sequence" 1997) ("sequence*" 2289) ("char-seq" 2538) ("char-seq-match" 2787) ("char-seq-split" 2921) ("char-seq-until" 3047) ("any-of" 3172) ("all-of" 3459) ("none-of" 3746) ("none-of*" 4095) ("preceded-by" 4332) ("followed-by" 4683) ("enclosed-by" 5210) ("maybe" 5567) ("zero-or-more" 5895) ("one-or-more" 6414) ("repeated" 6859) ("skip" 6981) ("as-string" 7069) ("recursive-parser" 7209))
(def (sig (procedure "(result value)" (id result))) (p "Returns a parser which always succeeds, returning " (tt "value") " as the parse result and the untouched input as the remainder."))
(def (sig (procedure "(fail input)" (id fail))) (p "A parser which always fails."))
(def (sig (procedure "(item input)" (id item))) (p "A parser which consumes and returns the first item of " (tt "input") ", i.e. it returns that item as the parse result and the tail of " (tt "input") " as the remainder. Fails if " (tt "input") " is empty."))
(def (sig (procedure "(end-of-input input)" (id end-of-input))) (p "A parser which returns " (tt "#t") " as the parse result and the untouched " (tt "input") " as the remainder if " (tt "input") " is empty."))
(def (sig (procedure "(bind parser proc)" (id bind))) (p "Returns a parser which applies " (tt "parser") " and calls " (tt "proc") " with its parse result if it succeeds. " (tt "proc") " must return a parser which will be applied to the remainder returned by " (tt "parser") "."))
(def (sig (procedure "(satisfies condition . args)" (id satisfies))) (p "Returns a parser which consumes the next " (tt "item") " of its input and applies " (tt "condition") " to it like this: " (tt "(apply condition item args)") ". If that call returns " (tt "#f") ", the parser fails. Otherwise it succeeds and returns the item as its result."))
(def (sig (procedure "(is x)" (id is))) (p "Returns a parser which succeeds when the next " (tt "item") " of its input is " (tt "eqv?") " to " (tt "x") "."))
(def (sig (procedure "(in collection . items)" (id in))) (p "Returns a parser which succeeds when the next item of the given input is contained in " (tt "collection") ". Collection can be a " (link "http://srfi.schemers.org/srfi-14/srfi-14.html" "SRFI 14 char-set") " or a list which is checked for membership with " (tt "memq") ". Given more than one argument, membership of the next item is checked for with " (tt "memq") " in " (tt "(cons collection items)") "."))
(def (sig (procedure "(sequence parser . parsers)" (id sequence))) (p "Returns a parser which applies the given parsers from left to right and returns the list of their results when all succeed. See also the " (int-link "#a-note-on-variadic-combinators" "note on variadic combinators") "."))
(def (sig (syntax "(sequence* ((binding parser) ...) body ...)" (id sequence*))) (p "Similar to " (tt "let*") " but the bindings are made to the results of a sequence of parsers.  Body should use a " (tt "result") " form to yield a parse result."))
(def (sig (procedure "(char-seq str)" (id char-seq))) (p "Returns a parser which consumes the chars of the given string " (tt "str") " in the order contained therein, i.e. it parses a literal string. On success the parser returns " (tt "str") "."))
(def (sig (procedure "(char-seq-match rx)" (id char-seq-match))) (p "Returns a parser which matches an irregex regular expression."))
(def (sig (procedure "(char-seq-split str #!optional allow-end-of-input?)" (id char-seq-split))) (p "To-do: document this."))
(def (sig (procedure "(char-seq-until cs #!optional allow-end-of-input?)" (id char-seq-until))) (p "To-do: document this."))
(def (sig (procedure "(any-of parser . parsers)" (id any-of))) (p "Returns a parser which applies the given parsers from left to right and returns the result of the first one that succeeds. See also the " (int-link "#a-note-on-variadic-combinators" "note on variadic combinators") "."))
(def (sig (procedure "(all-of parser . parsers)" (id all-of))) (p "Returns a parser which applies the given parsers from left to right and returns the result of the last one if all succeed. See also the " (int-link "#a-note-on-variadic-combinators" "note on variadic combinators") "."))
(def (sig (procedure "(none-of parser . parsers)" (id none-of))) (p "Returns a parser which applies the given parsers from left to right and returns " (tt "#t") " as its result if none of them succeed while it doesn't consume any items from the input. See also the " (int-link "#a-note-on-variadic-combinators" "note on variadic combinators") "."))
(def (sig (procedure "(none-of* parser [parsers ...] but)" (id none-of*))) (p "Returns a parser which applies the given parsers from left to right. If none of them succeed, it applies the parser " (tt "but") " and returns its result."))
(def (sig (procedure "(preceded-by parser . parsers)" (id preceded-by))) (p "Returns a parser which applies the given parsers from left to right to the input or the remainder of the preceding parser, respectively, and returns the result of the last one. See also the " (int-link "#a-note-on-variadic-combinators" "note on variadic combinators") "."))
(def (sig (procedure "(followed-by parser following-parser . following-parsers)" (id followed-by))) (p "Returns a parser which applies " (tt "parser") " if the given " (tt "following-parser[s]") " succeed on its remainder from left to right. Note that the " (tt "following-parsers") " don't consume any input, i.e. they only perform a look-ahead.") (p "See also the " (int-link "#a-note-on-variadic-combinators" "note on variadic combinators") " which applies to the " (tt "following-parser[s]") " argument(s) in this case."))
(def (sig (procedure "(enclosed-by open content close)" (id enclosed-by))) (p "Returns a parser which applies the given parsers " (tt "open") ", " (tt "content") ", and " (tt "close") " in that order to the input or the remainder of the preceding parser, respectively, and returns the result of " (tt "content") " with the remainder of " (tt "close") "."))
(def (sig (procedure "(maybe parser #!optional default)" (id maybe))) (p "Returns a parser which applies " (tt "parser") " to the input and returns its result and remainder if it succeeds. Otherwise it returns " (tt "default") " or " (tt "#f") " if not specified as the parse result and the untouched input as the remainder."))
(def (sig (procedure "(zero-or-more parser)" (id zero-or-more))) (p "Returns a parser which applies " (tt "parser") " to its input. If that fails, it returns " (tt "()") " as the parse result and the untouched input as the remainder. Otherwise it applies " (tt "parser") " again to the remainder of the previous application and so forth, collecting all parse result in a list. That list is then returned as the parse result and the remainder of the last successful application of " (tt "parser") " as the remainder."))
(def (sig (procedure "(one-or-more parser)" (id one-or-more))) (p "Returns a parser which applies " (tt "parser") " to its input. If that fails, it also fails. Otherwise it applies " (tt "parser") " again to the remainder of the previous application and so forth, collecting all parse result in a list. That list is then returned as the parse result and the remainder of the last successful application of " (tt "parser") " as the remainder."))
(def (sig (procedure "(repeated parser #!rest args #!key (min 0) max until)" (id repeated))) (p "To-do: document this."))
(def (sig (procedure "(skip parser . parsers)" (id skip))) (p "To-do: document this."))
(def (sig (procedure "(as-string parser)" (id as-string))) (p "Returns a parser that turns the result of the given parser into a string."))
(def (sig (syntax "(recursive-parser body ...)" (id recursive-parser))) (p "To-do: document this."))
