This is the easy-bind Reference Manual, version 1.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Feb 26 16:20:12 2024 GMT+0.
The main system appears first, followed by any subsystem dependency.
easy-bindEasy-bind - easy local binding for Common Lisp
Marius Gaarde
MIT
1.0
easy-bind-package.lisp (file).
easy-bind-main.lisp (file).
letmatch.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
easy-bind/easy-bind.asdeasy-bind/easy-bind-package.lispeasy-bind/easy-bind-main.lispeasy-bind/letmatch.lispeasy-bind/easy-bind-main.lispeasy-bind-package.lisp (file).
easy-bind (system).
all-keyword-p (function).
collect-binding-list (function).
collect-let+-complex-bindings (function).
complex-left-hand-side-p (function).
equals-sign-or-being-p (function).
equals-sign-p (function).
function-binding-p (function).
function-bindings-splice-implicit-progn (function).
function-keyword-p (function).
generate-function-binding-list (function).
generate-let*s-and-complex-bindings (function).
generate-let*s-and-function-bindings (function).
generate-let*s-and-labels (function).
generate-let*s-and-macrolets (function).
generate-let*s-and-multiple-value-binds (function).
generate-let+-expansion (function).
generate-let-binding-list (function).
generate-symbol-macrolet-bindings (function).
let+-collect-function-bindings (function).
macro-binding-p (function).
macro-keyword-p (function).
make-function-binding (function).
multiple-of (function).
parse-separated-list (function).
simple-left-hand-side-p (function).
simple-or-complex-left-hand-side-p (function).
single-splice-implicit-progn (function).
sym-keyword-p (function).
values-keyword-p (function).
easy-bind/letmatch.lispeasy-bind-main.lisp (file).
easy-bind (system).
letmatch (macro).
consequent-sign-p (function).
ignorablep (function).
letmatch-body-check-wellformedness (function).
map-leaves (function).
matches (function).
nmap-leaves (function).
splice-implicit-progn (function).
Packages are listed by definition order.
edraag.easy-bindeasy-bind
eb
common-lisp.
all-keyword-p (function).
collect-binding-list (function).
collect-let+-complex-bindings (function).
complex-left-hand-side-p (function).
consequent-sign-p (function).
equals-sign-or-being-p (function).
equals-sign-p (function).
function-binding-p (function).
function-bindings-splice-implicit-progn (function).
function-keyword-p (function).
generate-function-binding-list (function).
generate-let*s-and-complex-bindings (function).
generate-let*s-and-function-bindings (function).
generate-let*s-and-labels (function).
generate-let*s-and-macrolets (function).
generate-let*s-and-multiple-value-binds (function).
generate-let+-expansion (function).
generate-let-binding-list (function).
generate-symbol-macrolet-bindings (function).
ignorablep (function).
let+-collect-function-bindings (function).
letmatch-body-check-wellformedness (function).
macro-binding-p (function).
macro-keyword-p (function).
make-function-binding (function).
map-leaves (function).
matches (function).
multiple-of (function).
nmap-leaves (function).
parse-separated-list (function).
simple-left-hand-side-p (function).
simple-or-complex-left-hand-side-p (function).
single-splice-implicit-progn (function).
splice-implicit-progn (function).
sym-keyword-p (function).
values-keyword-p (function).
Definitions are sorted by export status, category, package, and then by lexicographic order.
Conditional form of let+ which expands into a cond form where the test-forms are calls to ‘matches’ to check if the structure of each binding-list in the body matches that of key-expr. The body should consist of pairs of binding-lists and forms separated by a fat-arrow (=>). The first binding-list that matches is bound to key-expr in a let+ form (at runtime), its right-hand form becoming the body of the let+ form.
Takes a list ((a b) (c d) ...) and collects elems (x y) into new list only as long as a, c, ... satisfies predicate.
Complex-binding-collector to be passed to generate-let*s-and-complex-bindings when generating a let+-style binding form. As such it returns 3 values: a form-name (symbol), a binding list, and the number of binding pairs from the passed-in binding list it lays claim to. It may also returned a 4th value T to indicate that the returned binding list should be spliced into the generated form.
Generates a LET* form as long as it can collect simple bindings, and complex
bindings into a form or forms determined by complex-binding-collector, alternately
nested until binding list exhausted, at which point body is spliced into the
innermost form. Recognizes the :all keyword and handles bindings accordingly.
Complex-binding-collector must be a function which takes the binding list as argument and returns 3 values: 1) a form-name (a symbol), 2) a list of bindings to give to the form, 3) the number of successive bindings it lays claim to from the passed-in binding list. It may also return a 4th value: whether (default nil) to splice the returned binding list into the generated form.
Used to create a form-generator for generating nested let* and <form-name> forms. Form-name must be a symbol which names a CL form that expects function-like bindings, such as labels or macrolet.
Used to collect binding pairs where the first element is a list which begins with a keyword like :fun or :macro, and transforming these to bindings which can be used by forms like labels and macrolet. Collects bindings only as long as they satisfy predicate.
Transforms binding ((fn x y) (do-stuff x y)) => (fn (x y) (do-stuff x y)).
Finds the leaves of the tree and conses up a similar tree where the leaves are replaced according to replacement-fn, but only if they satisfy predicate.
Implements the rules for matching a left-hand side (x) to a given key-expression (y) in a letmatch form.
Non-consing version of map-leaves. Returns nil, or the result of applying action if tree is an atom and satisfies predicate.
Parses the forms only as long as pairs of forms are joined according to separator-predicate, like so: (a1 <separator> a2 b1 <separator> b2 ...), and a1, b1... satisfies left-hand-side-predicate. Returns 2 values: 1) a list ((a1 a2) (b1 b2) ...), 2) the number of forms processed, including separators.
Removes the outer list surrounding the ‘implicit progn’ of a function-binding right-hand side (body).
Remove outer list around right-hand sides of arguments to letmatch.
| Jump to: | A C D E F G I L M N P S V W |
|---|
| Jump to: | A C D E F G I L M N P S V W |
|---|
| Jump to: | E F L P S |
|---|
| Jump to: | E F L P S |
|---|