This is the generic-cl Reference Manual, version 1.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Dec 15 06:16:40 2024 GMT+0.
generic-cl/srcgeneric-cl.comparison/src/comparisongeneric-cl.internal/src/internalgeneric-cl.object/src/objectgeneric-cl.arithmetic/src/arithmeticgeneric-cl.container/src/containergeneric-cl.iterator/src/iteratorgeneric-cl.collector/src/collectorgeneric-cl.sequence/src/sequencegeneric-cl.map/src/mapgeneric-cl.set/src/setgeneric-cl.lazy-seq/src/lazy-seqgeneric-cl.math/src/mathgeneric-cl/generic-cl.asdgeneric-cl.comparison/generic-cl.comparison.asdgeneric-cl.internal/generic-cl.internal.asdgeneric-cl.object/generic-cl.object.asdgeneric-cl.arithmetic/generic-cl.arithmetic.asdgeneric-cl.container/generic-cl.container.asdgeneric-cl.iterator/generic-cl.iterator.asdgeneric-cl.collector/generic-cl.collector.asdgeneric-cl.sequence/generic-cl.sequence.asdgeneric-cl.map/generic-cl.map.asdgeneric-cl.set/generic-cl.set.asdgeneric-cl.lazy-seq/generic-cl.lazy-seq.asdgeneric-cl.math/generic-cl.math.asdgeneric-cl/src/package.lispgeneric-cl.comparison/src/comparison/package.lispgeneric-cl.comparison/src/comparison/equality.lispgeneric-cl.comparison/src/comparison/comparison.lispgeneric-cl.internal/src/internal/package.lispgeneric-cl.internal/src/internal/util.lispgeneric-cl.object/src/object/package.lispgeneric-cl.object/src/object/object.lispgeneric-cl.object/src/object/misc.lispgeneric-cl.arithmetic/src/arithmetic/package.lispgeneric-cl.arithmetic/src/arithmetic/arithmetic.lispgeneric-cl.container/src/container/package.lispgeneric-cl.container/src/container/container.lispgeneric-cl.container/src/container/cl-containers.lispgeneric-cl.iterator/src/iterator/package.lispgeneric-cl.iterator/src/iterator/iterator.lispgeneric-cl.iterator/src/iterator/util.lispgeneric-cl.iterator/src/iterator/doseq.lispgeneric-cl.iterator/src/iterator/expanders.lispgeneric-cl.collector/src/collector/package.lispgeneric-cl.collector/src/collector/collector.lispgeneric-cl.sequence/src/sequence/package.lispgeneric-cl.sequence/src/sequence/sequences.lispgeneric-cl.sequence/src/sequence/cl-sequences.lispgeneric-cl.sequence/src/sequence/generic-sequences.lispgeneric-cl.sequence/src/sequence/optimization.lispgeneric-cl.map/src/map/package.lispgeneric-cl.map/src/map/hash-tables.lispgeneric-cl.map/src/map/expanders.lispgeneric-cl.set/src/set/package.lispgeneric-cl.set/src/set/sets.lispgeneric-cl.lazy-seq/src/lazy-seq/package.lispgeneric-cl.lazy-seq/src/lazy-seq/lazy-seq.lispgeneric-cl.math/src/math/package.lispgeneric-cl.math/src/math/math.lispgeneric-cl.mapgeneric-cl.containergeneric-clgeneric-cl.setgeneric-cl.objectgeneric-cl.iteratorgeneric-cl.sequencegeneric-cl.mathgeneric-math-clgeneric-cl.internalgeneric-cl.iterator.optimizationgeneric-cl.lazy-seqgeneric-cl.arithmeticgeneric-cl.comparisongeneric-cl.collectorThe main system appears first, followed by any subsystem dependency.
generic-clgeneric-cl.comparisongeneric-cl.internalgeneric-cl.objectgeneric-cl.arithmeticgeneric-cl.containergeneric-cl.iteratorgeneric-cl.collectorgeneric-cl.sequencegeneric-cl.mapgeneric-cl.setgeneric-cl.lazy-seqgeneric-cl.mathgeneric-clStandard Common Lisp functions implemented using generic functions.
Alexander Gutev
MIT
1.0
agutil (system).
generic-cl.comparison (system).
generic-cl.object (system).
generic-cl.arithmetic (system).
generic-cl.container (system).
generic-cl.iterator (system).
generic-cl.collector (system).
generic-cl.sequence (system).
generic-cl.map (system).
generic-cl.set (system).
generic-cl.lazy-seq (system).
generic-cl.math (system).
src (module).
generic-cl.comparisonGeneric comparison interface
Alexander Gutev
MIT
1.0
alexandria (system).
static-dispatch (system).
generic-cl.internal (system).
src/comparison (module).
generic-cl.internalUtilities used internally by generic-cl
Alexander Gutev
MIT
1.0
alexandria (system).
trivia (system).
cl-form-types (system).
static-dispatch (system).
src/internal (module).
generic-cl.objectGeneric object copying and type conversion interface
Alexander Gutev
MIT
1.0
alexandria (system).
arrows (system).
static-dispatch (system).
generic-cl.comparison (system).
src/object (module).
generic-cl.arithmeticGeneric arithmetic function interface
Alexander Gutev
MIT
1.0
static-dispatch (system).
trivia (system).
generic-cl.internal (system).
generic-cl.comparison (system).
src/arithmetic (module).
generic-cl.containerGeneric container interface
Alexander Gutev
MIT
1.0
static-dispatch (system).
generic-cl.object (system).
src/container (module).
generic-cl.iteratorGeneric iterator interface
Alexander Gutev
MIT
1.0
alexandria (system).
agutil (system).
anaphora (system).
arrows (system).
trivia (system).
parse-declarations-1.0 (system).
static-dispatch (system).
cl-form-types (system).
generic-cl.internal (system).
generic-cl.object (system).
generic-cl.container (system).
src/iterator (module).
generic-cl.collectorGeneric collector interface
Alexander Gutev
MIT
1.0
alexandria (system).
anaphora (system).
arrows (system).
static-dispatch (system).
generic-cl.object (system).
generic-cl.iterator (system).
src/collector (module).
generic-cl.sequenceGeneric sequence operations
Alexander Gutev
MIT
1.0
alexandria (system).
anaphora (system).
arrows (system).
cl-custom-hash-table (system).
static-dispatch (system).
cl-form-types (system).
generic-cl.internal (system).
generic-cl.comparison (system).
generic-cl.object (system).
generic-cl.container (system).
generic-cl.iterator (system).
generic-cl.collector (system).
generic-cl.map (system).
src/sequence (module).
generic-cl.mapGeneric map and hash-table interface
Alexander Gutev
MIT
1.0
agutil (system).
anaphora (system).
alexandria (system).
arrows (system).
trivia (system).
static-dispatch (system).
cl-custom-hash-table (system).
generic-cl.internal (system).
generic-cl.comparison (system).
generic-cl.object (system).
generic-cl.container (system).
generic-cl.iterator (system).
generic-cl.collector (system).
src/map (module).
generic-cl.setGeneric set interface
Alexander Gutev
MIT
1.0
anaphora (system).
static-dispatch (system).
generic-cl.comparison (system).
generic-cl.arithmetic (system).
generic-cl.object (system).
generic-cl.container (system).
generic-cl.iterator (system).
generic-cl.collector (system).
generic-cl.sequence (system).
generic-cl.map (system).
src/set (module).
generic-cl.lazy-seqLazy sequences
Alexander Gutev
MIT
1.0
agutil (system).
arrows (system).
trivia (system).
cl-custom-hash-table (system).
static-dispatch (system).
generic-cl.comparison (system).
generic-cl.object (system).
generic-cl.container (system).
generic-cl.iterator (system).
generic-cl.collector (system).
generic-cl.sequence (system).
generic-cl.map (system).
src/lazy-seq (module).
generic-cl.mathGeneric math function interface
Alexander Gutev
MIT
1.0
agutil (system).
alexandria (system).
anaphora (system).
arrows (system).
static-dispatch (system).
trivia (system).
generic-cl.arithmetic (system).
src/math (module).
Modules are listed depth-first from the system components tree.
generic-cl/srcgeneric-cl.comparison/src/comparisongeneric-cl.internal/src/internalgeneric-cl.object/src/objectgeneric-cl.arithmetic/src/arithmeticgeneric-cl.container/src/containergeneric-cl.iterator/src/iteratorgeneric-cl.collector/src/collectorgeneric-cl.sequence/src/sequencegeneric-cl.map/src/mapgeneric-cl.set/src/setgeneric-cl.lazy-seq/src/lazy-seqgeneric-cl.math/src/mathgeneric-cl/srcgeneric-cl (system).
package.lisp (file).
generic-cl.comparison/src/comparisongeneric-cl.comparison (system).
package.lisp (file).
equality.lisp (file).
comparison.lisp (file).
generic-cl.internal/src/internalgeneric-cl.internal (system).
package.lisp (file).
util.lisp (file).
generic-cl.object/src/objectgeneric-cl.object (system).
package.lisp (file).
object.lisp (file).
misc.lisp (file).
generic-cl.arithmetic/src/arithmeticgeneric-cl.arithmetic (system).
package.lisp (file).
arithmetic.lisp (file).
generic-cl.container/src/containergeneric-cl.container (system).
package.lisp (file).
container.lisp (file).
cl-containers.lisp (file).
generic-cl.iterator/src/iteratorgeneric-cl.iterator (system).
package.lisp (file).
iterator.lisp (file).
util.lisp (file).
doseq.lisp (file).
expanders.lisp (file).
generic-cl.collector/src/collectorgeneric-cl.collector (system).
package.lisp (file).
collector.lisp (file).
generic-cl.sequence/src/sequencegeneric-cl.sequence (system).
package.lisp (file).
sequences.lisp (file).
cl-sequences.lisp (file).
generic-sequences.lisp (file).
optimization.lisp (file).
generic-cl.map/src/mapgeneric-cl.map (system).
package.lisp (file).
hash-tables.lisp (file).
expanders.lisp (file).
generic-cl.set/src/setgeneric-cl.set (system).
package.lisp (file).
sets.lisp (file).
generic-cl.lazy-seq/src/lazy-seqgeneric-cl.lazy-seq (system).
package.lisp (file).
lazy-seq.lisp (file).
generic-cl.math/src/mathgeneric-cl.math (system).
package.lisp (file).
math.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
generic-cl/generic-cl.asdgeneric-cl.comparison/generic-cl.comparison.asdgeneric-cl.internal/generic-cl.internal.asdgeneric-cl.object/generic-cl.object.asdgeneric-cl.arithmetic/generic-cl.arithmetic.asdgeneric-cl.container/generic-cl.container.asdgeneric-cl.iterator/generic-cl.iterator.asdgeneric-cl.collector/generic-cl.collector.asdgeneric-cl.sequence/generic-cl.sequence.asdgeneric-cl.map/generic-cl.map.asdgeneric-cl.set/generic-cl.set.asdgeneric-cl.lazy-seq/generic-cl.lazy-seq.asdgeneric-cl.math/generic-cl.math.asdgeneric-cl/src/package.lispgeneric-cl.comparison/src/comparison/package.lispgeneric-cl.comparison/src/comparison/equality.lispgeneric-cl.comparison/src/comparison/comparison.lispgeneric-cl.internal/src/internal/package.lispgeneric-cl.internal/src/internal/util.lispgeneric-cl.object/src/object/package.lispgeneric-cl.object/src/object/object.lispgeneric-cl.object/src/object/misc.lispgeneric-cl.arithmetic/src/arithmetic/package.lispgeneric-cl.arithmetic/src/arithmetic/arithmetic.lispgeneric-cl.container/src/container/package.lispgeneric-cl.container/src/container/container.lispgeneric-cl.container/src/container/cl-containers.lispgeneric-cl.iterator/src/iterator/package.lispgeneric-cl.iterator/src/iterator/iterator.lispgeneric-cl.iterator/src/iterator/util.lispgeneric-cl.iterator/src/iterator/doseq.lispgeneric-cl.iterator/src/iterator/expanders.lispgeneric-cl.collector/src/collector/package.lispgeneric-cl.collector/src/collector/collector.lispgeneric-cl.sequence/src/sequence/package.lispgeneric-cl.sequence/src/sequence/sequences.lispgeneric-cl.sequence/src/sequence/cl-sequences.lispgeneric-cl.sequence/src/sequence/generic-sequences.lispgeneric-cl.sequence/src/sequence/optimization.lispgeneric-cl.map/src/map/package.lispgeneric-cl.map/src/map/hash-tables.lispgeneric-cl.map/src/map/expanders.lispgeneric-cl.set/src/set/package.lispgeneric-cl.set/src/set/sets.lispgeneric-cl.lazy-seq/src/lazy-seq/package.lispgeneric-cl.lazy-seq/src/lazy-seq/lazy-seq.lispgeneric-cl.math/src/math/package.lispgeneric-cl.math/src/math/math.lispgeneric-cl.comparison/generic-cl.comparison.asdgeneric-cl.comparison (system).
generic-cl.internal/generic-cl.internal.asdgeneric-cl.internal (system).
generic-cl.object/generic-cl.object.asdgeneric-cl.object (system).
generic-cl.arithmetic/generic-cl.arithmetic.asdgeneric-cl.arithmetic (system).
generic-cl.container/generic-cl.container.asdgeneric-cl.container (system).
generic-cl.iterator/generic-cl.iterator.asdgeneric-cl.iterator (system).
generic-cl.collector/generic-cl.collector.asdgeneric-cl.collector (system).
generic-cl.sequence/generic-cl.sequence.asdgeneric-cl.sequence (system).
generic-cl.map/generic-cl.map.asdgeneric-cl.map (system).
generic-cl.set/generic-cl.set.asdgeneric-cl.set (system).
generic-cl.lazy-seq/generic-cl.lazy-seq.asdgeneric-cl.lazy-seq (system).
generic-cl.math/generic-cl.math.asdgeneric-cl.math (system).
generic-cl.comparison/src/comparison/package.lispsrc/comparison (module).
generic-cl.comparison/src/comparison/equality.lisppackage.lisp (file).
src/comparison (module).
generic-cl.comparison/src/comparison/comparison.lispequality.lisp (file).
src/comparison (module).
< (compiler macro).
< (function).
<= (compiler macro).
<= (function).
> (compiler macro).
> (function).
>= (compiler macro).
>= (function).
compare (generic function).
greater-equal-p (generic function).
greaterp (generic function).
less-equal-p (generic function).
lessp (generic function).
max (compiler macro).
max (function).
min (compiler macro).
min (function).
generic-cl.internal/src/internal/package.lispsrc/internal (module).
generic-cl.internal/src/internal/util.lisppackage.lisp (file).
src/internal (module).
constant-form-value (function).
numbers? (function).
with-constant-values (macro).
generic-cl.object/src/object/package.lispsrc/object (module).
generic-cl.object/src/object/object.lisppackage.lisp (file).
src/object (module).
deep-copy-array (function).
deep-copy-list (function).
deep-copy-vector (function).
generic-cl.object/src/object/misc.lispobject.lisp (file).
src/object (module).
defconstant (macro).
generic-cl.arithmetic/src/arithmetic/package.lispsrc/arithmetic (module).
generic-cl.arithmetic/src/arithmetic/arithmetic.lisppackage.lisp (file).
src/arithmetic (module).
* (symbol macro).
* (compiler macro).
* (function).
+ (symbol macro).
+ (compiler macro).
+ (function).
- (symbol macro).
- (compiler macro).
- (function).
/ (symbol macro).
/ (compiler macro).
/ (function).
1+ (generic function).
1- (generic function).
abs (generic function).
add (generic function).
ceiling (generic function).
decf (macro).
divide (generic function).
evenp (generic function).
floor (generic function).
incf (macro).
minusp (generic function).
mod (generic function).
multiply (generic function).
negate (generic function).
oddp (generic function).
plusp (generic function).
rem (generic function).
round (generic function).
signum (generic function).
subtract (generic function).
truncate (generic function).
zerop (generic function).
generic-cl.container/src/container/package.lispsrc/container (module).
generic-cl.container/src/container/container.lisppackage.lisp (file).
src/container (module).
adjust-size (generic function).
clear (generic function).
cleared (generic function).
elt (generic function).
(setf elt) (generic function).
emptyp (generic function).
erase (generic function).
first (generic function).
last (generic function).
length (generic function).
make-sequence-of-type (generic function).
nadjust-size (generic function).
subseq (generic function).
(setf subseq) (generic function).
generic-cl.container/src/container/cl-containers.lispcontainer.lisp (file).
src/container (module).
adjust-size (method).
adjust-size (method).
clear (method).
cleared (method).
cleared (method).
elt (method).
elt (method).
elt (method).
elt (method).
(setf elt) (method).
(setf elt) (method).
(setf elt) (method).
(setf elt) (method).
emptyp (method).
emptyp (method).
emptyp (method).
erase (method).
first (method).
first (method).
first (method).
last (method).
last (method).
last (method).
lastcdr (function).
length (method).
length (method).
length (method).
make-sequence-of-type (method).
nadjust-size (method).
nadjust-size (method).
sequence-of-type (function).
subseq (method).
(setf subseq) (method).
generic-cl.iterator/src/iterator/package.lispsrc/iterator (module).
generic-cl.iterator/src/iterator/iterator.lisppackage.lisp (file).
src/iterator (module).
advance (generic function).
advance-n (generic function).
at (generic function).
(setf at) (generic function).
copy (method).
endp (generic function).
iterator (function).
iterator (structure).
length (method).
length (method).
length (method).
length (method).
make-iterator (generic function).
make-reverse-iterator (generic function).
start (generic function).
subseq (method).
subseq (method).
subseq (method).
subseq (method).
subseq (method).
subseq (method).
subseq (method).
subseq (method).
subseq (method).
array-iterator (structure).
array-iterator-array (function).
(setf array-iterator-array) (function).
array-iterator-end (function).
(setf array-iterator-end) (function).
array-iterator-index (function).
(setf array-iterator-index) (function).
array-iterator-p (function).
bound-list-iterator (structure).
bound-list-iterator-cons (function).
(setf bound-list-iterator-cons) (function).
bound-list-iterator-end (reader).
(setf bound-list-iterator-end) (writer).
bound-list-iterator-p (function).
copy-array-iterator (function).
copy-bound-list-iterator (function).
copy-iterator (function).
copy-list-iterator (function).
copy-reverse-array-iterator (function).
copy-reverse-list-iterator (function).
copy-reverse-vector-iterator (function).
copy-vector-iterator (function).
iterator-p (function).
list-iterator (structure).
list-iterator-cons (reader).
(setf list-iterator-cons) (writer).
list-iterator-p (function).
make-array-iterator (function).
make-bound-list-iterator (function).
make-list-iterator (function).
make-reverse-array-iterator (function).
make-reverse-list-iterator (function).
make-reverse-vector-iterator (function).
make-sub-iterator (function).
make-vector-iterator (function).
reverse-array-iterator (structure).
reverse-array-iterator-array (function).
(setf reverse-array-iterator-array) (function).
reverse-array-iterator-end (function).
(setf reverse-array-iterator-end) (function).
reverse-array-iterator-index (function).
(setf reverse-array-iterator-index) (function).
reverse-array-iterator-p (function).
reverse-list-iterator (structure).
reverse-list-iterator-cons (function).
(setf reverse-list-iterator-cons) (function).
reverse-list-iterator-p (function).
reverse-vector-iterator (structure).
reverse-vector-iterator-array (function).
(setf reverse-vector-iterator-array) (function).
reverse-vector-iterator-end (function).
(setf reverse-vector-iterator-end) (function).
reverse-vector-iterator-index (function).
(setf reverse-vector-iterator-index) (function).
reverse-vector-iterator-p (function).
sub-iterator (structure).
sub-iterator-end (reader).
(setf sub-iterator-end) (writer).
sub-iterator-iter (reader).
(setf sub-iterator-iter) (writer).
sub-iterator-p (function).
vector-iterator (structure).
vector-iterator-array (reader).
(setf vector-iterator-array) (writer).
vector-iterator-end (reader).
(setf vector-iterator-end) (writer).
vector-iterator-index (reader).
(setf vector-iterator-index) (writer).
vector-iterator-p (function).
generic-cl.iterator/src/iterator/util.lispiterator.lisp (file).
src/iterator (module).
destructure-vars (function).
iter-macro (macro).
make-destructure-pattern (function).
parse-iter-macro-body (function).
partition-declarations (function).
split-declarations-forms (macro).
subtype (method combination).
with-destructure-pattern (macro).
with-variable-declarations (macro).
generic-cl.iterator/src/iterator/doseq.lisputil.lisp (file).
src/iterator (module).
do-iter-values (macro).
do-sequences (macro).
do-sequences! (macro).
doiter (macro).
doiters (macro).
doseq (macro).
doseq! (macro).
with-iter-place (macro).
with-iter-value (macro).
with-iter-values (macro).
with-iterators (macro).
do-iter-places (macro).
do-sequences!-fast% (macro).
do-sequences!-safe% (macro).
do-sequences-fast% (macro).
do-sequences-safe% (macro).
iter-place-macros (function).
iter-value-macros (function).
make-doseq (generic function).
with-iter-places (macro).
generic-cl.iterator/src/iterator/expanders.lispdoseq.lisp (file).
src/iterator (module).
make-doseq (method).
make-doseq (method).
make-doseq (method).
make-doseq (method).
sublist (function).
generic-cl.collector/src/collector/package.lispsrc/collector (module).
generic-cl.collector/src/collector/collector.lisppackage.lisp (file).
src/collector (module).
accumulate (generic function).
collector-sequence (generic function).
extend (generic function).
make-collector (generic function).
copy-front-list-collector (function).
copy-front-vector-collector (function).
copy-list-collector (function).
front-list-collector (structure).
front-list-collector-cons (reader).
(setf front-list-collector-cons) (writer).
front-list-collector-p (function).
front-vector-collector (structure).
front-vector-collector-p (function).
front-vector-collector-vector (reader).
(setf front-vector-collector-vector) (writer).
list-collector (structure).
list-collector-head (reader).
(setf list-collector-head) (writer).
list-collector-p (function).
list-collector-tail (reader).
(setf list-collector-tail) (writer).
make-front-list-collector (function).
make-front-vector-collector (function).
make-list-collector (function).
generic-cl.sequence/src/sequence/package.lispsrc/sequence (module).
generic-cl.sequence/src/sequence/sequences.lisppackage.lisp (file).
src/sequence (module).
concatenate (generic function).
concatenate-to (generic function).
count (generic function).
count-if (generic function).
count-if-not (generic function).
delete (generic function).
delete-duplicates (generic function).
delete-if (generic function).
delete-if-not (generic function).
fill (generic function).
find (generic function).
find-if (generic function).
find-if-not (generic function).
find-it (generic function).
find-it-if (generic function).
find-it-if-not (generic function).
map (generic function).
map-extend (generic function).
map-extend-into (generic function).
map-extend-to (generic function).
map-into (generic function).
map-to (generic function).
merge (generic function).
mismatch (generic function).
nconcatenate (generic function).
nmap (generic function).
nmerge (generic function).
nreverse (generic function).
nsort (generic function).
nsubstitute (generic function).
nsubstitute-if (generic function).
nsubstitute-if-not (generic function).
position (generic function).
position-if (generic function).
position-if-not (generic function).
reduce (generic function).
remove (generic function).
remove-duplicates (generic function).
remove-if (generic function).
remove-if-not (generic function).
replace (generic function).
reverse (generic function).
search (generic function).
sort (generic function).
stable-nsort (generic function).
stable-sort (generic function).
substitute (generic function).
substitute-if (generic function).
substitute-if-not (generic function).
generic-cl.sequence/src/sequence/cl-sequences.lispsequences.lisp (file).
src/sequence (module).
count (method).
count-if (method).
count-if-not (method).
delete (method).
delete-duplicates (method).
delete-if (method).
delete-if-not (method).
fill (method).
find (method).
find-if (method).
find-if-not (method).
merge (method).
mismatch (method).
nmerge (method).
nreverse (method).
nsort (method).
nsubstitute (method).
nsubstitute-if (method).
nsubstitute-if-not (method).
position (method).
position-if (method).
position-if-not (method).
reduce (method).
remove (method).
remove-duplicates (method).
remove-if (method).
remove-if-not (method).
replace (method).
reverse (method).
search (method).
sort (method).
stable-nsort (method).
stable-sort (method).
substitute (method).
substitute-if (method).
substitute-if-not (method).
generic-cl.sequence/src/sequence/generic-sequences.lispcl-sequences.lisp (file).
src/sequence (module).
adjust-size (method).
concatenate (method).
concatenate-to (method).
count (method).
count-if (method).
count-if-not (method).
delete (method).
delete-duplicates (method).
delete-if (method).
delete-if-not (method).
elt (method).
(setf elt) (method).
emptyp (method).
every (function).
fill (method).
find (method).
find-if (method).
find-if-not (method).
find-it (method).
find-it-if (method).
find-it-if-not (method).
first (method).
foreach (function).
last (method).
length (method).
length (method).
map (method).
map-extend (method).
map-extend-into (method).
map-extend-to (method).
map-into (method).
map-to (method).
merge (method).
mismatch (method).
nadjust-size (method).
nconcatenate (method).
nmap (method).
nmerge (method).
notany (function).
notevery (function).
nreverse (method).
nsort (method).
nsubstitute (method).
nsubstitute-if (method).
nsubstitute-if-not (method).
position (method).
position-if (method).
position-if-not (method).
reduce (method).
remove (method).
remove-duplicates (method).
remove-if (method).
remove-if-not (method).
replace (method).
reverse (method).
search (method).
some (function).
sort (method).
stable-nsort (method).
stable-sort (method).
subseq (method).
(setf subseq) (method).
substitute (method).
substitute-if (method).
substitute-if-not (method).
advance-all (function).
collect-perform-op (function).
get-elements (function).
make-iters (function).
map-extend-into% (function).
map-into% (function).
some-endp (function).
test-eq (function).
test-not (function).
generic-cl.sequence/src/sequence/optimization.lispgeneric-sequences.lisp (file).
src/sequence (module).
optimize-seq-fn (macro).
sequence? (function).
sequences? (function).
generic-cl.map/src/map/hash-tables.lisppackage.lisp (file).
src/map (module).
accumulate (method).
alist-hash-map (function).
(setf at) (method).
clear (method).
clear (method).
cleared (method).
coerce (method).
coerce (method).
collector-sequence (method).
copy (method).
copy (method).
elt (method).
elt (method).
(setf elt) (method).
(setf elt) (method).
emptyp (method).
emptyp (method).
ensure-get (macro).
ensure-hash-map (function).
equalp (method).
erase (method).
erase (method).
first (method).
first (method).
get (generic function).
(setf get) (generic function).
hash (generic function).
hash-map (function).
hash-map (structure).
hash-map-alist (function).
hash-map-p (function).
hash-map-table (reader).
(setf hash-map-table) (writer).
hash-map-test (function).
length (method).
length (method).
like-hash (generic function).
likep (method).
make-collector (method).
make-hash-map (function).
make-iterator (method).
make-iterator (method).
make-load-form (method).
make-reverse-iterator (method).
make-reverse-iterator (method).
make-sequence-of-type (method).
map-keys (generic function).
map-values (generic function).
subseq (method).
copy-generic-hash-table (function).
copy-hash-table-iterator (function).
do-generic-map (macro).
hash-map->list (function).
hash-map-test-p (function).
hash-table-iterator (structure).
hash-table-iterator-cons (function).
(setf hash-table-iterator-cons) (function).
hash-table-iterator-p (function).
hash-table-iterator-table (reader).
(setf hash-table-iterator-table) (writer).
hashmap-keys (function).
hashmap-values (function).
make-empty-hash-table (function).
make-generic-hash-table (function).
make-generic-similar-hash-table (function).
make-hash-map-table (function).
make-hash-table-iterator (function).
generic-cl.map/src/map/expanders.lisphash-tables.lisp (file).
src/map (module).
make-destructure-pattern (function).
make-doseq (method).
make-doseq (method).
map-place (macro).
(setf map-place) (setf expander).
with-destructure-entry (macro).
generic-cl.set/src/set/sets.lisppackage.lisp (file).
src/set (module).
accumulate (method).
add (method).
adjoin (generic function).
cleared (method).
coerce (method).
copy (method).
equalp (method).
hash-set (function).
hash-set (structure).
hash-set-p (function).
hash-set-table (function).
(setf hash-set-table) (function).
hash-table-set (function).
intersection (generic function).
make-hash-set (function).
make-iterator (method).
make-reverse-iterator (method).
make-sequence-of-type (method).
memberp (generic function).
nadjoin (generic function).
nintersection (generic function).
nset-difference (generic function).
nset-exclusive-or (generic function).
nunion (generic function).
set-difference (generic function).
set-exclusive-or (generic function).
subsetp (generic function).
subtract (method).
union (generic function).
hash-set->list (function).
list->hash-set (function).
generic-cl.lazy-seq/src/lazy-seq/package.lispsrc/lazy-seq (module).
generic-cl.lazy-seq/src/lazy-seq/lazy-seq.lisppackage.lisp (file).
src/lazy-seq (module).
advance (method).
advance (method).
at (method).
cleared (method).
coerce (method).
concatenate (method).
concatenate-to (method).
copy (method).
delete-duplicates (method).
delete-if (method).
emptyp (method).
endp (method).
endp (method).
equalp (method).
first (method).
lazy-seq (macro).
lazy-seq (structure).
lazy-seq-head (reader).
(setf lazy-seq-head) (writer).
lazy-seq-p (function).
lazy-seq-tail (reader).
(setf lazy-seq-tail) (writer).
make-collector (method).
make-iterator (method).
make-iterator (method).
make-lazy-seq (function).
make-reverse-iterator (method).
map (method).
map-extend (method).
map-extend-into (method).
map-extend-to (method).
map-into (method).
map-to (method).
nconcatenate (method).
nmap (method).
nsubstitute-if (method).
range (function).
remove-duplicates (method).
remove-if (method).
subseq (method).
subseq (method).
subseq (method).
substitute-if (method).
bound-lazy-seq-iterator (structure).
bound-lazy-seq-iterator-end (reader).
(setf bound-lazy-seq-iterator-end) (writer).
bound-lazy-seq-iterator-index (reader).
(setf bound-lazy-seq-iterator-index) (writer).
bound-lazy-seq-iterator-p (function).
bound-lazy-seq-iterator-seq (function).
(setf bound-lazy-seq-iterator-seq) (function).
copy-bound-lazy-seq-iterator (function).
copy-initial-lazy-seq (function).
copy-lazy-seq-iterator (function).
lazy-seq->list (function).
lazy-seq-iterator (structure).
lazy-seq-iterator-p (function).
lazy-seq-iterator-seq (reader).
(setf lazy-seq-iterator-seq) (writer).
make-bound-lazy-seq-iterator (function).
make-lazy-seq-iterator (function).
map-extend-to-lazy-seq (function).
more? (function).
remove-dups-from-lazy-seq-hash (function).
remove-dups-from-lazy-seq-list (function).
remove-from-lazy-seq (function).
sub-lazy-seq (function).
substitue-in-lazy-seq (function).
thunk (macro).
generic-cl.math/src/math/math.lisppackage.lisp (file).
src/math (module).
acos (generic function).
acosh (generic function).
asin (generic function).
asinh (generic function).
atan (generic function).
atanh (generic function).
cis (generic function).
conjugate (generic function).
cos (generic function).
cosh (generic function).
denominator (generic function).
exp (generic function).
expt (generic function).
imagpart (generic function).
isqrt (generic function).
log (generic function).
numerator (generic function).
phase (generic function).
rational (generic function).
rationalize (generic function).
realpart (generic function).
sin (generic function).
sinh (generic function).
sqrt (generic function).
tan (generic function).
tanh (generic function).
Packages are listed by definition order.
generic-cl.mapgeneric-cl.containergeneric-clgeneric-cl.setgeneric-cl.objectgeneric-cl.iteratorgeneric-cl.sequencegeneric-cl.mathgeneric-math-clgeneric-cl.internalgeneric-cl.iterator.optimizationgeneric-cl.lazy-seqgeneric-cl.arithmeticgeneric-cl.comparisongeneric-cl.collectorgeneric-cl.mapGeneric map and hash-table interface
anaphora.
arrows.
cl-custom-hash-table.
generic-cl.collector.
generic-cl.comparison.
generic-cl.container.
generic-cl.internal.
generic-cl.iterator.
generic-cl.iterator.optimization.
generic-cl.object.
static-dispatch-cl.
trivia.level2.
alist-hash-map (function).
ensure-get (macro).
ensure-hash-map (function).
get (compiler macro).
(setf get) (compiler macro).
get (generic function).
(setf get) (generic function).
hash (compiler macro).
hash (generic function).
hash-map (function).
hash-map (structure).
hash-map-alist (function).
hash-map-p (function).
hash-map-table (reader).
(setf hash-map-table) (writer).
hash-map-test (function).
like-hash (compiler macro).
like-hash (generic function).
make-hash-map (function).
map-keys (compiler macro).
map-keys (generic function).
map-values (compiler macro).
map-values (generic function).
copy-generic-hash-table (function).
copy-hash-table-iterator (function).
do-generic-map (macro).
hash-map->list (function).
hash-map-test-p (function).
hash-table-iterator (structure).
hash-table-iterator-cons (function).
(setf hash-table-iterator-cons) (function).
hash-table-iterator-p (function).
hash-table-iterator-table (reader).
(setf hash-table-iterator-table) (writer).
hashmap-keys (function).
hashmap-values (function).
make-destructure-pattern (function).
make-empty-hash-table (function).
make-generic-hash-table (function).
make-generic-similar-hash-table (function).
make-hash-map-table (function).
make-hash-table-iterator (function).
map-place (macro).
(setf map-place) (setf expander).
with-destructure-entry (macro).
generic-cl.containerGeneric container interface
alexandria.
generic-cl.object.
static-dispatch-cl.
adjust-size (compiler macro).
adjust-size (generic function).
clear (compiler macro).
clear (generic function).
cleared (compiler macro).
cleared (generic function).
elt (compiler macro).
(setf elt) (compiler macro).
elt (generic function).
(setf elt) (generic function).
emptyp (compiler macro).
emptyp (generic function).
erase (compiler macro).
erase (generic function).
first (compiler macro).
first (generic function).
last (compiler macro).
last (generic function).
lastcdr (function).
length (compiler macro).
length (generic function).
make-sequence-of-type (compiler macro).
make-sequence-of-type (generic function).
nadjust-size (compiler macro).
nadjust-size (generic function).
sequence-of-type (function).
subseq (compiler macro).
(setf subseq) (compiler macro).
subseq (generic function).
(setf subseq) (generic function).
generic-cl.setGeneric set interface
anaphora.
cl-custom-hash-table.
generic-cl.arithmetic.
generic-cl.collector.
generic-cl.comparison.
generic-cl.container.
generic-cl.iterator.
generic-cl.map.
generic-cl.object.
generic-cl.sequence.
static-dispatch-cl.
adjoin (compiler macro).
adjoin (generic function).
hash-set (function).
hash-set (structure).
hash-set-p (function).
hash-set-table (function).
(setf hash-set-table) (function).
hash-table-set (function).
intersection (compiler macro).
intersection (generic function).
make-hash-set (function).
memberp (compiler macro).
memberp (generic function).
nadjoin (compiler macro).
nadjoin (generic function).
nintersection (compiler macro).
nintersection (generic function).
nset-difference (compiler macro).
nset-difference (generic function).
nset-exclusive-or (compiler macro).
nset-exclusive-or (generic function).
nunion (compiler macro).
nunion (generic function).
set-difference (compiler macro).
set-difference (generic function).
set-exclusive-or (compiler macro).
set-exclusive-or (generic function).
subsetp (compiler macro).
subsetp (generic function).
union (compiler macro).
union (generic function).
hash-set->list (function).
list->hash-set (function).
generic-cl.objectGeneric object copying and type conversion interface
alexandria.
arrows.
generic-cl.comparison.
static-dispatch-cl.
coerce (compiler macro).
coerce (generic function).
copy (compiler macro).
copy (generic function).
defconstant (macro).
deep-copy-array (function).
deep-copy-list (function).
deep-copy-vector (function).
generic-cl.iteratorGeneric iterator interface
anaphora.
arrows.
cl-form-types.
generic-cl.container.
generic-cl.internal.
generic-cl.object.
static-dispatch-cl.
tcr.parse-declarations-1.0.
trivia.level2.
advance (compiler macro).
advance (generic function).
advance-n (compiler macro).
advance-n (generic function).
at (compiler macro).
(setf at) (compiler macro).
at (generic function).
(setf at) (generic function).
do-iter-values (macro).
do-sequences (macro).
do-sequences! (macro).
doiter (macro).
doiters (macro).
doseq (macro).
doseq! (macro).
endp (compiler macro).
endp (generic function).
iterator (function).
iterator (structure).
make-iterator (compiler macro).
make-iterator (generic function).
make-reverse-iterator (compiler macro).
make-reverse-iterator (generic function).
start (compiler macro).
start (generic function).
with-iter-place (macro).
with-iter-value (macro).
with-iter-values (macro).
with-iterators (macro).
array-iterator (structure).
array-iterator-array (function).
(setf array-iterator-array) (function).
array-iterator-end (function).
(setf array-iterator-end) (function).
array-iterator-index (function).
(setf array-iterator-index) (function).
array-iterator-p (function).
bound-list-iterator (structure).
bound-list-iterator-cons (function).
(setf bound-list-iterator-cons) (function).
bound-list-iterator-end (reader).
(setf bound-list-iterator-end) (writer).
bound-list-iterator-p (function).
copy-array-iterator (function).
copy-bound-list-iterator (function).
copy-iterator (function).
copy-list-iterator (function).
copy-reverse-array-iterator (function).
copy-reverse-list-iterator (function).
copy-reverse-vector-iterator (function).
copy-vector-iterator (function).
destructure-vars (function).
do-iter-places (macro).
do-sequences!-fast% (macro).
do-sequences!-safe% (macro).
do-sequences-fast% (macro).
do-sequences-safe% (macro).
iter-macro (macro).
iter-place-macros (function).
iter-value-macros (function).
iterator-p (function).
list-iterator (structure).
list-iterator-cons (reader).
(setf list-iterator-cons) (writer).
list-iterator-p (function).
make-array-iterator (function).
make-bound-list-iterator (function).
make-destructure-pattern (function).
make-doseq (compiler macro).
make-doseq (generic function).
make-list-iterator (function).
make-reverse-array-iterator (function).
make-reverse-list-iterator (function).
make-reverse-vector-iterator (function).
make-sub-iterator (function).
make-vector-iterator (function).
parse-iter-macro-body (function).
partition-declarations (function).
reverse-array-iterator (structure).
reverse-array-iterator-array (function).
(setf reverse-array-iterator-array) (function).
reverse-array-iterator-end (function).
(setf reverse-array-iterator-end) (function).
reverse-array-iterator-index (function).
(setf reverse-array-iterator-index) (function).
reverse-array-iterator-p (function).
reverse-list-iterator (structure).
reverse-list-iterator-cons (function).
(setf reverse-list-iterator-cons) (function).
reverse-list-iterator-p (function).
reverse-vector-iterator (structure).
reverse-vector-iterator-array (function).
(setf reverse-vector-iterator-array) (function).
reverse-vector-iterator-end (function).
(setf reverse-vector-iterator-end) (function).
reverse-vector-iterator-index (function).
(setf reverse-vector-iterator-index) (function).
reverse-vector-iterator-p (function).
split-declarations-forms (macro).
sub-iterator (structure).
sub-iterator-end (reader).
(setf sub-iterator-end) (writer).
sub-iterator-iter (reader).
(setf sub-iterator-iter) (writer).
sub-iterator-p (function).
sublist (function).
subtype (method combination).
vector-iterator (structure).
vector-iterator-array (reader).
(setf vector-iterator-array) (writer).
vector-iterator-end (reader).
(setf vector-iterator-end) (writer).
vector-iterator-index (reader).
(setf vector-iterator-index) (writer).
vector-iterator-p (function).
with-destructure-pattern (macro).
with-iter-places (macro).
with-variable-declarations (macro).
generic-cl.sequenceGeneric sequence operations
anaphora.
arrows.
cl-custom-hash-table.
cl-form-types.
generic-cl.collector.
generic-cl.comparison.
generic-cl.container.
generic-cl.internal.
generic-cl.iterator.
generic-cl.map.
generic-cl.object.
generic-cl.sequence.
static-dispatch-cl.
concatenate (compiler macro).
concatenate (generic function).
concatenate-to (compiler macro).
concatenate-to (generic function).
count (compiler macro).
count (generic function).
count-if (compiler macro).
count-if (generic function).
count-if-not (compiler macro).
count-if-not (generic function).
delete (compiler macro).
delete (generic function).
delete-duplicates (compiler macro).
delete-duplicates (generic function).
delete-if (compiler macro).
delete-if (generic function).
delete-if-not (compiler macro).
delete-if-not (generic function).
every (compiler macro).
every (function).
fill (compiler macro).
fill (generic function).
find (compiler macro).
find (generic function).
find-if (compiler macro).
find-if (generic function).
find-if-not (compiler macro).
find-if-not (generic function).
find-it (compiler macro).
find-it (generic function).
find-it-if (compiler macro).
find-it-if (generic function).
find-it-if-not (compiler macro).
find-it-if-not (generic function).
foreach (compiler macro).
foreach (function).
map (compiler macro).
map (generic function).
map-extend (compiler macro).
map-extend (generic function).
map-extend-into (compiler macro).
map-extend-into (generic function).
map-extend-to (compiler macro).
map-extend-to (generic function).
map-into (compiler macro).
map-into (generic function).
map-to (compiler macro).
map-to (generic function).
merge (compiler macro).
merge (generic function).
mismatch (compiler macro).
mismatch (generic function).
nconcatenate (compiler macro).
nconcatenate (generic function).
nmap (compiler macro).
nmap (generic function).
nmerge (compiler macro).
nmerge (generic function).
notany (compiler macro).
notany (function).
notevery (compiler macro).
notevery (function).
nreverse (compiler macro).
nreverse (generic function).
nsort (compiler macro).
nsort (generic function).
nsubstitute (compiler macro).
nsubstitute (generic function).
nsubstitute-if (compiler macro).
nsubstitute-if (generic function).
nsubstitute-if-not (compiler macro).
nsubstitute-if-not (generic function).
position (compiler macro).
position (generic function).
position-if (compiler macro).
position-if (generic function).
position-if-not (compiler macro).
position-if-not (generic function).
reduce (compiler macro).
reduce (generic function).
remove (compiler macro).
remove (generic function).
remove-duplicates (compiler macro).
remove-duplicates (generic function).
remove-if (compiler macro).
remove-if (generic function).
remove-if-not (compiler macro).
remove-if-not (generic function).
replace (compiler macro).
replace (generic function).
reverse (compiler macro).
reverse (generic function).
search (compiler macro).
search (generic function).
some (compiler macro).
some (function).
sort (compiler macro).
sort (generic function).
stable-nsort (compiler macro).
stable-nsort (generic function).
stable-sort (compiler macro).
stable-sort (generic function).
substitute (compiler macro).
substitute (generic function).
substitute-if (compiler macro).
substitute-if (generic function).
substitute-if-not (compiler macro).
substitute-if-not (generic function).
advance-all (function).
collect-perform-op (function).
get-elements (function).
make-iters (function).
map-extend-into% (function).
map-into% (function).
optimize-seq-fn (macro).
sequence? (function).
sequences? (function).
some-endp (function).
test-eq (function).
test-not (function).
generic-cl.mathGeneric math function interface
generic-cl.arithmetic.
static-dispatch-cl.
acos (compiler macro).
acos (generic function).
acosh (compiler macro).
acosh (generic function).
asin (compiler macro).
asin (generic function).
asinh (compiler macro).
asinh (generic function).
atan (compiler macro).
atan (generic function).
atanh (compiler macro).
atanh (generic function).
cis (compiler macro).
cis (generic function).
conjugate (compiler macro).
conjugate (generic function).
cos (compiler macro).
cos (generic function).
cosh (compiler macro).
cosh (generic function).
denominator (compiler macro).
denominator (generic function).
exp (compiler macro).
exp (generic function).
expt (compiler macro).
expt (generic function).
imagpart (compiler macro).
imagpart (generic function).
isqrt (compiler macro).
isqrt (generic function).
log (compiler macro).
log (generic function).
numerator (compiler macro).
numerator (generic function).
phase (compiler macro).
phase (generic function).
rational (compiler macro).
rational (generic function).
rationalize (compiler macro).
rationalize (generic function).
realpart (compiler macro).
realpart (generic function).
sin (compiler macro).
sin (generic function).
sinh (compiler macro).
sinh (generic function).
sqrt (compiler macro).
sqrt (generic function).
tan (compiler macro).
tan (generic function).
tanh (compiler macro).
tanh (generic function).
generic-cl.internalUtilities used internally by generic-cl
alexandria.
cl-form-types.
static-dispatch-cl.
trivia.level2.
constant-form-value (function).
numbers? (function).
with-constant-values (macro).
generic-cl.iterator.optimizationOptimization interface of iterator interface.
generic-cl.lazy-seqLazy Sequences
agutil.
arrows.
cl-custom-hash-table.
generic-cl.collector.
generic-cl.comparison.
generic-cl.container.
generic-cl.iterator.
generic-cl.map.
generic-cl.object.
generic-cl.sequence.
static-dispatch-cl.
trivia.level2.
lazy-seq (macro).
lazy-seq (structure).
lazy-seq-head (reader).
(setf lazy-seq-head) (writer).
lazy-seq-p (function).
lazy-seq-tail (reader).
(setf lazy-seq-tail) (writer).
make-lazy-seq (function).
range (function).
bound-lazy-seq-iterator (structure).
bound-lazy-seq-iterator-end (reader).
(setf bound-lazy-seq-iterator-end) (writer).
bound-lazy-seq-iterator-index (reader).
(setf bound-lazy-seq-iterator-index) (writer).
bound-lazy-seq-iterator-p (function).
bound-lazy-seq-iterator-seq (function).
(setf bound-lazy-seq-iterator-seq) (function).
copy-bound-lazy-seq-iterator (function).
copy-initial-lazy-seq (function).
copy-lazy-seq-iterator (function).
lazy-seq->list (function).
lazy-seq-iterator (structure).
lazy-seq-iterator-p (function).
lazy-seq-iterator-seq (reader).
(setf lazy-seq-iterator-seq) (writer).
make-bound-lazy-seq-iterator (function).
make-lazy-seq-iterator (function).
map-extend-to-lazy-seq (function).
more? (function).
remove-dups-from-lazy-seq-hash (function).
remove-dups-from-lazy-seq-list (function).
remove-from-lazy-seq (function).
sub-lazy-seq (function).
substitue-in-lazy-seq (function).
thunk (macro).
generic-cl.arithmeticGeneric arithmetic functions
generic-cl.comparison.
generic-cl.internal.
static-dispatch-cl.
trivia.level2.
* (symbol macro).
* (compiler macro).
* (function).
+ (symbol macro).
+ (compiler macro).
+ (function).
- (symbol macro).
- (compiler macro).
- (function).
/ (symbol macro).
/ (compiler macro).
/ (function).
1+ (compiler macro).
1+ (generic function).
1- (compiler macro).
1- (generic function).
abs (compiler macro).
abs (generic function).
add (compiler macro).
add (generic function).
ceiling (compiler macro).
ceiling (generic function).
decf (macro).
divide (compiler macro).
divide (generic function).
evenp (compiler macro).
evenp (generic function).
floor (compiler macro).
floor (generic function).
incf (macro).
minusp (compiler macro).
minusp (generic function).
mod (compiler macro).
mod (generic function).
multiply (compiler macro).
multiply (generic function).
negate (compiler macro).
negate (generic function).
oddp (compiler macro).
oddp (generic function).
plusp (compiler macro).
plusp (generic function).
rem (compiler macro).
rem (generic function).
round (compiler macro).
round (generic function).
signum (compiler macro).
signum (generic function).
subtract (compiler macro).
subtract (generic function).
truncate (compiler macro).
truncate (generic function).
zerop (compiler macro).
zerop (generic function).
generic-cl.comparisonGeneric comparison interface.
alexandria.
generic-cl.internal.
static-dispatch-cl.
/= (compiler macro).
/= (function).
< (compiler macro).
< (function).
<= (compiler macro).
<= (function).
= (compiler macro).
= (function).
> (compiler macro).
> (function).
>= (compiler macro).
>= (function).
compare (compiler macro).
compare (generic function).
equalp (compiler macro).
equalp (generic function).
greater-equal-p (compiler macro).
greater-equal-p (generic function).
greaterp (compiler macro).
greaterp (generic function).
less-equal-p (compiler macro).
less-equal-p (generic function).
lessp (compiler macro).
lessp (generic function).
likep (compiler macro).
likep (generic function).
max (compiler macro).
max (function).
min (compiler macro).
min (function).
generic-cl.collectorGeneric collector interface
alexandria.
anaphora.
arrows.
generic-cl.iterator.
generic-cl.object.
static-dispatch-cl.
accumulate (compiler macro).
accumulate (generic function).
collector-sequence (compiler macro).
collector-sequence (generic function).
extend (compiler macro).
extend (generic function).
make-collector (compiler macro).
make-collector (generic function).
copy-front-list-collector (function).
copy-front-vector-collector (function).
copy-list-collector (function).
front-list-collector (structure).
front-list-collector-cons (reader).
(setf front-list-collector-cons) (writer).
front-list-collector-p (function).
front-vector-collector (structure).
front-vector-collector-p (function).
front-vector-collector-vector (reader).
(setf front-vector-collector-vector) (writer).
list-collector (structure).
list-collector-head (reader).
(setf list-collector-head) (writer).
list-collector-p (function).
list-collector-tail (reader).
(setf list-collector-tail) (writer).
make-front-list-collector (function).
make-front-vector-collector (function).
make-list-collector (function).
Definitions are sorted by export status, category, package, and then by lexicographic order.
Decrements the place by DELTA (defaults to 1) using the generic SUBTRACT function.
Ensures that SYMBOL is a constant with a value that is equal by
GENERIC-CL:EQUALP to VALUE. Implemented using
ALEXANDRIA:DEFINE-CONSTANT.
DOCUMENTATION is an optional documentation string.
Iterate over the remaining elements of a sequence pointed to by static iterators.
Evaluate FORMS at each iteration, for each remaining element, until
one of the iterators reaches the end of the sequence.
NOTE: May only be used inside a WITH-ITERATORS form.
ITERS:
List of bindings. Each element is of the form (PATTERN ITER),
interpreted as if to WITH-ITER-VALUE, where PATTERN is a binding
pattern, for the binding to the sequence element value, and ITER
is a static iterator identifier symbol, introduced in a parent
WITH-ITERATORS form.
FORMS
List of forms evaluated for each remaining element in the
sequences pointed to by the static iterators.
At each evaluation the next element of each sequence, pointed by
each ITER in ITERS, is bound to the variable(s) specified by the
corresponding PATTERN. After which the iterators are advanced to
the next elements.
If one of the iterators has reached the end of its sequence, a
non-local jump outside the enclosing WITH-ITERATORS form is
performed, i.e. any forms following this form, within the enclosing
WITH-ITERATORS form, will not be evaluated.
Iterate over the elements of one or more sequences.
Iteration is performed using the iterator interface, and over
multiple sequences simultaneously.
The macro arguments can be in one of the following two forms:
1. (NAME (&REST SEQS) &BODY BODY)
2. ((&REST SEQS) &BODY BODY)
NAME is a symbol serving as the name of the BLOCK from which the
forms in BODY can return, using (RETURN-FROM NAME ...). If not
given defaults to NIL.
Each element of SEQS is a list of the form (VAR SEQUENCE . ARGS),
where VAR is the variable to which the element of the sequence,
SEQUENCE, is bound, at each iteration, and ARGS are arguments
passed to the ITERATOR function, after the sequence.
BODY is a list of forms evaluated at each iteration. RETURN-FROM to the block named NAME may be used to terminate the iteration early and return a value from the DO-SEQUENCES form. NIL is returned if there is no explicit RETURN.
Mutable version of DO-SEQUENCES.
This is the same as DO-SEQUENCES however each NAME, is the name of
a symbol-macro, that is introduced, which expands to the ’place’,
suitable for use with SETF, of the current sequence element, rather
than a variable storing its value. This allows the elements of the
sequence to be mutated.
NOTE: This macro does not support destructuring of the sequence elements.
Sames as DOITERS however for the special case of iterating over a
single sequence.
The macro arguments can be in one of the following two forms:
1. (NAME (ITER &REST ARGS) &BODY BODY)
2. ((ITER &REST ARGS) &BODY BODY)
NAME is the block name, NIL if not given.
ITER is the variable to which the sequence iterator is bound.
ARGS are the arguments passed to the ITERATOR function, the result
of which is bound to ITER.
BODY is the list of forms in the loop body.
Iterate over one or more sequences with the iterator of each sequence bound to a variable.
The macro arguments can be in one of the following two forms:
1. (NAME (&REST ITERS) &BODY BODY)
2. ((&REST ITERS) &BODY BODY)
NAME is a symbol serving as the name of the BLOCK from which the
forms in BODY can return, using (RETURN-FROM NAME ...). If not
given defaults to NIL.
ITERS is a list of bindings with each element of the form (IT-VAR
SEQUENCE . ARGS). IT-VAR is the variable to which the iterator for
SEQUENCE is bound. ARGS are the remaining arguments passed to the
ITERATOR function (if any).
BODY is a list of forms which are evaluated at each iteration. The
bindings to the iterator variables (IT-VAR’s) are visible. At the
end of each iteration, each iterator is advanced by one position
with ADVANCE. The loop is terminated, with the DOITERS form
returning NIL, when at least one of the iterators reaches the end
of its sequence (ENDP returns true). The loop can be terminated
early with a RETURN-FROM to the block named NAME.
Iterate over the elements of a single sequence SEQUENCE.
Same as DO-SEQUENCES but for the special case of iterating over a
single sequence.
The macro arguments can be in one of the following two forms:
1. (NAME (ELEMENT SEQUENCE &REST ARGS) &BODY BODY)
2. ((ELEMENT SEQUENCE &REST ARGS) &BODY BODY)
NAME is the block name, NIL if not given.
ELEMENT is the variable to which each element of the sequence is
bound.
SEQUENCE is the sequence, with ARGS being the remaining arguments
passed to the ITERATOR function.
BODY is the list of forms evaluated on each iteration.
Mutable version of DOSEQ, expanding into DO-SEQUENCES!.
Increments the place by DELTA (defaults to 1) using the generic ADD function.
Creates a ‘LAZY-SEQ’ where HEAD is the first element in the sequence and TAIL is a form which computes the remainder of the sequence. TAIL is wrapped in a function that stores the result of evaluating FORM, the first time it is invoked, and returns the stored result in future invocations.
Check whether one or more forms are constant and retrieve their values.
THINGS:
A list of bindings each of the form (VAR INITFORM).
Each INITFORM is evaluated and the result is checked whether it
is a constant form in the environment ENV. If so the constant
value is stored in VAR otherwise the resulting form (to which
INITFORM evaluates) itself is stored in VAR.
Alternatively each element of THINGS can be a symbol in which
case it is a shorthand for (VAR VAR).
ENV:
The environment in which to check whether the forms are
constants.
CLAUSES:
A list of clauses each of the form (VARS . FORMS), where
VARS is a list of variables, listed in THINGS, which should be
constant in order for the corresponding FORMS to be evaluated.
If all variables in VARS are constants FORMS are evaluated in an
implicit PROGN, with the result of the last form returned.
If not all of VARS are constant, FORMS are not evaluated and the next clause is tried. If no clause succeeds NIL is returned.
Introduce an identifier serving as a place to the current sequence element.
This macro may only be used within the body of a WITH-ITERATORS
macro.
A symbol-macro, with identifier NAME, is introduced which expands
to a place, suitable for use with SETF, to the current element of
the sequence, pointed by the iterator ITER. This symbol-macro is
visible to the body FORMS of the WITH-ITER-PLACE form.
If the iterator is already at the end of the sequence a non-local
jump, to the end of the enclosing WITH-ITERATORS form, is
performed.
Simultaneously the iterator is also advanced to the next element of
the sequence. However, the iterator is only guaranteed to be
advanced on a normal exit from the WITH-ITER-PLACE form. If a
non-local jump is used, via GO, RETURN-FROM or THROW, the iterator
might not be advanced.
NAME:
Identifier of the symbol-macro which is introduced.
NOTE: Unlike in WITH-ITER-VALUE this must be a symbol, and cannot
be a destructuring-bind pattern.
MOREP (Optional)
The name of the variable which is bound to true if there are more
elements in the sequence, and to NIL when there are no more
elements in the sequence.
If NON-NIL it is not checked whether the end of the sequence has
been reached, and hence the body FORMS are not skipped. It is up
to the programmer to check the value of this variable and perform
whatever logic should be performed when the end of the sequence
has been reached.
ITER:
Symbol identifying the iterator, as established by the
WITH-ITERATOR form.
This must name an iterator introduced in a parent WITH-ITERATORS
form.
FORMS:
List of forms evaluated in an implicit PROGN. The binding(s) for
the current element are visible to the forms.
NOTE: If there are no more elements in the sequence, the FORMS
are not evaluated and a non-local jump to the end of the
WITH-ITERATORS form is performed.
Bind the current element of a sequence, pointed to by a static iterator, to a variable.
This macro may only be used within the body of a WITH-ITERATORS
macro.
The current value of the sequence, with iterator ITER, is bound to
the variable(s) specified by PATTERN, with the bindings visible to
FORMS.
If the iterator is already at the end of the sequence a non-local
jump, to the end of the enclosing WITH-ITERATORS form, is
performed.
After binding, the iterator is advanced to the next element of the
sequence.
PATTERN:
A binding pattern specifying the variable(s) to which the current
element of the sequence is bound.
This may either be a symbol, naming a variable, or a list which
is interpreted as a pattern to ‘destructuring-bind‘.
ITER:
Symbol identifying the iterator, as established by the
WITH-ITERATORS form.
This must name an iterator introduced in a parent WITH-ITERATORS
form.
BODY:
The body of the WITH-ITER-VALUE form:
(DECLARATION* FORM*)
The body consists of a list of forms evaluated in an implicit
PROGN, with the value of the last form returned from the
WITH-ITER-VALUE form. The binding(s) introduced by PATTERN are
visible to forms.
The forms may be preceded by declaration expressions, which may
apply to the variables introduced in PATTERN.
NOTE: If there are no more elements in the sequence, the forms
are not evaluated and a non-local jump to the end of the
enclosing WITH-ITERATORS form is performed.
Like WITH-ITER-VALUE except multiple sequence elements are bound simultaneously.
BINDINGS:
A list of element value bindings, corresponding to the first
argument of WITH-ITER-VALUE, each of the form (PATTERN ITER).
((pattern-1 iter-1) (pattern-2 iter-2) ... (pattern-n iter-n))
This form is functionally equivalent to a series of nested
WITH-ITER-VALUE forms:
(with-iter-value (pattern-1 iter-1)
(with-iter-value (pattern-2 iter-2)
(...
(with-iter-value (pattern-n iter-n)
,@body))))
However unlike simply nesting WITH-ITER-VALUE forms, declarations
occurring in BODY are handled properly and associated with the
correct WITH-ITER-VALUE form, depending on which variable(s) they
apply to.
BODY:
The body of the WITH-ITER-VALUES form:
(DECLARATION* FORM*)
The body consists of a list of forms evaluate in an implicit
PROGN, with the value of the last form returned from the
WITH-ITER-VALUE form. The binding(s) introduced by PATTERN are
visible to forms.
The forms may be preceded by one or more declaration expressions,
which may apply to the variables introduced in any of the binding
patterns, in BINDINGS.
NOTE: If there are no more elements in at least of the sequences,
the forms are not evaluated and a non-local jump to the end of
the enclosing WITH-ITERATORS form is performed.
Create static iterators for one or more sequence.
This macro attempts to determine the type of each sequence, and calls
MAKE-DOSEQ to generate optimal static iterator code for the given
sequence types, rather than creating dynamic iterator objects.
SEQS:
A list where each element is of the form (ITER SEQUENCE . ARGS)
where ITER is a symbol identifying the iterator for the sequence,
SEQUENCE is the form which evaluates to a sequence, and ARGS are
the remaining iteration arguments, interpreted as they are to the
ITERATOR function.
Each iterator identifier (ITER) can be passed to
WITH-ITER-VALUE, within the body forms of WITH-ITERATORS, to
retrieve the values of the elements of the sequence.
The iterator identifiers are in a namespace of their own that is they do not name lexical variables/symbol-macros nor functions/macros.
FORMS:
A list of forms evaluated in an implicit TAGBODY, thus symbols
are interpreted as tag names.
The WITH-ITER-VALUE macro can be used, within FORMS, to retrieve
the current element of the sequence and advance the iterator to
the next position.
The WITH-ITER-PLACE macro can be used, within FORMS, both to
retrieve and set the value of the current element of the
sequence, and advance the iterator to the next position.
NOTE: The value of the last form is not returned, due to it being
evaluated in a TAGBODY, instead NIL is returned. RETURN-FROM, to
an outer BLOCK, should be used to return a value from this form.
NOTE: Whilst the intended use of WITH-ITERATORS is to implement
iteration macros, such as DOSEQ, the FORMS are only evaluated
once. It is up to the user to implement the actual loop, using
the provided TAGBODY facility.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
Returns true if at least one object in REST is not equal, by EQUALP, to FIRST.
Returns true if each object in REST is equal, by EQUALP, to FIRST.
Returns an hash map containing all entries in the association list ALIST. ARGS are the additional arguments passed to MAKE-HASH-MAP.
Return the value of a form if it is a constant.
FORM is a form.
ENV is the environment in which FORM is found.
Returns two values:
1. The constant value if the form is constant in the
environment. Otherwise is FORM itself.
2. True if the form is constant, otherwise is NIL.
If MAP is a ‘HASH-MAP’ returns it, otherwise if MAP is a ‘HASH-TABLE’ or ‘CUSTOM-HASH-TABLE’ returns a ‘HASH-MAP’ which wraps it. Signals an error if MAP is not of the aforementioned types.
Same as CL:EVERY except it can be applied to any sequence for which there the iterator interface is implemented.
Applies FUNCTION on each element of each sequence in SEQUENCES.
Returns an ALIST containing all the entries (key-value pairs) in the hash-map MAP.
Returns the TEST function (as a symbol) of the underlying hash-table of the ‘HASH-MAP’ MAP.
Returns a ‘HASH-SET’ with elements ELEMENTS.
Returns an iterator for the sub-sequence of SEQUENCE bounded by the
range [START, END).
START is the index of the first element to iterate over. Defaults
to 0.
END is the index of the element at which to terminate the
iteration, the element itself is not visited. If END is NIL then
the iteration continues till the end of the sequence. Defaults to
NIL.
If FROM-END is T the elements are iterated in reverse
order. Defaults to NIL.
Equivalent to CL:LAST. Returns the CDR of the N’th CONS cell from the last CONS cell in LIST.
head.
tail.
Creates a hash map.
If TEST is GENERIC-CL:EQUALP (the default), a generic hash-table,
with GENERIC-CL:HASH as the hash function and GENERIC-CL:EQUALP as
the comparison function, is created.
If TEST is GENERIC-CL:LIKEP, a generic hash-table with
GENERIC-CL:LIKE-HASH as the hash function and GENERIC-CL:LIKEP as
the comparison function, is created.
If another value for TEST (the available options are specified in
the documentation for CL:MAKE-HASH-TABLE) is given, the native hash
function is used.
The remaining keyword arguments accepted by CL:MAKE-HASH-TABLE, are
also accepted by this function.
The return value is always a HASH-MAP which wraps either the generic or Common Lisp hash-table.
Creates a ‘HASH-SET’. The keyword arguments accepted by MAKE-HASH-MAP are accepted by MAKE-HASH-SET.
Returns the maximum argument, the argument that is greater than or equal to all the other arguments, the actual comparisons are done using GREATERP. Any argument which satisfies this condition may be returned.
Returns the minimum argument, the argument that is less than or equal to all the other arguments, the actual comparisons are done using LESSP. Any argument which satisfies this condition may be returned.
Same as CL:NOTANY except it can be applied to any sequence for which there the iterator interface is implemented.
Same as CL:NOTEVERY except it can be applied to any sequence for which there the iterator interface is implemented.
Returns true if each form in ARGS evaluates (within the lexical environment ENV) to a type that is a subtype of NUMBER.
Returns a ‘LAZY-SEQ’ containing all numbers in the range [START, END). If END is NIL then an infinite sequence, without an upper bound is returned. STEP is the delta by which each number is incremented to obtain the next successive number.
Creates a sequence of the type TYPE by calling
MAKE-SEQUENCE-OF-TYPE.
If TYPE is a list, MAKE-SEQUENCE-OF-TYPE is called with the CAR of the list as the first argument, and the CDR of the list as the second argument. Otherwise MAKE-SEQUENCE-OF-TYPE is called with TYPE as the first argument and NIL as the second argument.
Same as CL:SOME except it can be applied to any sequence for which there the iterator interface is implemented.
Returns A + 1.
Returns A - 1.
Returns the absolute value of A.
Adds ITEM to the sequence with collector COLLECTOR.
front-vector-collector) item) ¶vector) item) ¶front-list-collector) item) ¶list-collector) item) ¶Returns the arc cosine of A.
number)) ¶Returns the hyperbolic arc cosine of A.
number)) ¶Returns the sum of A and B.
number) (b number)) ¶Returns a new set which contains ITEM and all elements in set SET.
Methods specialized on lists also accept TEST and KEY keyword parameters. These parameters are ignored by other methods.
list) &key test key) ¶Returns a new sequence that is a copy of SEQUENCE with size
changed to SIZE.
If SIZE is less than the current number of elements in SEQUENCE, the remaining elements after the first SIZE elements, are removed. If SIZE is greater than the number of elements in SEQUENCE, elements, with value ELEMENT (default NIL), should be appended to SEQUENCE such that it has SIZE elements.
Advances ITERATOR to the next element of the sequence.
bound-lazy-seq-iterator)) ¶lazy-seq-iterator)) ¶sub-iterator)) ¶reverse-vector-iterator)) ¶vector-iterator)) ¶bound-list-iterator)) ¶list-iterator)) ¶Advances the iterator ITERATOR N positions, advances to the position that the iterator would be at after calling ADVANCE N times.
sub-iterator) n) ¶reverse-vector-iterator) n) ¶vector-iterator) n) ¶Returns the arc sine of A.
number)) ¶Returns the hyperbolic arc sine of A.
number)) ¶Returns the element at the position specified by ITERATOR. Is not guaranteed to check whether the end of the sequence has been reached.
lazy-seq-iterator)) ¶sub-iterator)) ¶reverse-array-iterator)) ¶Access the element of the array at the current position using ROW-MAJOR-AREF.
array-iterator)) ¶Access the element of the array at the current position using ROW-MAJOR-AREF.
vector-iterator)) ¶reverse-list-iterator)) ¶list-iterator)) ¶Sets the value at the position of the sequence at which ITERATOR is currently at.
hash-table-iterator)) ¶Sets the value corresponding to the current key being iterator (CAR (AT ITER)) to VALUE.
sub-iterator)) ¶reverse-array-iterator)) ¶array-iterator)) ¶vector-iterator)) ¶reverse-list-iterator)) ¶list-iterator)) ¶Returns the arc tangent of A. If B is supplied, returns the arc tangent of A/B.
number) &optional b) ¶Returns the hyperbolic arc tangent of A.
number)) ¶Returns N, or N/D if D is provided, rounded towards positive infinity, and the remainder of the division if any.
real) &optional d) ¶Returns a complex number equal to cos(A) + i*sin(A) where A is in radians.
Destructively removes all elements from SEQUENCE.
Creates a new sequence of the same type and with the same properties as SEQUENCE however without any elements.
Coerces the OBJECT to the type RESULT-TYPE.
hash-map) (type (eql trivia.level2:plist))) ¶Returns a PLIST containing all the entries (key-value pairs) in the hash-map MAP.
hash-map) (type (eql trivia.level2:alist))) ¶Returns an ALIST containing all the entries (key-value pairs) in the hash-map MAP.
Returns the sequence associated with the collector COLLECTOR.
Calling this method is necessary, when no more items will be added to the sequence, as the original sequence passed to MAKE-COLLECTOR might not have been destructively modified.
front-vector-collector)) ¶vector)) ¶front-list-collector)) ¶list-collector)) ¶Returns :LESS if A is less than B (LESSP A B), :GREATER if A is greater than B (GREATERP A B) or :EQUAL if A is equal to B (EQUALP A B).
Returns a new sequence, of the same type as SEQUENCE, containing all the elements of SEQUENCE and of each sequence in SEQUENCES, in the order they are supplied.
Returns a sequence of type TYPE containing all the elements of each sequence in SEQUENCES, in the order they are supplied.
Returns the complex conjugate of A.
Returns a copy of OBJECT. Some methods may accept additional
keyword arguments which allow options, on how the object is to be
copied, to be specified.
Methods specialized on sequences or collections should accept the :DEEP keyword argument which if provided and is true, the objects contained in the sequence/collection should be copied as well otherwise (if not provided or is NIL) only the sequence/collection itself should be copied.
hash-table) &key deep) ¶sub-iterator) &key) ¶Returns a copy of a ‘SUB-ITERATOR’ which contains a copy of the sequence’s iterator stored in the ITER slot.
Default method, does not copy OBJECT.
structure-object) &key) ¶array) &key deep) ¶vector) &key deep) ¶cons) &key deep) ¶Returns the cosine of A (radians).
number)) ¶Returns the hyperbolic cosine of A.
number)) ¶Same as CL:COUNT however is extensible to other sequence types
besides CL:SEQUENCE.
The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.
Same as CL:COUNT-IF however is extensible to other sequence types besides CL:SEQUENCE.
Same as CL:COUNT-IF-NOT however is extensible to other sequence types besides CL:SEQUENCE.
Same as CL:DELETE however is extensible to other sequence types
besides CL:SEQUENCE.
The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.
Same as CL:DELETE-DUPLICATES however is extensible to other
sequence types besides CL:SEQUENCE.
The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.
lazy-seq) &key from-end test start end key) ¶Same as the REMOVE-DUPLICATES method specialized on ‘LAZY-SEQ’.
sequence) &key from-end test start end key) ¶Same as CL:DELETE-IF however is extensible to other sequence types besides CL:SEQUENCE.
lazy-seq) &key from-end start end count key) ¶Same as the REMOVE-IF method specialized on ‘LAZY-SEQ’
sequence) &key from-end end start count key) ¶Same as CL:DELETE-IF-NOT however is extensible to other sequence types besides CL:SEQUENCE.
Returns the numerator of A.
number)) ¶Returns the quotient of A and B. If A is the constant 1, should return the reciprocal of B.
number) (b number)) ¶Returns the element at index INDEX of SEQUENCE.
Returns the element at index INDEX of the generic sequence SEQUENCE.
This is implemented by creating an iterator for sequence with start position INDEX, and returning the first element returned by the iterator.
hash-table) key) ¶array) (indices list)) ¶array) (index integer)) ¶vector) index) ¶sequence) index) ¶Sets the element at index INDEX of sequence SEQUENCE to VALUE.
Sets the value of the element at index INDEX of the generic
sequence SEQUENCE.
This is implemented by creating an iterator for sequence with start position INDEX, and setting the value of the element at the iterator’s starting position.
hash-table) key) ¶array) (indices list)) ¶array) (index integer)) ¶vector) index) ¶sequence) index) ¶Returns true if SEQUENCE is empty.
lazy-seq)) ¶Always returns NIL as NIL is used to indicate an empty ‘LAZY-SEQ’. a ‘LAZY-SEQ’ object always contains at least one element.
Returns true if an iterator created for SEQUENCE is immediately at its end position (ENDP returns true).
hash-table)) ¶array)) ¶Always returns false as a multi-dimensional array can never be empty.
vector)) ¶list)) ¶Returns true if ITERATOR points to the end of the sequence.
bound-lazy-seq-iterator)) ¶lazy-seq-iterator)) ¶sub-iterator)) ¶reverse-vector-iterator)) ¶vector-iterator)) ¶bound-list-iterator)) ¶list-iterator)) ¶Generic equality comparison function. Returns true if objects A and B are equal.
hash-set) (b hash-set)) ¶Returns true if the ‘HASH-SETS’ A and B have the same number of elements and each element of A is also an element of B.
hash-map) (b hash-map)) ¶Hash-table comparison method. Returns true if both hash-tables have
the same number of entries, and the value corresponding to each key
in A is equal (by EQUALP) to the value corresponding to the same
key in B.
NOTE: Hash-table equality is not necessarily symmetric if the test functions of the two hash-tables are different.
Default equality comparison method. Returns true if objects A and B are the same object, compared using CL:EQ.
pathname) (b pathname)) ¶Returns true if both ‘pathname’ objects are equal by CL-FAD:PATHNAME-EQUAL.
string) (b string)) ¶Returns true if both strings are equal by CL:STRING=
array) (b array)) ¶Multi-dimensional array equality comparison method. Returns true if both arrays have the same dimensions and each element of A is equal (by EQUALP) to the corresponding element of B.
vector) (b vector)) ¶Array equality comparison method. Returns true if both arrays are of the same length and each element of A is equal (by EQUALP) to the corresponding element of B.
cons) (b cons)) ¶CONS equality comparison method. Returns true if the CAR of A is equal to the CAR of B (compared using EQUALP) and the CDR of A is equal to the CDR of B (compared using EQUALP).
character) (b character)) ¶Character equality comparison method. Returns true if A and B represent the same character, compared using CL:CHAR=.
number) (b number)) ¶Numeric equality comparison method. Returns true if A and B represent the same numeric value, compared using CL:=.
Removes the element at index INDEX from the sequence SEQUENCE.
Returns true if A is even.
Returns the natural exponent of power (e^POWER).
number)) ¶Returns BASE raised to the power POWER.
number) (p number)) ¶Adds each item in SEQUENCE to the sequence with collector COLLECTOR.
list-collector) (list list)) ¶Destructively replaces the elements of SEQUENCE between START and END with ITEM. Returns SEQUENCE.
Same as CL:FIND however is extensible to other sequence types
besides CL:SEQUENCE.
The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.
Same as CL:FIND-IF however is extensible to other sequence types besides CL:SEQUENCE.
Same as CL:FIND-IF-NOT however is extensible to other sequence types besides CL:SEQUENCE.
Same as FIND but returns an iterator to the found item rather than the item itself.
Same as FIND-IF but returns an iterator to the found item rather than the item itself.
Same as FIND-IF-NOT but returns an iterator to the found item rather than the item itself.
Returns the first element of SEQUENCE.
Returns the first element of the generic sequence. Implemented using ELT.
hash-table)) ¶array)) ¶vector)) ¶list)) ¶Returns N, or N/D if D is provided, rounded towards negative infinity, and the remainder of the division if any.
real) &optional d) ¶Returns the value of the entry corresponding to the key KEY in the
map MAP. If the map does not contain any entry with that key,
DEFAULT is returned.
Returns two values: the value and true if an entry with the key KEY was found in the map, false otherwise.
Sets the value of the entry corresponding to the key KEY in the map MAP. DEFAULT is ignored.
hash-table) &optional default) ¶Returns true if A compares greater than or equal to B.
Returns true if A compares greater than B.
HASH function for ‘HASH-MAPS’s with the GENERIC-CL:EQUALP test function.
This function should return the same hash code for objects which
are equal by GENERIC-CL:EQUALP.
For further details on the constraints on the hash code see the documentation for CL:SXHASH.
Returns the imaginary part of A.
number)) ¶Returns the set intersection of SET1 and SET2. The set returned
contains all elements that occur in both SET1 and SET2.
Methods specialized on lists also accept TEST, TEST-NOT and KEY keyword parameters. These parameters are ignored by other methods.
Returns the largest integer smaller than or equal to the positive square root of A.
number)) ¶Returns the N’th (default 0) element from the last element of SEQUENCE.
Returns the nth element from the last element of the generic sequence. Implemented using ELT and LENGTH.
array) &optional n) ¶vector) &optional n) ¶list) &optional n) ¶Returns the number of elements in SEQUENCE.
iterator)) ¶Returns the number of elements between the current position of the iterator and its end. This is achieved by iterating until ENDP returns true using a copy of IT.
Returns the number of elements in SEQUENCE, where SEQUENCE is of a
type for which the iterator interface is implemented.
The type is computed by iterating through the entire sequence, thus this is a linear O(n) operation, in the number of elements in the sequence.
hash-table)) ¶sub-iterator)) ¶reverse-vector-iterator)) ¶vector-iterator)) ¶bound-list-iterator)) ¶array)) ¶Returns the total number of elements in the multi-dimensional array ARRAY.
vector)) ¶Returns the number of elements in the vector VEC.
sequence)) ¶Generic CL:SEQUENCE method, calls CL:LENGTH.
Returns true if A compares less than or equal to B.
Returns true if A compares less than B.
HASH function for ‘HASH-MAPS’s with the LIKEP test function.
This function should return the same hash code for objects which
compare equal by GENERIC-CL:LIKEP.
For further details on the constraints on the hash code see the documentation for CL:SXHASH.
Generic similarity comparison function for checking whether two objects are similar rather than strictly equal. Similarity ignores certain differences between objects, such as case differences between strings.
hash-map) (b hash-map)) ¶Returns true if both hash-tables have the same number of entries,
and the value corresponding to each key in A is similar (by LIKEP)
to the value corresponding to the same key in B.
NOTE: This method requires that there is an implementation of LIKEP
and LIKE-HASH for each key type in A and B.
NOTE: Hash-table similarity is not necessarily symmetric if the test functions of the two hash-tables are different.
Compares A and B using GENERIC-CL:EQUALP
string) (b string)) ¶Returns true if both strings are equal, by CL:STRING-EQUAL, ignoring differences in case.
array) (b array)) ¶Returns true if both arrays have the same dimensions and each element of A is similar (by LIKEP) to the corresponding element of B.
vector) (b vector)) ¶Returns true if both vectors are of the same length and each element of A is similar (by LIKEP) to the corresponding element of B.
cons) (b cons)) ¶Returns true if the CAR of A is similar to the CAR of B (by LIKEP) and the CDR of A is similar to the CDR of B (by LIKEP).
character) (b character)) ¶Returns true if A and B represent the same character, ignoring case. Compared using CL:CHAR-EQUAL
Returns the logarithm of N in base BASE. If BASE is not supplied, the natural logarithm of N is returned.
number) &optional base) ¶Returns a collector for adding items to SEQUENCE. If :FRONT is true the items will be added to the front of the sequence rather than the back.
lazy-seq) &key front) ¶Returns a collector for collecting items onto a list containing the same elements as the sequence.
vector) &key front) ¶list) &key front) ¶Returns an iterator for elements of the sub-sequence of SEQUENCE,
bounded to the range [START, END).
START is the index of the first element to iterate over.
END is the index of the element at which to terminate the iteration, the element itself is not visited. If END is NIL then the iteration continues till the end of the sequence.
hash-table) start end) ¶hash-map) start end) ¶Create an iterator for the elements of a ‘hash-map where each element is a CONS of the form (KEY . VALUE). The order in which the elements are iterated is unspecified, likewise there is no guarantee which elements will be iterated over if START is not 0 and END is not NIL.
array) start end) ¶vector) start end) ¶list) start (end number)) ¶list) start (end null)) ¶Same as MAKE-ITERATOR except the elements should be iterate over in reverse order.
lazy-seq) start end) ¶Accumulates the elements of SEQ, between START and END, into a list, in reverse order, and returns an iterator for the list.
hash-table) start end) ¶hash-map) start end) ¶Create a reverse iterator for the elements of a ‘hash-table’. Since the order of iteration is unspecified this is identical to MAKE-ITERATOR.
array) start end) ¶vector) start end) ¶list) start end) ¶list) start (end null)) ¶Creates a sequence of the type TYPE. If the type was a list TYPE is the first element of the list and ARGS are the remaining elements. If the type was a symbol TYPE is the symbol and ARGS is NIL.
Creates a new sequence, of the same type as SEQUENCE (by CLEARED), containing the result of applying FUNCTION to each element of SEQUENCE and each element of each SEQUENCE in SEQUENCES.
Like MAP-EXTEND-TO except the first resulting sequence is of the same type as SEQUENCE.
Like MAP-EXTEND-TO except the results are accumulated directly into RESULT. Result may be destructively modified however this is not guaranteed, thus this function should only be used for its return value, not its side effects.
Applies FUNCTION on each respective element of SEQUENCE and SEQUENCES and accumulates the result, which is expected to be a sequence, into a sequence, of type TYPE, using EXTEND.
Applies FUNCTION on each element of each sequence in SEQUENCES and stores the result in RESULT, using the collector interface.
Returns a sequence containing all the keys in MAP.
hash-table)) ¶Applies FUNCTION to each element of each sequence in SEQUENCES and stores the result in a new sequence of type TYPE. Returns the sequence in which the results of applying function are stored.
Returns a sequence containing all the values in MAP.
hash-table)) ¶Returns true if ITEM is an element of the set SET.
Methods specialized on lists also accept TEST and KEY keyword parameters. These parameters are ignored by other methods.
list) &key test key) ¶Returns a new sequence (of the same type as SEQUENCE1) containing
the elements of SEQUENCE1 and SEQUENCE2. The elements are ordered
according to the function PREDICATE.
PREDICATE is a function of two arguments (an element from
SEQUENCE1 and an element from SEQUENCE2), which should return true
if and only if the first argument is strictly less than the second
argument.
KEY is a function of one argument, that is called (if it is
non-NIL) on each element of SEQUENCE1 and SEQUENCE2 with the
result passed on to the PREDICATE function.
Unlike CL:MERGE this function is non-destructive.
Returns true if A is less than 0.
Same as CL:MISMATCH however is extensible to other sequence types
besides CL:SEQUENCE.
The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.
Returns the remainder of the floor operation on N and D.
Returns the product of A and B.
number) (b number)) ¶Same as ADJOIN however is permitted to destructively modify SET.
Same as ADJUST however is permitted to destructively modify SEQUENCE.
Destructively concatenates each sequence in SEQUENCES to the sequence RESULT.
Returns the negation of A.
number)) ¶Same as INTERSECTION however is permitted to destructively modify SET1 or SET2.
Destructively replaces each element of RESULT with the result of
applying FUNCTION to each element of RESULT and each element of
each sequence in SEQUENCES.
The shortest sequence of RESULT and SEQUENCE determines how many
times FUNCTION is applied and how many elements are in the
resulting sequence. If RESULT is longer than any sequence in
SEQUENCE the remaining elements are unmodified.
Unlike CL:MAP-INTO, if RESULT is a vector then FUNCTION is only
applied on the elements up-to the fill-pointer, i.e. the
fill-pointer is not ignored.
Returns RESULT.
Same as MERGE however is permitted to destructively modify either SEQUENCE1 or SEQUENCE2.
Same as REVERSE however SEQUENCE may be modified.
Same as SET-DIFFERENCE however is permitted to destructively modify SET1 or SET2.
Same as SET-EXCLUSIVE-OR however is permitted to destructively modify SET1 or SET2.
Same as SORT however is permitted to destructively modify SEQUENCE.
Same as CL:NSUBSTITUTE however is extensible to other sequence
types besides CL:SEQUENCE.
The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.
Same as CL:NSUBSTITUTE-IF however is extensible to other sequence types besides CL:SEQUENCE.
lazy-seq) &key from-end start end count key) ¶Same as the SUBSTITUTE-IF method specialized on ‘LAZY-SEQ’.
sequence) &key from-end start end count key) ¶Same as CL:NSUBSTITUTE-IF-NOT however is extensible to other sequence types besides CL:SEQUENCE.
Returns the numerator of A.
number)) ¶Same as UNION however is permitted to destructively modify SET1 or SET2.
Returns true if A is odd.
Returns the phase of A (the angle of the polar representation of A).
Returns true if A is greater than 0
Same as CL:POSITION however is extensible to other sequence types
besides CL:SEQUENCE.
The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.
Same as CL:POSITION-IF however is extensible to other sequence types besides CL:SEQUENCE.
Same as CL:POSITION-IF-NOT however is extensible to other sequence types besides CL:SEQUENCE.
Returns a rational equivalent to A, assuming the floating point representation is completely accurate.
number)) ¶Returns a rational equivalent to A, assuming the floating point representation is accurate only to the floating-point precision.
number)) ¶Returns the real part of A.
number)) ¶Same as CL:REDUCE however is extensible to other sequence types besides CL:SEQUENCE.
Returns the remainder of the truncate operation on N and D.
Same as CL:REMOVE however is extensible to other sequence types
besides CL:SEQUENCE.
The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.
Same as CL:REMOVE-DUPLICATES however is extensible to other
sequence types besides CL:SEQUENCE.
The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.
lazy-seq) &key from-end test start end key) ¶Lazily removes duplicate items from a ‘LAZY-SEQ’. Only returns a ‘LAZY-SEQ’ if FROM-END is true.
sequence) &key from-end test start end key) ¶Same as CL:REMOVE-IF however is extensible to other sequence types besides CL:SEQUENCE.
lazy-seq) &key from-end start end count key) ¶Lazily removes items from a ‘LAZY-SEQ’. A ‘LAZY-SEQ’ is only returned if either FROM-END or COUNT is FALSE.
sequence) &key from-end end start count key) ¶Same as CL:REMOVE-IF-NOT however is extensible to other sequence types besides CL:SEQUENCE.
Destructively replaces the elements of SEQUENCE1, between START1 and END1, with the elements of SEQUENCE2, between START2 and END2.
Returns a new sequence of the same type as SEQUENCE and with the same elements in reverse order.
Returns N, or N/D if D is provided, rounded towards the nearest integer. If the quotient lies exactly halfway between two integers it is rounded to the nearest even integer.
real) &optional d) ¶Same as CL:SEARCH however is extensible to other sequence types
besides CL:SEQUENCE.
The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.
Returns the set difference of SET1 and SET2. The set returned contains all the elements of SET1 that do not appear in SET1.
Methods specialized on lists also accept TEST, TEST-NOT and KEY keyword parameters. These parameters are ignored by other methods.
Returns a set containing all elements that appear in exactly one
of SET1 and SET2.
Methods specialized on lists also accept TEST, TEST-NOT and KEY keyword parameters. These parameters are ignored by other methods.
Returns -1 - if A is negative, 0 - if A is zero or 1 if A is positive
Returns the sine of A (radians).
number)) ¶Returns the hyperbolic sine of A.
number)) ¶Returns a new sequence of the same type as SEQUENCE, with the same
elements sorted according to the order determined by the function
TEST.
TEST is a function of two arguments, which should return true if
and only if the first argument is strictly less than the
second. By default, TEST is GENERIC-CL:LESSP.
If KEY is provided and is not NIL it is called on each element and the result returned by the function is passed on to TEST.
Returns the square root of A.
number)) ¶Same as STABLE-SORT however is permitted to destructively modify SEQUENCE.
Same as SORT however the sort operation is guaranteed to be stable, that is the order of elements which compare equal, under TEST, will be preserved.
Returns the element at the position specified by ITERATOR or NIL if the ITERATOR points to the end of the sequence.
Returns a new sequence that is the sub-sequence of SEQUENCE between START and END.
bound-lazy-seq-iterator) start &optional end) ¶lazy-seq-iterator) start &optional end) ¶hash-table-iterator) start &optional end) ¶sub-iterator) start &optional end) ¶iterator) start &optional end) ¶Returns an iterator for the subseqeunce [START, END) of the sequence with iterator IT. Both START and END are interpreted relative to the position of the iterator IT within its sequence.
reverse-array-iterator) start &optional end) ¶array-iterator) start &optional end) ¶reverse-vector-iterator) start &optional end) ¶vector-iterator) start &optional end) ¶reverse-list-iterator) start &optional end) ¶bound-list-iterator) start &optional end) ¶list-iterator) start &optional end) ¶sequence) start &optional end) ¶Replaces the elements of SEQUENCE between START and END with the elements of NEW-SEQUENCE. The shorter of the length of NEW-SEQUENCE and the number of elements between START and END determines how many elements of SEQUENCE are actually modified.
Returns true if the set SET1 is a subset of the set SET2.
Methods specialized on lists also accept TEST and KEY keyword parameters. These parameters are ignored by other methods.
Same as CL:SUBSTITUTE however is extensible to other sequence
types besides CL:SEQUENCE.
The default TEST function is GENERIC-CL:EQUALP. The TEST-NOT argument is removed.
Same as CL:SUBSTITUTE-IF however is extensible to other sequence types besides CL:SEQUENCE.
lazy-seq) &key from-end start end count key) ¶Lazily substitutes elements, in a ‘LAZY-SEQ’ which satisfy TEST, with NEW.
sequence) &key from-end start end count key) ¶Same as CL:SUBSTITUTE-IF-NOT however is extensible to other sequence types besides CL:SEQUENCE.
Returns the difference of A and B.
Returns the tangent of A (radians).
number)) ¶Returns the hyperbolic tangent of A.
number)) ¶Returns N, or N/D if D is provided, rounded towards zero, and the remainder of the division if any.
real) &optional d) ¶Returns the set union of SET1 and SET2. The set returned contains
all elements of SET1 and SET2.
Methods specialized on lists also accept TEST, TEST-NOT and KEY keyword parameters. These parameters are ignored by other methods.
Returns true if A is zero.
Hash-table wrapper for Common Lisp hash-tables and generic hash
tables.
The TABLE slot stores the actual hash-table which may either be a native hash table or a CL-CUSTOM-HASH-TABLE:CUSTOM-HASH-TABLE. On implementations which provide functionality for specifying a custom hash function, this slot always contains a CL:HASH-TABLE.
structure-object.
accumulate.
add.
adjoin.
clear.
cleared.
coerce.
coerce.
collector-sequence.
copy.
(setf elt).
elt.
emptyp.
equalp.
erase.
first.
(setf get).
get.
intersection.
length.
likep.
make-collector.
make-iterator.
make-load-form.
make-reverse-iterator.
map-keys.
map-values.
memberp.
nadjoin.
nintersection.
nset-difference.
nset-exclusive-or.
nunion.
set-difference.
set-exclusive-or.
subsetp.
subtract.
union.
Set data structure implemented using hash tables.
This structure is equivalent to the ‘HASH-MAP’ structure, in-fact all set methods also work on ‘HASH-MAP’s as well as ‘HASH-SET’s. However this structure should be used to indicate that the values stored in the hash table are unimportant. Some methods, specialized on ‘HASH-SET’, will ignore the hash-table values.
Base iterator type. All iterators should inherit (:INCLUDE) from this type in order for methods which specialize on iterators to be chosen.
structure-object.
Lazy sequence where the elements are only computed when they are actually referenced. The first element of the sequence is stored in HEAD. TAIL stores a function which, when called, returns the ‘LAZY-SEQ’ containing the remaining elements in the sequence. If there are no remaining elements the function in TAIL returns NIL.
Like DO-ITER-VALUES but instead of binding the value of each sequence element, to variables, by WITH-ITER-VALUE, a symbol-macro expanding to the ’place’ of the current sequence element, is introduced, as if by WITH-ITER-PLACE.
Optimized expansion of DO-SEQUENCES!.
Generates optimized iteration code for the sequence types using MAKE-DOSEQ.
Expansion of DO-SEQUENCES! into DOITERS without optimization.
This macro is meant to be used internally when an optimization policy of (SAFETY 3) is used.
Optimized expansion of DO-SEQUENCES.
Generates optimized iteration code for the sequence types using MAKE-DOSEQ.
Expansion of DO-SEQUENCES into DOITERS without optimization.
This macro is meant to be used internally when an optimization policy of (SAFETY 3) is used.
Generate a lexical macro definition for WITH-ITER-VALUE/PLACE for an iterator.
This macro is intended to be used within MAKE-DOSEQ to facilitate
the definition, by avoiding the need for nested backquotes, of the
lexical macros, serving as the expansion of WITH-ITER-VALUE and
WITH-ITER-PLACE for a given iterator type.
VARS is a list of variables to ’capture’ from the lexical scope of
the ITER-MACRO form. Inside the generated macro definition, a
symbol-macro is introduced for each variable, by SYMBOL-MACROLET,
which expands to a QUOTE form which returns the value of the
variable as it is in the environment where the ITER-MACRO form
occurs.
LAMBDA-LIST is the macro lambda-list (not evaluated).
BODY is the list of body forms of the generated macro. These are
not evaluated at the time the ITER-MACRO form is evaluated but are
instead quoted and become the body forms of the generated macro
definition. The body forms may reference the variables in the
LAMBDA-LIST and the values of the ’captured’ variables listed in
VARS.
Returns a lexical macro definition (excluding the name) suitable to
be returned from MAKE-DOSEQ as the macro definition for the
iterator’s WITH-ITER-VALUE and WITH-ITER-PLACE.
Generate optimized code for an optimized sequence function.
The macro expands to a form which generates a DO-SEQUENCES forms
with the elements of the sequence in SEQS, bound to gensym’d
variables. The DO-SEQUENCE form is followed by the form RESULT with
the entire generated form wrapped in a BLOCK.
VARS is the name of a variable which is bound to the list of the
GENSYM’d names of the variables bound to the elements of the
sequences.
BLOCK is a variable bound to the name of the block in which the
entire generated code is contained.
SEQS (evaluated) is the list of forms which are placed in the
sequences of the DO-SEQUENCES forms.
RESULT (evaluated) is the form which is placed last in the
generated BLOCK, thus its value is returned if there is no
non-local exit from the block.
BODY is evaluated, in an implicit PROGN, the result of which is spliced into the body of the generated DO-SEQUENCES form. The bindings to VARS and BLOCK are available to the forms in BODY.
Split a ’body’ into declare expressions and the forms to be evaluate.
DECL is the name of the variable to receive the list of DECLARE
expressions.
FORMS is the name of the variable to receive the body forms.
BODY-FORM is a form (evaluated) which produces the body.
BODY is the list of forms, evaluated in an implicit PROGN with DECL and FORMS bound to the declarations and forms respectively. The value of the last form is returned.
Creates a function, with no arguments, which, when called for the first time returns the result of evaluating FORM. This result is stored such that in future invocations of the function, it will be returned without re-evaluating FORM.
Like WITH-DESTRUCTURE-PATTERN, except that FORMS should generate code which binds the current entry key to KEY and the value to VALUE.
Automatically generate destructuring code if the binding pattern is
a destructuring-bind pattern.
The WITH-ITER-VALUE binding pattern, PATTERN, is checked whether it
is a symbol naming a variable or a list representing a
DESTRUCTURING-BIND pattern.
If PATTERN is a list, a variable name is generated, and bound to
the variable VAR. BODY-VAR is bound to forms which destructure the
value stored in the variable, wrapping the forms in BODY.
If PATTERN is a symbol, the variable given by VAR is bound directly
to that symbol and the variable given by BODY-VAR is bound directly
to BODY.
DECL-VAR is the name of a variable which receives the list of
DECLARE expressions applying to the variable, given by VAR. These
should be inserted in the correct place, where VAR is bound, in the
result returned.
The body forms of the macro FORMS are evaluated in an implicit
PROGN, with the bindings to the variables given by VAR and BODY-VAR
visible. The return value of the last form is interpreted as the
body form making up the WITH-ITER-VALUE expansion returned.
FORMS should generate code which binds the current sequence element
to the variable with name stored in VAR.
This macro automatically takes care of handling declarations, that is if the list returned by BODY contains declarations, those applying to the variables in the destructuring pattern are inserted in the ‘destructuring-bind‘ form, DECL-VAR is bound to those which apply to the variable VAR, and a LOCALLY form, wrapping the form returned by FORMS, is generated in which the remaining declarations are inserted.
Like WITH-ITER-PLACE except for multiple sequences.
BINDINGS:
A list of element value bindings, corresponding to the first
argument of WITH-ITER-PLACE, each of the form (NAME ITER)
or (NAME ITER MOREP).
((name-1 iter-1) (name-2 iter-2) ... (name-n iter-n))
This form is functionally equivalent to a series of nested
WITH-ITER-PLACE forms:
(with-iter-place (name-1 iter-1)
(with-iter-place (name-2 iter-2)
(...
(with-iter-place (name-n iter-n)
,@body))))
However unlike simply nesting WITH-ITER-PLACE forms, declarations
occurring in BODY are handled properly and associated with the
correct WITH-ITER-PLACE form, depending on which variable(s) they
apply to.
BODY:
The body of the WITH-ITER-PLACE form:
(DECLARATION* FORM*)
The body consists of a list of forms evaluate in an implicit
PROGN, with the value of the last form returned from the
WITH-ITER-PLACE form. The symbol-macros introduced in BINDINGS
are visible to the forms.
The forms may be preceded by one or more declaration expressions,
which may apply to the variables introduced in any of the binding
patterns, in BINDINGS.
NOTE: If there are no more elements in at least of the sequences, and there is no corresponding MOREP variable for the sequence, the forms are not evaluated and a non-local jump to the end of the enclosing WITH-ITERATORS form is performed.
Split a body into the declarations, applying to specific variables, and the forms.
BINDINGS:
List specifying for which variables to extract the declarations.
Each element is of the form (DECL-VAR VAR), where DECL-VAR is the
name of the variable which is to receive the list of declarations
applying to the variable given by VAR (evaluated).
FORMS-VAR:
Name of the variable to receive the list of forms.
BODY-FORM:
The body to split (evaluated).
BODY:
The macro body forms evaluated in an implicit PROGN. The value
returned by the last form is included in the result returned.
The value returned by the macro is a LOCALLY form containing the
declarations not applying to any of the variables listed in
BINDINGS and the body of which is the form returned by the last
form in BODY.
A no-op on SBCL since static dispatching is handled by the compiler transforms, rather than compiler macros.
static-dispatch.
Advances each iterator in ITERS to its next position (by ADVANCE).
end.
end.
Collects the elements of SEQUENCE in the range [0, START), and from
END till the end of the sequence. Calls OP to perform an operation
on the remaining range.
If FROM-END is true COLLECTOR should be a collector to the front of a sequence.
Returns a new ‘LAZY-SEQ’ which contains the first START elements of SEQ. The function OP is applied on the remaining sequence of elements, of SEQ, to obtain the remainder of the sequence that is returned.
Returns a copy of the multi-dimensional ARRAY which contains a copy (by COPY) of each object contained in it.
Returns a copy of LIST which contains a copy (by COPY) of each object contained in it.
Returns a copy of the vector VEC which contains a copy (by COPY) of each object contained in it.
Return the list of variables introduced by a destructuring-lambda-list.
LAMBDA-LIST is a destructuring-lambda-list as found in
DESTRUCTURING-BIND. It should not have &ENVIRONMENT parameters.
Returns the list of all variables introduced by the lambda-list,
not in any particular order.
NOTE: If the lambda-list is malformed, or an unknown lambda-list keyword is encountered, this function simply returns the variable names it has encountered so far, and silently ignores the remaining malformed part.
cons.
Returns a list containing the elements at the positions of each iterator in ITERS (by AT).
Returns an ALIST containing the elements of the hash map MAP. START and END determine the number of elements that will be returned. If START is zero and END is NIL all elements are included in the ALIST.
Returns true if TEST is a valid hash-table test function.
Returns a list containing the elements of the hash set SET,
i.e. the keys of the underlying hash table. START and END determine
the number of elements that will be returned. If START is zero and
END is NIL all elements are returned.
Returns a list containing the keys in the hash table TABLE.
Returns a list containing the values in the hash table TABLE.
Retrieve the association list mapping iterator identifiers to the names of the macros serving as the expansion of WITH-ITER-PLACE when given those iterator identifiers. This information is retrieved from the environmnet ENV by macroexpanding the symbol-macro ITER-PLACE-MACROS.
Retrieve the association list mapping iterator identifiers to the names of the macros serving as the expansion of WITH-ITER-VALUE when given those iterator identifiers. This information is retrieved from the environmnet ENV by macroexpanding the symbol-macro ITER-VALUE-MACROS.
Accumulates COUNT elements of the ‘LAZY-SEQ’ SEQ into a list, in reverse order.
seq.
Returns a ‘HASH-SET’ containing all the elements in LIST.
head.
tail.
cons.
Creates either a native hash-table or generic hash-table depending on the TEST.
Returns a list of iterators for each sequence in SEQS.
Returns true if there are more elements to be processed in the sequence SEQ. END is the index of the last element to process and COUNT is the maximum number of elements to be processed.
Split the BODY of a WITH-ITER-VALUE/PLACE macro into declaration
expressions and forms.
If BODY is a list of a single LOCALLY form, the body of the LOCALLY form is parsed instead.
Split DECLARATIONS into those that do and do not apply to XS.
Return two values, one with each set.
Both sets of declarations are returned in a form that can be spliced
directly into Lisp code:
(locally ,@(partition-declarations vars decls) ...)
Returns a ‘LAZY-SEQ’ containing all elements in SEQ with the elements in the ‘HASH-MAP’ ITEMS removed.
Returns a ‘LAZY-SEQ’ containing all elements in SEQ with the elements in the ‘LIST’ ITEMS removed.
Returns a ‘LAZY-SEQ’ that contains the elements of SEQ with the elements that satisfy TEST removed.
Return true if FORM is of type CL:SEQUENCCE in environment ENV.
Return true if each form in FORMS is of type CL:SEQUENCE in environment ENV.
Returns true if at least one of the iterators in ITERS is at the end of its sequence (by ENDP.
end.
iter.
Returns the subsequence of SEQ beginning at the element at index START.
Return the list of CONS cells making up a subsequence of a list.
LIST is the list.
START is the index of the first element of the subsequence.
END is the index 1 past the last element of the subsequence. If NIL
the subsequence extends till the end of the list.
If FROM-END is true the cells are collected starting from the last
element of the subsequence, otherwise they are collected starting
from the first element of the subsequence.
The return value is a list of CONS cells of the original list, corresponding to the cells containing the elements of the subsequence. This allows modifying the original list by modifying the cons cells.
Returns a new ‘LAZY-SEQ’ containing all elements of ‘SEQ’ with the elements that satisfy TEST replaced with NEW.
Returns a function of one argument Y which returns true if (FN X Y) returns true.
Returns a function of one argument which returns the complement of applying FN on the argument.
end.
Generate the WITH-ITERATORS expansion for a sequence of a given type.
This method has the SUBTYPE method combination meaning each method
has a single qualifier which is interpreted as a type specifier
symbol. The method with the most derived type, which is a subtype
of the type specifier given in TYPE, is called.
TYPE is the type specifier of the sequence, as determined from the
environment.
SEQ is the form which returns the sequence over which to iterate.
ARGS are the additional arguments passed after the sequence which
should be interpreted as they are interpreted by the ITERATOR
function.
TAG is the name of the tag (in TAGBODY) to which a non-local jump
should be performed, by GO, when the end of the container is
reached.
BODY is list of forms comprising the body of the WITH-ITERATORS
form.
ENV is the environment in which the DO-SEQUENCES/DOSEQ form is
found.
Methods of this function should return the following values:
1. A list of bindings, as by LET*, which are established before
the first iteration and remain visible to the body forms
throughout all iterations.
Each binding, in this list, may optionally provide the
following keyword arguments following the init-form:
:CONSTANT
Flag for whether the variable should be treated as a
constant. If true and the init-form is a constant-form,
the symbol is bound by SYMBOL-MACROLET, preceding the
non-constant bindings, rather than LET.
NOTE: A constant binding may only reference other bindings
for which this flag is true.
2. The new body of the WITH-ITERATORS form.
3. A lexical macro definition defining the expansion of
WITH-ITER-VALUE for the sequence’s iterator.
This should be a list of the form:
(LAMBDA-LIST . BODY)
where LAMBDA-LIST is the macro lambda-list and BODY is the
macro definition body. A name should not be provided as a name
for the macro is generated.
The lambda-list should have the following arguments:
(PATTERN &BODY BODY)
where PATTERN is the binding pattern, corresponding to the PATTERN argument of WITH-ITER-VALUE, describing which variable(s) to bind to the value of current sequence element.
This may either be a symbol, naming a variable or a list which
should be interpreted as a destructuring-bind pattern.
BODY is the list of body forms of the WITH-ITER-VALUE form,
corresponding to the BODY argument.
The macro should expand to a form which binds the current
sequence element to the variable(s) specified in PATTERN,
advances the position of the iterator to the next element in
the sequence, and evaluates the body forms.
The expansion should jump out of the WITH-ITERATORS form,
using a GO to the tag name given in the TAG argument.
4. A lexical macro definition defining the expansion of
WITH-ITER-PLACE for the sequence’s iterator.
This should be a list of the form:
(LAMBDA-LIST . BODY)
where LAMBDA-LIST is the macro lambda-list and BODY is the
macro definition body. A name should not be provided as a name
for the macro is generated.
The lambda-list should have the following arguments:
(NAME MOREP &BODY FORMS)
where NAME is the name of the symbol-macro to be introduced,
expanding to the ’place’ of the current sequence element,
corresponding to the NAME argument of WITH-ITER-PLACE.
MOREP corresponds to the MOREP argument of WITH-ITER-PLACE
which is the name of the variable which should be bound to
true if there are more elements in the sequence and bound to
NIL if there are no more elements. If MOREP is NIL, the
expansion should jump out of the WITH-ITERATORS form, skipping
the evaluation of FORMS, using a GO to the tag name given in
the TAG argument.
FORMS are the body forms of the WITH-ITER-PLACE form,
corresponding to the FORMS argument of WITH-ITER-PLACE.
If this return value is NIL it is assumed the sequence is immutable, and any uses of WITH-ITER-PLACE on it will result in an error being signalled.
Dispatch based on a type keyword given as a qualifier.
With this method combination each method includes a single
qualifier, which is interpreted as a type specifier symbol.
The method of which the value given in the first argument, interpreted as a type specifier, is a subtype of the method’s qualified type specifier, given in the first qualifier, is called.
The methods are ordered such that the methods qualified with the most derived type, i.e. a type which is a subtype of the others, are called first.
Multi-dimensional (non-vector) array iterator for iterator over each element of the flattened array. Does not have any additional slots over ‘vector-iterator’, as it is used only for generic dispatch.
Lazy sequence iterator which iterates through the elements of the sequence up till the element at index END.
Bounded list iterator for iterator from a given starting position
till a given end position.
END is the number of elements (to iterate over) between the current position and the end of the sublist.
Collector object for adding items to the front of a list.
structure-object.
common-lisp.
Collector object for adding items to the front of a vector
structure-object.
common-lisp.
Hash-table iterator. The actual hash-table is converted to an ALIST upon creation of the iterator, since closing over the iteration function provided by WITH-HASH-TABLE-ITERATOR is undefined, and assigned to the CONS slot. A reference to the hash-table is only kept to implement (SETF AT).
Unbounded lazy sequence iterator. Iterates through all elements of the ‘LAZY-SEQ’ SEQ till the end of the sequence.
Collector object for adding items to the back of a list.
Unbounded list iterator for iterating from a given starting
position till the end of the list.
CONS stores the CONS cell at the iterator’s current position.
common-lisp.
Multi-dimensional (non-vector) array iterator for iterating over the elements of the flattened array in reverse order. Does not have any additional slots over ‘reverse-vector-iterator’, as it is used only for generic dispatch.
Reverse iterator for iterating over the elements of a list in reverse order. Does not have any additional slots over ‘list-iterator’, as it is only used for generic dispatch.
Reverse iterator for iterating over the elements of a vector in reverse order. Does not have any additional slots over ‘vector-iterator’, as it is only used for generic dispatch.
Iterator for iterating over a sub-sequence given an iterator for
the sequence.
ITER is the sequence’s iterator. END is the index of the end of the subsequence.
| Jump to: | (
*
+
-
/
1
<
=
>
A B C D E F G H I L M N O P R S T U V W Z |
|---|
| Jump to: | (
*
+
-
/
1
<
=
>
A B C D E F G H I L M N O P R S T U V W Z |
|---|
| Jump to: | *
+
-
/
A C E H I S T V |
|---|
| Jump to: | *
+
-
/
A C E H I S T V |
|---|
| Jump to: | A B C D E F G H I L M O P R S U V |
|---|
| Jump to: | A B C D E F G H I L M O P R S U V |
|---|