The fact-base Reference Manual

This is the fact-base Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Feb 15 05:55:49 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 fact-base

Simple implementation of fact-base data storage for Common Lisp

Author

Inaimathi <>

License

AGPL3

Dependencies
  • alexandria (system).
  • local-time (system).
  • optima (system).
  • cl-fad (system).
Source

fact-base.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 fact-base/fact-base.asd

Source

fact-base.asd.

Parent Component

fact-base (system).

ASDF Systems

fact-base.


3.1.2 fact-base/package.lisp

Source

fact-base.asd.

Parent Component

fact-base (system).

Packages

fact-base.


3.1.3 fact-base/util.lisp

Dependency

package.lisp (file).

Source

fact-base.asd.

Parent Component

fact-base (system).

Internals

3.1.4 fact-base/queue.lisp

Dependency

util.lisp (file).

Source

fact-base.asd.

Parent Component

fact-base (system).

Internals

3.1.5 fact-base/fact-base.lisp

Dependency

queue.lisp (file).

Source

fact-base.asd.

Parent Component

fact-base (system).

Public Interface
Internals

3.1.6 fact-base/index.lisp

Dependency

fact-base.lisp (file).

Source

fact-base.asd.

Parent Component

fact-base (system).

Public Interface
Internals

3.1.7 fact-base/unify.lisp

Dependency

index.lisp (file).

Source

fact-base.asd.

Parent Component

fact-base (system).

Public Interface

for-all (macro).

Internals

4 Packages

Packages are listed by definition order.


4.1 fact-base

Source

package.lisp.

Use List
  • common-lisp.
  • optima.
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 Macros

Macro: for-all (goal-term &key in collect do)
Package

fact-base.

Source

unify.lisp.


5.1.2 Ordinary functions

Function: make-fact-base (&key indices file-name in-memory?)
Package

fact-base.

Source

fact-base.lisp.


5.1.3 Generic functions

Generic Function: base! (file-name &key indices in-memory?)
Package

fact-base.

Methods
Method: base! ((file-name pathname) &key indices in-memory?)
Source

fact-base.lisp.

Generic Function: change! (state old new)
Package

fact-base.

Methods
Method: change! ((state fact-base) (old list) (new list))
Source

fact-base.lisp.

Generic Reader: current (object)
Generic Writer: (setf current) (object)
Package

fact-base.

Methods
Reader Method: current ((fact-base fact-base))
Writer Method: (setf current) ((fact-base fact-base))

The current projection of this fact-base

Source

fact-base.lisp.

Target Slot

current.

Generic Function: delete! (state fact)
Package

fact-base.

Methods
Method: delete! ((state index) (fact list))
Source

index.lisp.

Method: delete! ((state fact-base) (fact list))
Source

fact-base.lisp.

Generic Reader: delta (object)
Generic Writer: (setf delta) (object)
Package

fact-base.

Methods
Reader Method: delta ((fact-base fact-base))
Writer Method: (setf delta) ((fact-base fact-base))

A collection of history entries that have not yet been written to disk

Source

fact-base.lisp.

Target Slot

delta.

Generic Reader: file-name (object)
Package

fact-base.

Methods
Reader Method: file-name ((fact-base fact-base))

The file associated with this fact-base

Source

fact-base.lisp.

Target Slot

file-name.

Generic Function: fork-at (state history-index &key file-name)
Package

fact-base.

Methods
Method: fork-at ((state fact-base) (history-index integer) &key file-name)
Source

fact-base.lisp.

Generic Function: index! (state indices)
Package

fact-base.

Methods
Method: index! ((state fact-base) (indices list))
Source

fact-base.lisp.

Generic Function: insert! (state fact)
Package

fact-base.

Methods
Method: insert! ((state index) (fact list))
Source

index.lisp.

Method: insert! ((state fact-base) (fact list))
Source

fact-base.lisp.

Generic Function: insert-if-unique! (state entry)
Package

fact-base.

Methods
Method: insert-if-unique! ((state fact-base) (entry list))
Source

fact-base.lisp.

Generic Function: insert-new! (state b c)
Package

fact-base.

Methods
Method: insert-new! ((state fact-base) b c)
Source

fact-base.lisp.

Generic Function: load! (file-name &key indices in-memory?)
Package

fact-base.

Methods
Method: load! ((file-name pathname) &key indices in-memory?)
Source

fact-base.lisp.

Generic Function: lookup (state &key a b c)
Package

fact-base.

Methods
Method: lookup ((state fact-base) &key a b c)
Source

fact-base.lisp.

Method: lookup ((state list) &key a b c)
Source

fact-base.lisp.

Generic Function: multi-insert! (state b/c-pairs)
Package

fact-base.

Methods
Method: multi-insert! ((state fact-base) (b/c-pairs list))
Source

fact-base.lisp.

Generic Function: next-id! (state)
Package

fact-base.

Methods
Method: next-id! ((state fact-base))
Source

fact-base.lisp.

Generic Function: rewind-by (state delta &optional units)
Package

fact-base.

Methods
Method: rewind-by ((state fact-base) delta &optional units)
Source

fact-base.lisp.

Generic Function: rewind-to (state time)
Package

fact-base.

Methods
Method: rewind-to ((state fact-base) (tag string))
Source

fact-base.lisp.

Method: rewind-to ((state fact-base) (index integer))
Source

fact-base.lisp.

Method: rewind-to ((state fact-base) (time timestamp))
Source

fact-base.lisp.

Generic Function: tag! (state tag)
Package

fact-base.

Methods
Method: tag! ((state fact-base) (tag string))
Source

fact-base.lisp.

Generic Function: tags-of (state)
Package

fact-base.

Methods
Method: tags-of ((state fact-base))
Source

fact-base.lisp.

Generic Function: total-entries (state)
Package

fact-base.

Methods
Method: total-entries ((state fact-base))
Source

fact-base.lisp.

Generic Function: write! (state &key file-name)
Package

fact-base.

Methods
Method: write! ((state fact-base) &key file-name)
Source

fact-base.lisp.


5.1.4 Classes

Class: fact-base
Package

fact-base.

Source

fact-base.lisp.

Direct methods
Direct slots
Slot: file-name

The file associated with this fact-base

Initargs

:file-name

Readers

file-name.

Writers

This slot is read-only.

Slot: fact-id

The next free fact-id

Initform

0

Readers

fact-id.

Writers

(setf fact-id).

Slot: delta

A collection of history entries that have not yet been written to disk

Initform

(fact-base::queue)

Readers

delta.

Writers

(setf delta).

Slot: tags

The collection of history tags in effect on this fact base

Readers

tags.

Writers

(setf tags).

Slot: current

The current projection of this fact-base

Readers

current.

Writers

(setf current).

Slot: index

The index structure of the current projection (used to accelerate queries)

Initargs

:index

Readers

index.

Writers

(setf index).

Slot: entry-count

The count of entries in disk history.

Initform

0

Readers

entry-count.

Writers

(setf entry-count).

Slot: earliest-entry

The earliest entry in the disk history.

Initargs

:earliest-entry

Readers

earliest-entry.

Writers

(setf earliest-entry).

Slot: in-memory?

Flag that designates whether this fact-base is going to keep its history in memory or on disk.
For fact bases with a relatively short history, and/or ones with a requirement for high-frequency rewind, keeping it in memory makes more sense. If you don’t need rewinding very often or quickly, or will keep a very deep history for a particular notebook, maybe keep it on disk.

Initargs

:in-memory?

Readers

in-memory?.

Writers

This slot is read-only.

Slot: history

If ‘in-memory?‘ is true, this should be a queue of this fact-bases’ history entries.

Initargs

:history

Readers

history.

Writers

This slot is read-only.

Slot: latest-entry

The latest entry in the disk history.

Initargs

:latest-entry

Readers

latest-entry.

Writers

(setf latest-entry).


5.2 Internals


5.2.1 Special variables

Special Variable: +fail+
Package

fact-base.

Source

unify.lisp.


5.2.2 Macros

Macro: index-case (ix-type fact &rest indices)
Package

fact-base.

Source

index.lisp.

Macro: lookup-index (state &rest indices)
Package

fact-base.

Source

index.lisp.

Macro: with-open-elif ((stream file-name) &body body)
Package

fact-base.

Source

util.lisp.


5.2.3 Ordinary functions

Function: and-goals (base goals &optional bindings)
Package

fact-base.

Source

unify.lisp.

Function: any-variables? (exp)
Package

fact-base.

Source

util.lisp.

Function: binding-value (binding)
Package

fact-base.

Source

util.lisp.

Function: change-fact-internal! (state old new &key update-delta?)
Package

fact-base.

Source

fact-base.lisp.

Function: delete-fact-internal! (state fact &key update-delta?)
Package

fact-base.

Source

fact-base.lisp.

Function: extend-bindings (var val bindings)
Package

fact-base.

Source

util.lisp.

Function: fail? (thing)
Package

fact-base.

Source

unify.lisp.

Function: get-binding (var bindings)
Package

fact-base.

Source

util.lisp.

Function: hash (&rest k/v-pairs)
Package

fact-base.

Source

util.lisp.

Function: insert-fact-internal! (state fact &key update-delta?)
Package

fact-base.

Source

fact-base.lisp.

Function: lisp-goals (goals &optional bindings)
Package

fact-base.

Source

unify.lisp.

Function: list->timestamp (timestamp-list)
Package

fact-base.

Source

util.lisp.

Function: lookup-binding (var bindings)
Package

fact-base.

Source

util.lisp.

Function: make-goal (base goal &optional bindings)
Package

fact-base.

Source

unify.lisp.

Function: make-index (indices)
Package

fact-base.

Source

index.lisp.

Function: make-range-fn (&optional min-time max-time)
Package

fact-base.

Source

util.lisp.

Function: not-goals (base goals &optional bindings)
Package

fact-base.

Source

unify.lisp.

Function: occurs-check (var x bindings)
Package

fact-base.

Source

unify.lisp.

Function: or-goals (base goals &optional bindings)
Package

fact-base.

Source

unify.lisp.

Function: queue (&optional elems)
Package

fact-base.

Source

queue.lisp.

Function: reverse-from-end-until (state fn)
Package

fact-base.

Source

fact-base.lisp.

Function: single-goal (base goal-form &optional bindings)
Package

fact-base.

Source

unify.lisp.

Function: subst-bindings (bindings term)
Package

fact-base.

Source

util.lisp.

Function: temp-file-name (&key prefix)
Package

fact-base.

Source

util.lisp.

Function: timestamp->list (timestamp)
Package

fact-base.

Source

util.lisp.

Function: unify (x y &optional bindings)
Package

fact-base.

Source

unify.lisp.

Function: unify-variable (var x bindings)
Package

fact-base.

Source

unify.lisp.

Function: unique-find-anywhere-if (predicate tree &optional found-so-far)
Package

fact-base.

Source

util.lisp.

Function: update-id! (state fact)
Package

fact-base.

Source

fact-base.lisp.

Function: variable? (thing)
Package

fact-base.

Source

unify.lisp.

Function: variables-in (thing)
Package

fact-base.

Source

unify.lisp.


5.2.4 Generic functions

Generic Function: ->key (thing)
Package

fact-base.

Methods
Method: ->key ((thing symbol))
Source

util.lisp.

Method: ->key ((thing null))
Source

util.lisp.

Generic Function: apply-entry (state entry)
Package

fact-base.

Methods
Method: apply-entry ((state list) (entry list))
Source

fact-base.lisp.

Generic Function: apply-entry! (state entry)
Package

fact-base.

Methods
Method: apply-entry! ((state fact-base) (entry list))
Source

fact-base.lisp.

Generic Function: decide-index (state &optional a b c)
Package

fact-base.

Methods
Method: decide-index ((state fact-base) &optional a b c)
Source

index.lisp.

Generic Function: delete (state fact)
Package

fact-base.

Methods
Method: delete ((state list) (fact list))
Source

fact-base.lisp.

Generic Reader: earliest-entry (object)
Generic Writer: (setf earliest-entry) (object)
Package

fact-base.

Methods
Reader Method: earliest-entry ((fact-base fact-base))
Writer Method: (setf earliest-entry) ((fact-base fact-base))

The earliest entry in the disk history.

Source

fact-base.lisp.

Target Slot

earliest-entry.

Generic Function: empty? (q)
Package

fact-base.

Methods
Method: empty? ((q queue))
Source

queue.lisp.

Generic Reader: entries (object)
Package

fact-base.

Methods
Reader Method: entries ((queue queue))

automatically generated reader method

Source

queue.lisp.

Target Slot

entries.

Generic Writer: (setf entries) (object)
Package

fact-base.

Methods
Writer Method: (setf entries) ((queue queue))

automatically generated writer method

Source

queue.lisp.

Target Slot

entries.

Generic Reader: entry-count (object)
Package

fact-base.

Methods
Reader Method: entry-count ((fact-base fact-base))

The count of entries in disk history.

Source

fact-base.lisp.

Target Slot

entry-count.

Reader Method: entry-count ((queue queue))

automatically generated reader method

Source

queue.lisp.

Target Slot

entry-count.

Generic Writer: (setf entry-count) (object)
Package

fact-base.

Methods
Writer Method: (setf entry-count) ((fact-base fact-base))

The count of entries in disk history.

Source

fact-base.lisp.

Target Slot

entry-count.

Writer Method: (setf entry-count) ((queue queue))

automatically generated writer method

Source

queue.lisp.

Target Slot

entry-count.

Generic Reader: fact-id (object)
Generic Writer: (setf fact-id) (object)
Package

fact-base.

Methods
Reader Method: fact-id ((fact-base fact-base))
Writer Method: (setf fact-id) ((fact-base fact-base))

The next free fact-id

Source

fact-base.lisp.

Target Slot

fact-id.

Generic Function: fact-p (fact)
Package

fact-base.

Methods
Method: fact-p ((fact list))
Source

util.lisp.

Method: fact-p (fact)
Source

util.lisp.

Generic Function: format-index (ix-type fact)
Package

fact-base.

Methods
Method: format-index ((ix-type symbol) (fact list))
Source

index.lisp.

Generic Reader: history (object)
Package

fact-base.

Methods
Reader Method: history ((fact-base fact-base))

If ‘in-memory?‘ is true, this should be a queue of this fact-bases’ history entries.

Source

fact-base.lisp.

Target Slot

history.

Generic Reader: in-memory? (object)
Package

fact-base.

Methods
Reader Method: in-memory? ((fact-base fact-base))

Flag that designates whether this fact-base is going to keep its history in memory or on disk.
For fact bases with a relatively short history, and/or ones with a requirement for high-frequency rewind, keeping it in memory makes more sense. If you don’t need rewinding very often or quickly, or will keep a very deep history for a particular notebook, maybe keep it on disk.

Source

fact-base.lisp.

Target Slot

in-memory?.

Generic Reader: index (object)
Generic Writer: (setf index) (object)
Package

fact-base.

Methods
Reader Method: index ((fact-base fact-base))
Writer Method: (setf index) ((fact-base fact-base))

The index structure of the current projection (used to accelerate queries)

Source

fact-base.lisp.

Target Slot

index.

Generic Function: indexed? (state ix-type)
Package

fact-base.

Methods
Method: indexed? ((state index) (ix-type symbol))
Source

index.lisp.

Generic Function: insert (state fact)
Package

fact-base.

Methods
Method: insert ((state list) (fact list))
Source

fact-base.lisp.

Generic Function: key->symbols (keyword)
Package

fact-base.

Methods
Method: key->symbols ((keyword symbol))
Source

util.lisp.

Generic Reader: last-cons (object)
Package

fact-base.

Methods
Reader Method: last-cons ((queue queue))

automatically generated reader method

Source

queue.lisp.

Target Slot

last-cons.

Generic Writer: (setf last-cons) (object)
Package

fact-base.

Methods
Writer Method: (setf last-cons) ((queue queue))

automatically generated writer method

Source

queue.lisp.

Target Slot

last-cons.

Generic Reader: latest-entry (object)
Generic Writer: (setf latest-entry) (object)
Package

fact-base.

Methods
Reader Method: latest-entry ((fact-base fact-base))
Writer Method: (setf latest-entry) ((fact-base fact-base))

The latest entry in the disk history.

Source

fact-base.lisp.

Target Slot

latest-entry.

Generic Function: map-insert! (state facts)
Package

fact-base.

Methods
Method: map-insert! ((state index) (facts list))
Source

index.lisp.

Generic Function: pop! (q)
Package

fact-base.

Methods
Method: pop! ((q queue))
Source

queue.lisp.

Generic Function: pre-search (goal-form facts &optional bindings)
Package

fact-base.

Methods
Method: pre-search (goal-form facts &optional bindings)
Source

unify.lisp.

Generic Function: push! (entry q)
Package

fact-base.

Methods
Method: push! (entry (q queue))
Source

queue.lisp.

Generic Function: read-entry! (s)
Package

fact-base.

Methods
Method: read-entry! ((s stream))
Source

fact-base.lisp.

Generic Function: read-entry-from-end! (s &key skip)
Package

fact-base.

Methods
Method: read-entry-from-end! ((s stream) &key skip)

Only use this inside of ‘with-open-elif‘.
It’s just an EXTREMELY expensive, non forwarding version of read-entry! otherwise.
Takes a stream opened with ‘with-open-elif‘, returns a history entry from the end of that file.
Two keyword arguments:
- :skip - is a number of entries to skip before the one we want (defaults to 0, which gives the last one)

Source

fact-base.lisp.

Generic Function: reverse-entry (state entry)
Package

fact-base.

Methods
Method: reverse-entry ((state list) (entry list))
Source

fact-base.lisp.

Generic Function: reverse-entry! (state entry)
Package

fact-base.

Methods
Method: reverse-entry! ((state fact-base) (entry list))
Source

fact-base.lisp.

Generic Function: rewind-by-internal (state count)
Package

fact-base.

Methods
Method: rewind-by-internal ((state fact-base) (count integer))
Source

fact-base.lisp.

Generic Function: show (thing &optional depth)
Package

fact-base.

Methods
Method: show ((ix index) &optional depth)
Source

index.lisp.

Method: show ((tbl hash-table) &optional depth)
Source

index.lisp.

Method: show (thing &optional depth)
Source

index.lisp.

Generic Reader: table (object)
Package

fact-base.

Methods
Reader Method: table ((index index))

automatically generated reader method

Source

fact-base.lisp.

Target Slot

table.

Generic Reader: tags (object)
Generic Writer: (setf tags) (object)
Package

fact-base.

Methods
Reader Method: tags ((fact-base fact-base))
Writer Method: (setf tags) ((fact-base fact-base))

The collection of history tags in effect on this fact base

Source

fact-base.lisp.

Target Slot

tags.

Generic Function: write-entries! (entries file if-exists)
Package

fact-base.

Methods
Method: write-entries! ((entries list) (file string) if-exists)
Source

fact-base.lisp.

Method: write-entries! ((entries list) (file pathname) if-exists)
Source

fact-base.lisp.

Generic Function: write-entry! (entry s)
Package

fact-base.

Methods
Method: write-entry! ((entry list) (s stream))
Source

fact-base.lisp.


5.2.5 Classes

Class: index
Package

fact-base.

Source

fact-base.lisp.

Direct methods
Direct slots
Slot: table
Initform

(make-hash-table :test (quote equal))

Readers

table.

Writers

This slot is read-only.

Class: queue
Package

fact-base.

Source

queue.lisp.

Direct methods
Direct slots
Slot: entries
Initargs

:entries

Readers

entries.

Writers

(setf entries).

Slot: entry-count
Initform

0

Initargs

:entry-count

Readers

entry-count.

Writers

(setf entry-count).

Slot: last-cons
Initargs

:last-cons

Readers

last-cons.

Writers

(setf last-cons).


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   (   -  
A   B   C   D   E   F   G   H   I   K   L   M   N   O   P   Q   R   S   T   U   V   W  
Index Entry  Section

(
(setf current): Public generic functions
(setf current): Public generic functions
(setf delta): Public generic functions
(setf delta): Public generic functions
(setf earliest-entry): Private generic functions
(setf earliest-entry): Private generic functions
(setf entries): Private generic functions
(setf entries): Private generic functions
(setf entry-count): Private generic functions
(setf entry-count): Private generic functions
(setf entry-count): Private generic functions
(setf fact-id): Private generic functions
(setf fact-id): Private generic functions
(setf index): Private generic functions
(setf index): Private generic functions
(setf last-cons): Private generic functions
(setf last-cons): Private generic functions
(setf latest-entry): Private generic functions
(setf latest-entry): Private generic functions
(setf tags): Private generic functions
(setf tags): Private generic functions

-
->key: Private generic functions
->key: Private generic functions
->key: Private generic functions

A
and-goals: Private ordinary functions
any-variables?: Private ordinary functions
apply-entry: Private generic functions
apply-entry: Private generic functions
apply-entry!: Private generic functions
apply-entry!: Private generic functions

B
base!: Public generic functions
base!: Public generic functions
binding-value: Private ordinary functions

C
change!: Public generic functions
change!: Public generic functions
change-fact-internal!: Private ordinary functions
current: Public generic functions
current: Public generic functions

D
decide-index: Private generic functions
decide-index: Private generic functions
delete: Private generic functions
delete: Private generic functions
delete!: Public generic functions
delete!: Public generic functions
delete!: Public generic functions
delete-fact-internal!: Private ordinary functions
delta: Public generic functions
delta: Public generic functions

E
earliest-entry: Private generic functions
earliest-entry: Private generic functions
empty?: Private generic functions
empty?: Private generic functions
entries: Private generic functions
entries: Private generic functions
entry-count: Private generic functions
entry-count: Private generic functions
entry-count: Private generic functions
extend-bindings: Private ordinary functions

F
fact-id: Private generic functions
fact-id: Private generic functions
fact-p: Private generic functions
fact-p: Private generic functions
fact-p: Private generic functions
fail?: Private ordinary functions
file-name: Public generic functions
file-name: Public generic functions
for-all: Public macros
fork-at: Public generic functions
fork-at: Public generic functions
format-index: Private generic functions
format-index: Private generic functions
Function, and-goals: Private ordinary functions
Function, any-variables?: Private ordinary functions
Function, binding-value: Private ordinary functions
Function, change-fact-internal!: Private ordinary functions
Function, delete-fact-internal!: Private ordinary functions
Function, extend-bindings: Private ordinary functions
Function, fail?: Private ordinary functions
Function, get-binding: Private ordinary functions
Function, hash: Private ordinary functions
Function, insert-fact-internal!: Private ordinary functions
Function, lisp-goals: Private ordinary functions
Function, list->timestamp: Private ordinary functions
Function, lookup-binding: Private ordinary functions
Function, make-fact-base: Public ordinary functions
Function, make-goal: Private ordinary functions
Function, make-index: Private ordinary functions
Function, make-range-fn: Private ordinary functions
Function, not-goals: Private ordinary functions
Function, occurs-check: Private ordinary functions
Function, or-goals: Private ordinary functions
Function, queue: Private ordinary functions
Function, reverse-from-end-until: Private ordinary functions
Function, single-goal: Private ordinary functions
Function, subst-bindings: Private ordinary functions
Function, temp-file-name: Private ordinary functions
Function, timestamp->list: Private ordinary functions
Function, unify: Private ordinary functions
Function, unify-variable: Private ordinary functions
Function, unique-find-anywhere-if: Private ordinary functions
Function, update-id!: Private ordinary functions
Function, variable?: Private ordinary functions
Function, variables-in: Private ordinary functions

G
Generic Function, (setf current): Public generic functions
Generic Function, (setf delta): Public generic functions
Generic Function, (setf earliest-entry): Private generic functions
Generic Function, (setf entries): Private generic functions
Generic Function, (setf entry-count): Private generic functions
Generic Function, (setf fact-id): Private generic functions
Generic Function, (setf index): Private generic functions
Generic Function, (setf last-cons): Private generic functions
Generic Function, (setf latest-entry): Private generic functions
Generic Function, (setf tags): Private generic functions
Generic Function, ->key: Private generic functions
Generic Function, apply-entry: Private generic functions
Generic Function, apply-entry!: Private generic functions
Generic Function, base!: Public generic functions
Generic Function, change!: Public generic functions
Generic Function, current: Public generic functions
Generic Function, decide-index: Private generic functions
Generic Function, delete: Private generic functions
Generic Function, delete!: Public generic functions
Generic Function, delta: Public generic functions
Generic Function, earliest-entry: Private generic functions
Generic Function, empty?: Private generic functions
Generic Function, entries: Private generic functions
Generic Function, entry-count: Private generic functions
Generic Function, fact-id: Private generic functions
Generic Function, fact-p: Private generic functions
Generic Function, file-name: Public generic functions
Generic Function, fork-at: Public generic functions
Generic Function, format-index: Private generic functions
Generic Function, history: Private generic functions
Generic Function, in-memory?: Private generic functions
Generic Function, index: Private generic functions
Generic Function, index!: Public generic functions
Generic Function, indexed?: Private generic functions
Generic Function, insert: Private generic functions
Generic Function, insert!: Public generic functions
Generic Function, insert-if-unique!: Public generic functions
Generic Function, insert-new!: Public generic functions
Generic Function, key->symbols: Private generic functions
Generic Function, last-cons: Private generic functions
Generic Function, latest-entry: Private generic functions
Generic Function, load!: Public generic functions
Generic Function, lookup: Public generic functions
Generic Function, map-insert!: Private generic functions
Generic Function, multi-insert!: Public generic functions
Generic Function, next-id!: Public generic functions
Generic Function, pop!: Private generic functions
Generic Function, pre-search: Private generic functions
Generic Function, push!: Private generic functions
Generic Function, read-entry!: Private generic functions
Generic Function, read-entry-from-end!: Private generic functions
Generic Function, reverse-entry: Private generic functions
Generic Function, reverse-entry!: Private generic functions
Generic Function, rewind-by: Public generic functions
Generic Function, rewind-by-internal: Private generic functions
Generic Function, rewind-to: Public generic functions
Generic Function, show: Private generic functions
Generic Function, table: Private generic functions
Generic Function, tag!: Public generic functions
Generic Function, tags: Private generic functions
Generic Function, tags-of: Public generic functions
Generic Function, total-entries: Public generic functions
Generic Function, write!: Public generic functions
Generic Function, write-entries!: Private generic functions
Generic Function, write-entry!: Private generic functions
get-binding: Private ordinary functions

H
hash: Private ordinary functions
history: Private generic functions
history: Private generic functions

I
in-memory?: Private generic functions
in-memory?: Private generic functions
index: Private generic functions
index: Private generic functions
index!: Public generic functions
index!: Public generic functions
index-case: Private macros
indexed?: Private generic functions
indexed?: Private generic functions
insert: Private generic functions
insert: Private generic functions
insert!: Public generic functions
insert!: Public generic functions
insert!: Public generic functions
insert-fact-internal!: Private ordinary functions
insert-if-unique!: Public generic functions
insert-if-unique!: Public generic functions
insert-new!: Public generic functions
insert-new!: Public generic functions

K
key->symbols: Private generic functions
key->symbols: Private generic functions

L
last-cons: Private generic functions
last-cons: Private generic functions
latest-entry: Private generic functions
latest-entry: Private generic functions
lisp-goals: Private ordinary functions
list->timestamp: Private ordinary functions
load!: Public generic functions
load!: Public generic functions
lookup: Public generic functions
lookup: Public generic functions
lookup: Public generic functions
lookup-binding: Private ordinary functions
lookup-index: Private macros

M
Macro, for-all: Public macros
Macro, index-case: Private macros
Macro, lookup-index: Private macros
Macro, with-open-elif: Private macros
make-fact-base: Public ordinary functions
make-goal: Private ordinary functions
make-index: Private ordinary functions
make-range-fn: Private ordinary functions
map-insert!: Private generic functions
map-insert!: Private generic functions
Method, (setf current): Public generic functions
Method, (setf delta): Public generic functions
Method, (setf earliest-entry): Private generic functions
Method, (setf entries): Private generic functions
Method, (setf entry-count): Private generic functions
Method, (setf entry-count): Private generic functions
Method, (setf fact-id): Private generic functions
Method, (setf index): Private generic functions
Method, (setf last-cons): Private generic functions
Method, (setf latest-entry): Private generic functions
Method, (setf tags): Private generic functions
Method, ->key: Private generic functions
Method, ->key: Private generic functions
Method, apply-entry: Private generic functions
Method, apply-entry!: Private generic functions
Method, base!: Public generic functions
Method, change!: Public generic functions
Method, current: Public generic functions
Method, decide-index: Private generic functions
Method, delete: Private generic functions
Method, delete!: Public generic functions
Method, delete!: Public generic functions
Method, delta: Public generic functions
Method, earliest-entry: Private generic functions
Method, empty?: Private generic functions
Method, entries: Private generic functions
Method, entry-count: Private generic functions
Method, entry-count: Private generic functions
Method, fact-id: Private generic functions
Method, fact-p: Private generic functions
Method, fact-p: Private generic functions
Method, file-name: Public generic functions
Method, fork-at: Public generic functions
Method, format-index: Private generic functions
Method, history: Private generic functions
Method, in-memory?: Private generic functions
Method, index: Private generic functions
Method, index!: Public generic functions
Method, indexed?: Private generic functions
Method, insert: Private generic functions
Method, insert!: Public generic functions
Method, insert!: Public generic functions
Method, insert-if-unique!: Public generic functions
Method, insert-new!: Public generic functions
Method, key->symbols: Private generic functions
Method, last-cons: Private generic functions
Method, latest-entry: Private generic functions
Method, load!: Public generic functions
Method, lookup: Public generic functions
Method, lookup: Public generic functions
Method, map-insert!: Private generic functions
Method, multi-insert!: Public generic functions
Method, next-id!: Public generic functions
Method, pop!: Private generic functions
Method, pre-search: Private generic functions
Method, push!: Private generic functions
Method, read-entry!: Private generic functions
Method, read-entry-from-end!: Private generic functions
Method, reverse-entry: Private generic functions
Method, reverse-entry!: Private generic functions
Method, rewind-by: Public generic functions
Method, rewind-by-internal: Private generic functions
Method, rewind-to: Public generic functions
Method, rewind-to: Public generic functions
Method, rewind-to: Public generic functions
Method, show: Private generic functions
Method, show: Private generic functions
Method, show: Private generic functions
Method, table: Private generic functions
Method, tag!: Public generic functions
Method, tags: Private generic functions
Method, tags-of: Public generic functions
Method, total-entries: Public generic functions
Method, write!: Public generic functions
Method, write-entries!: Private generic functions
Method, write-entries!: Private generic functions
Method, write-entry!: Private generic functions
multi-insert!: Public generic functions
multi-insert!: Public generic functions

N
next-id!: Public generic functions
next-id!: Public generic functions
not-goals: Private ordinary functions

O
occurs-check: Private ordinary functions
or-goals: Private ordinary functions

P
pop!: Private generic functions
pop!: Private generic functions
pre-search: Private generic functions
pre-search: Private generic functions
push!: Private generic functions
push!: Private generic functions

Q
queue: Private ordinary functions

R
read-entry!: Private generic functions
read-entry!: Private generic functions
read-entry-from-end!: Private generic functions
read-entry-from-end!: Private generic functions
reverse-entry: Private generic functions
reverse-entry: Private generic functions
reverse-entry!: Private generic functions
reverse-entry!: Private generic functions
reverse-from-end-until: Private ordinary functions
rewind-by: Public generic functions
rewind-by: Public generic functions
rewind-by-internal: Private generic functions
rewind-by-internal: Private generic functions
rewind-to: Public generic functions
rewind-to: Public generic functions
rewind-to: Public generic functions
rewind-to: Public generic functions

S
show: Private generic functions
show: Private generic functions
show: Private generic functions
show: Private generic functions
single-goal: Private ordinary functions
subst-bindings: Private ordinary functions

T
table: Private generic functions
table: Private generic functions
tag!: Public generic functions
tag!: Public generic functions
tags: Private generic functions
tags: Private generic functions
tags-of: Public generic functions
tags-of: Public generic functions
temp-file-name: Private ordinary functions
timestamp->list: Private ordinary functions
total-entries: Public generic functions
total-entries: Public generic functions

U
unify: Private ordinary functions
unify-variable: Private ordinary functions
unique-find-anywhere-if: Private ordinary functions
update-id!: Private ordinary functions

V
variable?: Private ordinary functions
variables-in: Private ordinary functions

W
with-open-elif: Private macros
write!: Public generic functions
write!: Public generic functions
write-entries!: Private generic functions
write-entries!: Private generic functions
write-entries!: Private generic functions
write-entry!: Private generic functions
write-entry!: Private generic functions