(index ("macro-helpers" 0) ("symbol-dispatcher" 159) ("bind-exception" 321) ("add-prefix" 552) ("prefixed-with?" 648) ("strip-prefix" 792) ("strip-suffix" 910) ("extract" 1028) ("remove-duplicates" 1166) ("adjoin" 1289) ("memp" 1401) ("assp" 1522) ("replace*" 1623) ("map*" 1755) ("flatten" 1852) ("flatten-map*" 1960) ("filter" 2085) ("mappend" 2226) ("plist?" 2341) ("pnull?" 2431) ("plength" 2547) ("plist-ref" 2727) ("plist-tail" 2885) ("seq-length" 3059) ("seq-ref" 3217) ("seq-tail" 3373) ("seq-length-ref-tail!" 3542) ("vector-tail" 3773) ("list-of" 3894) ("atom?" 4019) ("list-destruc" 4101) ("seq-destruc" 4398) ("dbind-ex" 4556) ("dbind-lit" 4781) ("dbind-len" 4965) ("dbind-def" 5176) ("low-level-macros" 5413) ("list-bind" 5603) ("list-bind-case" 5945) ("define-er-macro" 6422) ("define-macro" 6704) ("define-macro" 6704) ("define-macro" 6704) ("define-macro" 6704) ("let-macro" 7265) ("letre-macro" 7528) ("macro-rules" 7797) ("once-only" 8247) ("with-gensyms" 8452) ("define-syntax-rule" 8633) ("define-syntax-rule" 8633))
(def (sig (procedure "(macro-helpers [sym])" (id macro-helpers))) (p "shows which symbols are exported, if called with no argument, or sym's documentation."))
(def (sig (procedure "(symbol-dispatcher alist)" (id symbol-dispatcher))) (p "creates a documentation procedure as used by macro-helpers and low-level-macros."))
(def (sig (procedure "(bind-exception loc msg . args)" (id bind-exception))) (p "generates a composite condition of type (exn bind) with location loc, message msg and arguments args. Imported and reexported by low-level-macros."))
(def (sig (procedure "(add-prefix pref id)" (id add-prefix))) (p "adds a prefix to a symbol."))
(def (sig (procedure "(prefixed-with? pre)" (id prefixed-with?))) (p "returns a predicate, which checks, if pre is a prefix of its argument."))
(def (sig (procedure "(strip-prefix pre id)" (id strip-prefix))) (p "strips the prefix pre from the identifier id."))
(def (sig (procedure "(strip-suffix suf id)" (id strip-suffix))) (p "strips the suffix suf from the identifier id."))
(def (sig (procedure "(extract ok? tree)" (id extract))) (p "returns a flat list of all the symbols in a tree which pass the ok? test."))
(def (sig (procedure "(remove-duplicates lst)" (id remove-duplicates))) (p "returns a sublist of lst with dups removed."))
(def (sig (procedure "(adjoin obj lst)" (id adjoin))) (p "conses obj to lst provided it isn't already there."))
(def (sig (procedure "(memp ok? lst)" (id memp))) (p "returns the tail of lst, whose car passes ok?, or #f otherwise."))
(def (sig (procedure "(assp ok? tbl)" (id assp))) (p "returns the table item whose car passes ok?"))
(def (sig (procedure "(replace* what? by tree)" (id replace*))) (p "substitutes each old with (what? old) by (by old) in a tree."))
(def (sig (procedure "(map* fn . trees)" (id map*))) (p "tree-version of map. Returns a tree."))
(def (sig (procedure "(flatten tree)" (id flatten))) (p "returns a flat list with all the items of tree."))
(def (sig (procedure "(flatten-map* fn . trees)" (id flatten-map*))) (p "combination of flatten and map*. Returns a list."))
(def (sig (procedure "(filter ok? lst)" (id filter))) (p "returns two sublists of lst where each item passes ok? or not ok? respectively."))
(def (sig (procedure " (mappend fn lists)" (id mappend))) (p "combination of map and append, i.e. mapcan in CL."))
(def (sig (procedure "(plist? xpr)" (id plist?))) (p "is xpr a pseudolist? Allways #t."))
(def (sig (procedure "(pnull? xpr)" (id pnull?))) (p "is xpr a null? pseudolist? For example (pnull? 1) is true."))
(def (sig (procedure "(plength pl)" (id plength))) (p "returns the length of a pseudolist. For example (plength 1) is 0. Imported for-syntax and reexported by low-level-macros."))
(def (sig (procedure "(plist-ref pl k)" (id plist-ref))) (p "returns the kth item of a pseudolist. Imported for-syntax and reexported by low-level-macros."))
(def (sig (procedure "(plist-tail pl k)" (id plist-tail))) (p "returns the tail, starting from k, of a pseudolist. Imported for-syntax and reexported by low-level-macros."))
(def (sig (procedure "(seq-length seq)" (id seq-length))) (p "returns the length of the generic sequence seq, presently a string, vector or (pseudo-)list."))
(def (sig (procedure "(seq-ref seq n)" (id seq-ref))) (p "returns the nth item of the generic sequence seq, presently a string, vector or (pseudo-)list."))
(def (sig (procedure "(seq-tail seq n)" (id seq-tail))) (p "returns the tail of the generic sequence seq, presently a string, vector or (pseudo-)list, starting at n."))
(def (sig (procedure "(seq-length-ref-tail! type? type-length type-ref type-tail)" (id seq-length-ref-tail!))) (p "updates the local tables of seq-length, seq-ref and seq-tail in one go by adding appropriate pairs to its front."))
(def (sig (procedure "(vector-tail vec k)" (id vector-tail))) (p "returns the subvector of vec starting with index k."))
(def (sig (procedure "(list-of ok?)" (id list-of))) (p "returns a predicate which checks, if its list argument passes ok?"))
(def (sig (procedure "(atom? xpr)" (id atom?))) (p "same as (not (pair? xpr))."))
(def (sig (procedure "(list-destruc pat seq)" (id list-destruc))) (p "helper, which does most of the work to destructure seq according to the pattern pat, a nested pseudolist of symbols and non-symbol literals. Returns three lists, to be used by dbind-ex, dbind-lit and dbind-len respectively."))
(def (sig (procedure "(seq-destruc pat seq)" (id seq-destruc))) (p "same as list-destruc, but destructures generic sequences. Used in the bindings module."))
(def (sig (procedure "(dbind-ex symbols body)" (id dbind-ex))) (p "where body is a list starting with a fender expression and symbols is the first returned value of list- or seq-destruc. Generates a nested let expression."))
(def (sig (procedure "(dbind-lit literals)" (id dbind-lit))) (p "where literals is the second returned value of list- or seq-destruc. Generates code which checks if literals match."))
(def (sig (procedure "(dbind-len length-checks)" (id dbind-len))) (p "where length-checks is the third returned value of list- or seq-destruc. Generates code which checks if pat and seq are matchable at all."))
(def (sig (procedure "(dbind-def op symbols)" (id dbind-def))) (p "where op is either 'set! or 'define and symbols is the first returned value of list- or seq-destruc. Returns code for bind-define or bind-set! in the bindings module."))
(def (sig (procedure "(low-level-macros sym ..)" (id low-level-macros))) (p "returns a list of all the exported symbols of the module, if called with no argument, or sym's documentation."))
(def (sig (syntax "(list-bind pat seq (where . fenders) .. xpr ....)" (id list-bind))) (p "binds pattern variables of pat to subexpressions of seq and executes xpr ....  in this context, provided all fenders return #t, if supplied.") (p "Note, that non-symbol literals are accepted in pat and seq and considered a match if they are equal."))
(def (sig (syntax "(list-bind-case seq clause ....)" (id list-bind-case))) (p "where seq is a nested pseudolist expression and each clause is of one of two forms") (highlight scheme "(pat (where . fenders) xpr ....)\n(pat xpr ....)") (p "Matches seq against a series of patterns and executes the body of the first matching pattern satisfying fenders (if given).") (p "Note, that non-symbol literals are accepted in seq and each pat and considered a match if they are equal."))
(def (sig (syntax "(define-er-macro (name . args) (rename-prefix pre) . body)" (id define-er-macro))) (p "where body can start with an optional (keywords key ...) clause.") (p "Defines an explicit-renaming macro by renaming every symbol in the body which starts with prefix pre."))
(def (sig (syntax "(define-macro (name . args) xpr ....))" (id define-macro)) (syntax "(define-macro (name . args) (inject sym ...) xpr ....))" (id define-macro)) (syntax "(define-macro (name . args) (inject sym ...) (keywords key ...) xpr ....))" (id define-macro)) (syntax "(define-macro (name . args) (keywords key ...) (inject sym ...) xpr ....))" (id define-macro))) (p "generates an implicit-renaming macro, name. Keywords and injected symbols are extracted from the macro body and transformed into appropriate subexpressions of the macro-transformer."))
(def (sig (syntax "(let-macro ((code . body) ....) xpr ....)" (id let-macro))) (p "where (code . body) ....  are as in define-macro.") (p "This is a local version of define-macro, allowing a list of (code . body) lists to be processed in xpr .... in parallel."))
(def (sig (syntax "(letre-macro ((code0 . body) ....) xpr ....)" (id letre-macro))) (p "where (code0 . body) ....  are as in define-macro.") (p "This is a local version of define-macro, allowing a list of (code . body) lists to be processed in xpr .... recursively."))
(def (sig (syntax "(macro-rules sym ... (keyword ...) (pat (where . fenders) .. tpl) ....)" (id macro-rules))) (p "like syntax-rules, but the templates are usually quasiquote-expressions. Moreover, the symbols sym ... are injected, if there are any.") (p "Note, that non-symbol literals are accepted in  each pat and considered a match if they are equal to a corresponding literal in the macro-code.") (p "macro-rules must be imported for-syntax."))
(def (sig (syntax "(once-only (x ...) . body)" (id once-only))) (p "to be used in a macro-body to avoid side-effects. The arguments x ... are only evaluated once. once-only must be imported for-syntax."))
(def (sig (syntax "(with-gensyms (x ...) . body)" (id with-gensyms))) (p "to be used in a macro body. Generates a list of gensyms x ... with-gensyms must be imported for-syntax."))
(def (sig (syntax "(define-syntax-rule (name . args) tpl)" (id define-syntax-rule)) (syntax "(define-syntax-rule (name . args) (with-keywords (x ...) tpl))" (id define-syntax-rule))) (p "the only high-level macro. To be used instead of syntax-rules in case there is only one rule and no additional keywords."))
