The incf-cl Reference Manual

This is the incf-cl Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed May 15 05:36:10 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

The main system appears first, followed by any subsystem dependency.


2.1 incf-cl

INCF CL is a library of convenience functions for Common Lisp

Author

Juan M. Bello Rivas <>

License

X11

Dependency

cl-ppcre (system).

Source

incf-cl.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


3.1 Lisp


3.1.1 incf-cl/incf-cl.asd

Source

incf-cl.asd.

Parent Component

incf-cl (system).

ASDF Systems

incf-cl.


3.1.2 incf-cl/package.lisp

Source

incf-cl.asd.

Parent Component

incf-cl (system).

Packages

incf-cl.


3.1.3 incf-cl/function.lisp

Dependency

package.lisp (file).

Source

incf-cl.asd.

Parent Component

incf-cl (system).

Public Interface

$ (function).

Internals

canonicalize-test (function).


3.1.4 incf-cl/lc.lisp

Dependency

function.lisp (file).

Source

incf-cl.asd.

Parent Component

incf-cl (system).

Public Interface

lc (macro).

Internals

3.1.5 incf-cl/nest.lisp

Dependency

lc.lisp (file).

Source

incf-cl.asd.

Parent Component

incf-cl (system).

Public Interface
Internals

3.1.6 incf-cl/unfold.lisp

Dependency

nest.lisp (file).

Source

incf-cl.asd.

Parent Component

incf-cl (system).

Public Interface

3.1.7 incf-cl/range.lisp

Dependency

unfold.lisp (file).

Source

incf-cl.asd.

Parent Component

incf-cl (system).

Public Interface

range (function).


3.1.8 incf-cl/prelude.lisp

Dependency

range.lisp (file).

Source

incf-cl.asd.

Parent Component

incf-cl (system).

Public Interface
Internals

3.1.9 incf-cl/unscan.lisp

Dependency

prelude.lisp (file).

Source

incf-cl.asd.

Parent Component

incf-cl (system).

Public Interface

unscan (generic function).


3.1.10 incf-cl/fixed-point.lisp

Dependency

unscan.lisp (file).

Source

incf-cl.asd.

Parent Component

incf-cl (system).

Public Interface

fixed-point (function).


3.1.11 incf-cl/hash-table.lisp

Dependency

fixed-point.lisp (file).

Source

incf-cl.asd.

Parent Component

incf-cl (system).

Public Interface

dohash (macro).


3.1.12 incf-cl/iteration.lisp

Dependency

hash-table.lisp (file).

Source

incf-cl.asd.

Parent Component

incf-cl (system).

Public Interface

while (macro).


3.1.13 incf-cl/string.lisp

Dependency

iteration.lisp (file).

Source

incf-cl.asd.

Parent Component

incf-cl (system).

Public Interface

string-join (function).


3.1.14 incf-cl/doctest.lisp

Dependency

string.lisp (file).

Source

incf-cl.asd.

Parent Component

incf-cl (system).

Public Interface
Internals

3.1.15 incf-cl/symbol.lisp

Dependency

doctest.lisp (file).

Source

incf-cl.asd.

Parent Component

incf-cl (system).

Public Interface

4 Packages

Packages are listed by definition order.


4.1 incf-cl

Source

package.lisp.

Use List

common-lisp.

Public Interface
Internals

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


5.1 Public Interface


5.1.1 Special variables

Special Variable: *doctest-show-progress*

Determines if a dot will be displayed for each passed test.

Package

incf-cl.

Source

doctest.lisp.


5.1.2 Macros

Macro: dohash ((key value hash-table &optional result-form) &body body)

DOHASH iterates over the keys and values of HASH-TABLE. It returns NIL or the result of evaluating RESULT-FORM if it was specified.

Package

incf-cl.

Source

hash-table.lisp.

Macro: lc (collection-form &rest quantifiers)

Assembles a multiset containing the results of evaluating COLLECTION-FORM and subject to QUANTIFIERS.

Package

incf-cl.

Source

lc.lisp.

Macro: signals-p (condition &body body)

Returns T if evaluating BODY results in CONDITION being signalled, NIL otherwise.

Package

incf-cl.

Source

doctest.lisp.

Macro: while (predicate-form &body body)

Executes BODY while PREDICATE-FORM is non NIL.

Package

incf-cl.

Source

iteration.lisp.


5.1.3 Ordinary functions

Function: $ (&rest functions)

Returns the composition of FUNCTIONS. Note that FUNCTIONS must
be composable in the order specified.

For example,

INCF-CL> (funcall ($ (lambda (x) (* x x))
(lambda (x) (+ x 2)))
2)
16

INCF-CL> (funcall ($ #’values #’floor #’sqrt (lambda (x) (expt x 2))) -2) 2

Package

incf-cl.

Source

function.lisp.

Function: doctest (symbol &key stream)

If SYMBOL corresponds to a function, then its documentation string is tested and the results are printed to STREAM. If SYMBOL refers to a package, then all the functions corresponding to the external symbols in the package are tested.
DOCTEST returns T if the tests succeed, NIL otherwise.

Package

incf-cl.

Source

doctest.lisp.

Function: fixed-point (function initial-value &key test max-steps)

Returns the fixed point of FUNCTION starting with INITIAL-VALUE. The keyword argument TEST determines when a fixed point has been reached. Use MAX-STEPS to stop after a certain (positive) number of iterations.

For example, the square root of 2 using Newton’s method can be computed as:

INCF-CL> (fixed-point (lambda (x)
(float (- x (/ (- (expt x 2) 2) (* 2 x))))) 1)
1.4142135

INCF-CL> (sqrt 2)
1.4142135

Package

incf-cl.

Source

fixed-point.lisp.

Function: flip (f)

Applied to a binary function F, returns the same function with the order of the arguments reversed.

Package

incf-cl.

Source

prelude.lisp.

Function: list-all-symbols (package)

Returns a list containing all the symbols in PACKAGE.

Package

incf-cl.

Source

symbol.lisp.

Function: list-external-symbols (package)

Returns a list containing all the exported symbols in PACKAGE.

Package

incf-cl.

Source

symbol.lisp.

Function: nest (function initial-values &key test test-not n m max)
Package

incf-cl.

Source

nest.lisp.

Function: nest-list (function initial-values &key test test-not n m max)

Returns a list of the results of applying FUNCTION successively to INITIAL-VALUES and continuing until applying TEST (respectively TEST-NOT) to the result is non NIL.

If M is specified, then NEST-LIST supplies the M most recent results as arguments for TEST (respectivelly TEST-NOT) at each step.

If MAX is specified then FUNCTION is applied at most MAX times.

Package

incf-cl.

Source

nest.lisp.

Function: range (a b &optional c)
Package

incf-cl.

Source

range.lisp.

Function: replicate (n x)

Returns a list contaning N times the value X

Package

incf-cl.

Source

prelude.lisp.

Function: string-join (list &optional sep)

Returns a string joining each string in LIST by SEP. If SEP is not specified, the default separator is a space.

Package

incf-cl.

Source

string.lisp.

Function: unfold (predicate transformer incrementor initial-value &optional tail-gen)

Returns a list built following the pattern:

transformer(initial-value), transformer(incrementor(initial-value)), ...

Examples:

1. List of squares: 1^2, ..., 10^2

INCF-CL> (unfold (lambda (x) (> x 10)) (lambda (x) (expt x 2)) #’1+ 1) (1 4 9 16 25 36 49 64 81 100)

2. Append (3 4 5) onto (1 2)

INCF-CL> (unfold #’endp #’first #’rest (list 1 2) (lambda (x) (declare (ignore x)) (list 3 4 5))) (1 2 3 4 5)

See also:
http://srfi.schemers.org/srfi-1/srfi-1.html#unfold

Package

incf-cl.

Source

unfold.lisp.

Function: unfold-right (predicate transformer incrementor initial-value &optional tail)

Returns a list built following the pattern:

... transformer(incrementor(initial-value)), transformer(initial-value)

Examples:

1. List of squares: 1^2, ..., 10^2

INCF-CL> (unfold-right #’zerop (lambda (x) (* x x)) #’1- 10)
(1 4 9 16 25 36 49 64 81 100)

2. Reverse a proper list:

INCF-CL> (unfold-right #’endp #’first #’rest (list 1 2 3 4 5))
(5 4 3 2 1)

See also: http://srfi.schemers.org/srfi-1/srfi-1.html#unfold-right

Package

incf-cl.

Source

unfold.lisp.

Function: unzip (alist)

Applied to the association list ALIST, returns two lists (as VALUES) containing the keys and values of each element in ALIST respectively. This function is the inverse of PAIRLIS.

Package

incf-cl.

Source

prelude.lisp.


5.1.4 Generic functions

Generic Function: break* (predicate list &key key)

Given a PREDICATE and a LIST, breaks LIST into two
lists (returned as VALUES) at the point where PREDICATE is first satisfied. If PREDICATE is never satisfied then the first returned value is the entire LIST and the second element is NIL.

KEY is a designator for a function of one argument, or NIL. If KEY is supplied, it is applied once to each element of LIST before it is passed to PREDICATE. If it is not supplied or is NIL, the element of LIST itself is used.

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: break* ((predicate function) (list list) &key key)
Generic Function: cycle (list)

Returns a circular list containing the elements in LIST (which should be a proper list).

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: cycle ((list list))
Method: cycle ((list null))
Generic Function: drop (n list)

Applied to N (a non-negative integer) and LIST,
returns the list with the specified number of elements removed from the front of LIST. If LIST has less than N elements then it returns NIL.

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: drop ((n integer) (list list))
Generic Function: drop-while (predicate list &key key)

Applied to PREDICATE and LIST, removes elements
from the front of LIST while PREDICATE is satisfied.

KEY is a designator for a function of one argument, or NIL. If KEY is supplied, it is applied once to each element of LIST before it is passed to PREDICATE. If it is not supplied or is NIL, the element of LIST itself is used.

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: drop-while ((predicate function) (list list) &key key)
Generic Function: group (list &key key test test-not)

Returns a list of lists where every item in each
sublist satisfies TEST and the concatenation of the result is equal to LIST.

KEY is a designator for a function of one argument, or NIL. If KEY is supplied, it is applied once to each element of LIST before it is passed to PREDICATE. If it is not supplied or is NIL, the element of LIST itself is used.

For example,

INCF-CL> (mapcar (lambda (x) (concatenate ’string x))
(group (coerce "Mississippi" ’list)))
("M" "i" "ss" "i" "ss" "i" "pp" "i")

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: group ((list list) &key key test test-not)
Generic Function: insert (x list &key key test test-not)

Inserts X before the first element in LIST which is
greater than X. The order relation can be specified by either one of the keyword arguments TEST and TEST-NOT.

KEY is a designator for a function of one argument, or NIL. If KEY is supplied, it is applied once to each element of LIST before it is passed to PREDICATE. If it is not supplied or is NIL, the element of LIST itself is used.

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: insert (x (list list) &key key test test-not)
Generic Function: intersperse (element list)

Returns a list where ELEMENT is interspersed between the elements of SEQUENCE.

For example,

INCF-CL> (intersperse ’x (replicate 3 ’z)) (Z X Z X Z)

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: intersperse (element (list cons))
Method: intersperse (element (list null))
Generic Function: ncycle (list)

Destructive version of CYCLE. Again, keep in mind that LIST must be a proper list.

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: ncycle ((list list))
Method: ncycle ((list null))
Generic Function: nintersperse (element list)

Destructive version of INTERSPERSE.

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: nintersperse (element (list list))
Generic Function: partition (predicate list &key key)

Applied to PREDICATE and LIST, returns two values: a list containing all the elements from LIST that satisfy PREDICATE, and its complementary list.

KEY is a designator for a function of one argument, or NIL. If KEY is supplied, it is applied once to each element of LIST before it is passed to PREDICATE. If it is not supplied or is NIL, the element of LIST itself is used.

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: partition ((predicate function) (list list) &key key)
Generic Function: scan* (function list &key key from-end initial-value)

SCAN* is similar to REDUCE, but returns a list of
successive reduced values:

(scan* f (list x1 x2 ...) :initial-value z)
==> (z (funcall f z x1) (funcall f (funcall f z x1) x2) ...)

(scan* f (list x1 x2 ...))
==> (x1 (funcall f x1 x2) (funcall f (funcall f x1 x2) x2) ...)

(scan* f (list x1 ... x_n-1 x_n) :initial-value z :from-end t)
==> (... (funcall f x_n-1 (funcall f x_n z)) (funcall f x_n z) z)

(scan* f (list x1 ... x_n-1 x_n) :from-end t)
==> (... (funcall f x_n-1 (funcall f x_n-1 x_n)) (funcall f x_n-1 x_n) x_n)

Examples:

INCF-CL> (scan* #’/ (list 4 2 4) :initial-value 64)
(64 16 8 2)

INCF-CL> (scan* #’max (range 1 7) :initial-value 5)
(5 5 5 5 5 5 6 7)

INCF-CL> (scan* (lambda (x y) (+ (* 2 x) y)) (list 1 2 3) :initial-value 4) (4 9 20 43)

INCF-CL> (scan* #’+ (list 1 2 3 4))
(1 3 6 10)

INCF-CL> (scan* #’+ (list 1 2 3 4) :initial-value 5 :from-end t)
(15 14 12 9 5)

INCF-CL> (scan* #’+ (list 1 2 3 4) :from-end t)
(10 9 7 4)

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: scan* ((function function) (list list) &key key from-end initial-value)
Generic Function: span (predicate list &key key)

Splits LIST into two lists (returned as VALUES)
such that elements in the first list are taken from the head of LIST while PREDICATE is satisfied, and elements in the second list are the remaining elements from LIST once PREDICATE is not satisfied.

KEY is a designator for a function of one argument, or NIL. If KEY is supplied, it is applied once to each element of LIST before it is passed to PREDICATE. If it is not supplied or is NIL, the element of LIST itself is used.

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: span ((predicate function) (list list) &key key)
Generic Function: split-at (n list)

Given a non-negative integer N and LIST, splits
LIST into two lists (returned as VALUES) at the position corresponding to the given integer. If N is greater than the length of LIST, it returns the entire list first and the empty list second in VALUES.

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: split-at ((n integer) (list list))
Generic Function: take (n list)

Applied to the integer N and LIST, returns the specified number of elements from the front of LIST. If LIST has less than N elements, TAKE returns the entire LIST.

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: take ((n integer) (list list))
Generic Function: take-while (predicate list &key key)

Applied to PREDICATE and LIST, returns a list
containing elements from the front of LIST while PREDICATE is satisfied.

KEY is a designator for a function of one argument, or NIL. If KEY is supplied, it is applied once to each element of LIST before it is passed to PREDICATE. If it is not supplied or is NIL, the element of LIST itself is used.

Package

incf-cl.

Source

prelude.lisp.

Methods
Method: take-while ((predicate function) (list list) &key key)
Generic Function: unscan (function list &key initial-value)

Semi-inverse of SCAN*.

INCF-CL> (equal (unscan (flip #’-) (scan* #’+ ’(1 2 3)) :initial-value 0) ’(1 2 3))
T

Package

incf-cl.

Source

unscan.lisp.

Methods
Method: unscan ((function function) (list list) &key initial-value)
Method: unscan ((function function) (list null) &key initial-value)

5.2 Internals


5.2.1 Ordinary functions

Function: %nest-list (function initial-values test n m max)
Package

incf-cl.

Source

nest.lisp.

Function: apply-key (key element)
Package

incf-cl.

Source

prelude.lisp.

Function: canonicalize-test (test test-not)

Returns a validated test function for those functions that use TEST and TEST-NOT keyword arguments.

Package

incf-cl.

Source

function.lisp.

Function: ensure-and-copy-list (x)
Package

incf-cl.

Source

nest.lisp.

Function: first-with (key list)
Package

incf-cl.

Source

prelude.lisp.

Function: scan-left* (function list key initial-value ivp)
Package

incf-cl.

Source

prelude.lisp.

Function: scan-right* (function list key initial-value ivp)
Package

incf-cl.

Source

prelude.lisp.

Function: test-docstring (documentation)

Returns T if the first doctest found in DOCUMENTATION passes, signals DOCTEST-FAILURE otherwise.

Package

incf-cl.

Source

doctest.lisp.

Function: test-function (package function stream)

Returns T if every test in FUNCTION’s docstring passes, NIL otherwise.

Package

incf-cl.

Source

doctest.lisp.

Function: translate-comprehension (collection-form quantifiers)
Package

incf-cl.

Source

lc.lisp.

Function: translate-filter (collection-form filter-form quantifiers)
Package

incf-cl.

Source

lc.lisp.

Function: translate-generator (collection-form variable collection quantifiers)
Package

incf-cl.

Source

lc.lisp.

Function: translate-generator-or-filter (collection-form quantifiers)
Package

incf-cl.

Source

lc.lisp.


5.2.2 Generic functions

Generic Reader: actual-values (condition)
Package

incf-cl.

Methods
Reader Method: actual-values ((condition doctest-failure))
Source

doctest.lisp.

Target Slot

actual-values.

Generic Reader: expected-values (condition)
Package

incf-cl.

Methods
Reader Method: expected-values ((condition doctest-failure))
Source

doctest.lisp.

Target Slot

expected-values.

Generic Reader: sexpr (condition)
Package

incf-cl.

Methods
Reader Method: sexpr ((condition doctest-failure))
Source

doctest.lisp.

Target Slot

sexpr.


5.2.3 Conditions

Condition: doctest-failure
Package

incf-cl.

Source

doctest.lisp.

Direct superclasses

condition.

Direct methods
Direct slots
Slot: sexpr
Initargs

:sexpr

Readers

sexpr.

Writers

This slot is read-only.

Slot: actual-values
Initargs

:actual-values

Readers

actual-values.

Writers

This slot is read-only.

Slot: expected-values
Initargs

:expected-values

Readers

expected-values.

Writers

This slot is read-only.


5.2.4 Types

Type: function-or-null ()
Package

incf-cl.

Source

prelude.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   $   %  
A   B   C   D   E   F   G   I   L   M   N   P   R   S   T   U   W  
Index Entry  Section

$
$: Public ordinary functions

%
%nest-list: Private ordinary functions

A
actual-values: Private generic functions
actual-values: Private generic functions
apply-key: Private ordinary functions

B
break*: Public generic functions
break*: Public generic functions

C
canonicalize-test: Private ordinary functions
cycle: Public generic functions
cycle: Public generic functions
cycle: Public generic functions

D
doctest: Public ordinary functions
dohash: Public macros
drop: Public generic functions
drop: Public generic functions
drop-while: Public generic functions
drop-while: Public generic functions

E
ensure-and-copy-list: Private ordinary functions
expected-values: Private generic functions
expected-values: Private generic functions

F
first-with: Private ordinary functions
fixed-point: Public ordinary functions
flip: Public ordinary functions
Function, $: Public ordinary functions
Function, %nest-list: Private ordinary functions
Function, apply-key: Private ordinary functions
Function, canonicalize-test: Private ordinary functions
Function, doctest: Public ordinary functions
Function, ensure-and-copy-list: Private ordinary functions
Function, first-with: Private ordinary functions
Function, fixed-point: Public ordinary functions
Function, flip: Public ordinary functions
Function, list-all-symbols: Public ordinary functions
Function, list-external-symbols: Public ordinary functions
Function, nest: Public ordinary functions
Function, nest-list: Public ordinary functions
Function, range: Public ordinary functions
Function, replicate: Public ordinary functions
Function, scan-left*: Private ordinary functions
Function, scan-right*: Private ordinary functions
Function, string-join: Public ordinary functions
Function, test-docstring: Private ordinary functions
Function, test-function: Private ordinary functions
Function, translate-comprehension: Private ordinary functions
Function, translate-filter: Private ordinary functions
Function, translate-generator: Private ordinary functions
Function, translate-generator-or-filter: Private ordinary functions
Function, unfold: Public ordinary functions
Function, unfold-right: Public ordinary functions
Function, unzip: Public ordinary functions

G
Generic Function, actual-values: Private generic functions
Generic Function, break*: Public generic functions
Generic Function, cycle: Public generic functions
Generic Function, drop: Public generic functions
Generic Function, drop-while: Public generic functions
Generic Function, expected-values: Private generic functions
Generic Function, group: Public generic functions
Generic Function, insert: Public generic functions
Generic Function, intersperse: Public generic functions
Generic Function, ncycle: Public generic functions
Generic Function, nintersperse: Public generic functions
Generic Function, partition: Public generic functions
Generic Function, scan*: Public generic functions
Generic Function, sexpr: Private generic functions
Generic Function, span: Public generic functions
Generic Function, split-at: Public generic functions
Generic Function, take: Public generic functions
Generic Function, take-while: Public generic functions
Generic Function, unscan: Public generic functions
group: Public generic functions
group: Public generic functions

I
insert: Public generic functions
insert: Public generic functions
intersperse: Public generic functions
intersperse: Public generic functions
intersperse: Public generic functions

L
lc: Public macros
list-all-symbols: Public ordinary functions
list-external-symbols: Public ordinary functions

M
Macro, dohash: Public macros
Macro, lc: Public macros
Macro, signals-p: Public macros
Macro, while: Public macros
Method, actual-values: Private generic functions
Method, break*: Public generic functions
Method, cycle: Public generic functions
Method, cycle: Public generic functions
Method, drop: Public generic functions
Method, drop-while: Public generic functions
Method, expected-values: Private generic functions
Method, group: Public generic functions
Method, insert: Public generic functions
Method, intersperse: Public generic functions
Method, intersperse: Public generic functions
Method, ncycle: Public generic functions
Method, ncycle: Public generic functions
Method, nintersperse: Public generic functions
Method, partition: Public generic functions
Method, scan*: Public generic functions
Method, sexpr: Private generic functions
Method, span: Public generic functions
Method, split-at: Public generic functions
Method, take: Public generic functions
Method, take-while: Public generic functions
Method, unscan: Public generic functions
Method, unscan: Public generic functions

N
ncycle: Public generic functions
ncycle: Public generic functions
ncycle: Public generic functions
nest: Public ordinary functions
nest-list: Public ordinary functions
nintersperse: Public generic functions
nintersperse: Public generic functions

P
partition: Public generic functions
partition: Public generic functions

R
range: Public ordinary functions
replicate: Public ordinary functions

S
scan*: Public generic functions
scan*: Public generic functions
scan-left*: Private ordinary functions
scan-right*: Private ordinary functions
sexpr: Private generic functions
sexpr: Private generic functions
signals-p: Public macros
span: Public generic functions
span: Public generic functions
split-at: Public generic functions
split-at: Public generic functions
string-join: Public ordinary functions

T
take: Public generic functions
take: Public generic functions
take-while: Public generic functions
take-while: Public generic functions
test-docstring: Private ordinary functions
test-function: Private ordinary functions
translate-comprehension: Private ordinary functions
translate-filter: Private ordinary functions
translate-generator: Private ordinary functions
translate-generator-or-filter: Private ordinary functions

U
unfold: Public ordinary functions
unfold-right: Public ordinary functions
unscan: Public generic functions
unscan: Public generic functions
unscan: Public generic functions
unzip: Public ordinary functions

W
while: Public macros


A.4 Data types

Jump to:   C   D   F   H   I   L   N   P   R   S   T   U  
Index Entry  Section

C
Condition, doctest-failure: Private conditions

D
doctest-failure: Private conditions
doctest.lisp: The incf-cl/doctest․lisp file

F
File, doctest.lisp: The incf-cl/doctest․lisp file
File, fixed-point.lisp: The incf-cl/fixed-point․lisp file
File, function.lisp: The incf-cl/function․lisp file
File, hash-table.lisp: The incf-cl/hash-table․lisp file
File, incf-cl.asd: The incf-cl/incf-cl․asd file
File, iteration.lisp: The incf-cl/iteration․lisp file
File, lc.lisp: The incf-cl/lc․lisp file
File, nest.lisp: The incf-cl/nest․lisp file
File, package.lisp: The incf-cl/package․lisp file
File, prelude.lisp: The incf-cl/prelude․lisp file
File, range.lisp: The incf-cl/range․lisp file
File, string.lisp: The incf-cl/string․lisp file
File, symbol.lisp: The incf-cl/symbol․lisp file
File, unfold.lisp: The incf-cl/unfold․lisp file
File, unscan.lisp: The incf-cl/unscan․lisp file
fixed-point.lisp: The incf-cl/fixed-point․lisp file
function-or-null: Private types
function.lisp: The incf-cl/function․lisp file

H
hash-table.lisp: The incf-cl/hash-table․lisp file

I
incf-cl: The incf-cl system
incf-cl: The incf-cl package
incf-cl.asd: The incf-cl/incf-cl․asd file
iteration.lisp: The incf-cl/iteration․lisp file

L
lc.lisp: The incf-cl/lc․lisp file

N
nest.lisp: The incf-cl/nest․lisp file

P
Package, incf-cl: The incf-cl package
package.lisp: The incf-cl/package․lisp file
prelude.lisp: The incf-cl/prelude․lisp file

R
range.lisp: The incf-cl/range․lisp file

S
string.lisp: The incf-cl/string․lisp file
symbol.lisp: The incf-cl/symbol․lisp file
System, incf-cl: The incf-cl system

T
Type, function-or-null: Private types

U
unfold.lisp: The incf-cl/unfold․lisp file
unscan.lisp: The incf-cl/unscan․lisp file