The fact-base Reference Manual

Table of Contents

The fact-base Reference Manual

This is the fact-base Reference Manual, generated automatically by Declt version 3.0 "Montgomery Scott" on Tue Apr 28 11:46:27 2020 GMT+0.

1 Introduction

fact-base

Simple implementation of fact-base data storage for Common Lisp

Requirements

:fact-base depends on alexandria, anaphora, local-time, optima and cl-fad. All of them installable via quicklisp.

Example Usage

; SLIME 2013-11-17
CL-USER> (ql:quickload :fact-base)
To load "fact-base":
  Load 1 ASDF system:
    fact-base
; Loading "fact-base"

(:FACT-BASE)
CL-USER> (defpackage :demo (:use :cl :fact-base))
#<PACKAGE "DEMO">
CL-USER> (in-package :demo)
#<PACKAGE "DEMO">
DEMO> (defparameter *db* (make-fact-base))
*DB*
DEMO> (insert! *db* (list 0 :message "This is a sample message"))
NIL
DEMO> (insert! *db* (list 1 :message "This is another one"))
NIL
DEMO> (insert! *db* (list 1 :author "Inaimathi"))
NIL
DEMO> (insert! *db* (list 2 :message "That second one was written by me. This one is a meta-message."))
NIL
DEMO> (insert! *db* (list 2 :type :meta))
NIL
DEMO> (current *db*)
((2 :TYPE :META)
 (2 :MESSAGE "That second one was written by me. This one is a meta-message.")
 (1 :AUTHOR "Inaimathi") (1 :MESSAGE "This is another one")
 (0 :MESSAGE "This is a sample message"))
DEMO> (history *db*)
((@2014-03-20T09:47:19.622527-04:00 :INSERT (2 :TYPE :META))
 (@2014-03-20T09:47:16.186383-04:00 :INSERT
  (2 :MESSAGE
   "That second one was written by me. This one is a meta-message."))
 (@2014-03-20T09:47:08.834689-04:00 :INSERT (1 :AUTHOR "Inaimathi"))
 (@2014-03-20T09:47:03.936936-04:00 :INSERT (1 :MESSAGE "This is another one"))
 (@2014-03-20T09:46:04.771430-04:00 :INSERT
  (0 :MESSAGE "This is a sample message")))
DEMO> (write! *db*)
"fb-1007"

Interlude: The file fb-1007 now contains

((5132 49564 771430000) :INSERT (0 :MESSAGE "This is a sample message"))
((5132 49623 936936000) :INSERT (1 :MESSAGE "This is another one"))
((5132 49628 834689000) :INSERT (1 :AUTHOR "Inaimathi"))
((5132 49636 186383000) :INSERT
 (2 :MESSAGE "That second one was written by me. This one is a meta-message."))
((5132 49639 622527000) :INSERT (2 :TYPE :META))

we now resume your regularly scheduled demo.

DEMO> (multi-insert!
       *db*
       '((:message "Getting sick of specifying IDs manually, so I'll use multi-insert!")
	     (:user "Inaimathi")
	     (:mood "Curious")))
3
DEMO> (current *db*)
((3 :MOOD "Curious") (3 :USER "Inaimathi")
 (3 :MESSAGE
  "Getting sick of specifying IDs manually, so I'll use multi-insert!")
 (2 :TYPE :META)
 (2 :MESSAGE "That second one was written by me. This one is a meta-message.")
 (1 :AUTHOR "Inaimathi") (1 :MESSAGE "This is another one")
 (0 :MESSAGE "This is a sample message"))
DEMO> (delta *db*)
((@2014-03-20T09:51:13.740572-04:00 :INSERT (3 :MOOD "Curious"))
 (@2014-03-20T09:51:13.740565-04:00 :INSERT (3 :USER "Inaimathi"))
 (@2014-03-20T09:51:13.740544-04:00 :INSERT
  (3 :MESSAGE
   "Getting sick of specifying IDs manually, so I'll use multi-insert!")))
DEMO> (multi-insert!
       *db*
       '((:message "This next one will just append the delta to the file created last time.")
	     (:user "Inaimathi")
	     (:mood "Still curious")))
4
DEMO> (write-delta! *db*)
"fb-1007"

Interlude 2: That same file now contains...

((5132 49564 771430000) :INSERT (0 :MESSAGE "This is a sample message"))
((5132 49623 936936000) :INSERT (1 :MESSAGE "This is another one"))
((5132 49628 834689000) :INSERT (1 :AUTHOR "Inaimathi"))
((5132 49636 186383000) :INSERT
 (2 :MESSAGE "That second one was written by me. This one is a meta-message."))
((5132 49639 622527000) :INSERT (2 :TYPE :META))
((5132 49873 740544000) :INSERT
 (3 :MESSAGE
  "Getting sick of specifying IDs manually, so I'll use multi-insert!"))
((5132 49873 740565000) :INSERT (3 :USER "Inaimathi"))
((5132 49873 740572000) :INSERT (3 :MOOD "Curious"))
((5132 49927 302099000) :INSERT
 (4 :MESSAGE
  "This next one will just append the delta to the file created last time."))
((5132 49927 302129000) :INSERT (4 :USER "Inaimathi"))
((5132 49927 302139000) :INSERT (4 :MOOD "Still curious"))

That file wasn't cleared, then re-written. The delta was just appended to the bottom. Note that both write! and write-delta! take an optional filename as a parameter, so it's possible to break a fact-base up across files or back it up in another location

DEMO> (multi-insert!
       *db*
       '((:message "Ok, lets do some lookups now")
	     (:user "Inaimathi")
	     (:mood "Thoughtful")))
5
DEMO> (lookup *db* :a 0)
((0 :MESSAGE "This is a sample message"))
T
DEMO> (lookup *db* :a 2)
((2 :TYPE :META)
 (2 :MESSAGE "That second one was written by me. This one is a meta-message."))
T
DEMO> (lookup *db* :b :nope)
NIL
NIL
DEMO> (lookup *db* :b :user)
((5 :USER "Inaimathi") (4 :USER "Inaimathi") (3 :USER "Inaimathi"))
T
DEMO> (lookup *db* :a 3)
((3 :MOOD "Curious") (3 :USER "Inaimathi")
 (3 :MESSAGE
  "Getting sick of specifying IDs manually, so I'll use multi-insert!"))
T
DEMO> (lookup *db* :a 4)
((4 :MOOD "Still curious") (4 :USER "Inaimathi")
 (4 :MESSAGE
  "This next one will just append the delta to the file created last time."))
T
DEMO> (lookup *db* :a 5)
((5 :MOOD "Thoughtful") (5 :USER "Inaimathi")
 (5 :MESSAGE "Ok, lets do some lookups now"))
T
DEMO> (lookup *db* :a 5 :b :user)
WARNING: No relevant index found, traversing...

((5 :USER "Inaimathi"))
DEMO> (multi-insert!
       *db*
       '((:message "The index system is still naive. It only has separate indices on :a, :b and :c, you see, but it doesn't save itself the time by at least starting with the smallest known index yet.")
	     (:user "Inaimathi")
	     (:mood "Even more thoughtful")))
6
DEMO> (multi-insert!
       *db*
       '((:message "I'm going to fix that. In fact...")
	     (:user "Inaimathi")
	     (:mood "Even more thoughtful")))
7
DEMO> (lookup *db* :c "Even more thoughtful")

((7 :MOOD "Even more thoughtful") (6 :MOOD "Even more thoughtful"))
T
DEMO> (insert! *db* (list 6 :important nil))
NIL
DEMO> (multi-insert!
       *db*
       '((:message "Yes, you can add metadata after the fact.")
	     (:user "Inaimathi")
	     (:mood "Oh, right...")))
8
DEMO> 

Function documentation

:make-fact-base

:file-name

:next-id!

:lookup

:select

:matching?

:insert!

:multi-insert!

:delete!

:project!

:project

:write-delta!

:write!

:update!

:load!

Notes

• No, we're not going to implement :initial. Compressing stuff on disk would be a better approach than cutting history when you need to branch, and it would let us defer decisions about internal fact-base projection formats (specifically as pertains to the next note)

• Define a structure other than a list to store history. -Specifically, you want the ability to push to its end (since that's the only way we'll ever be doing it)

See also

The following posts talk about some of the design decisions and parts of the code of :fact-base

• Fact Bases and Total History
• Fact Base Indices
• Querying Fact Bases
• Querying Fact Bases Redux

2 Systems

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

2.1 fact-base

Author

Inaimathi <leo.zovic@gmail.com>

License

AGPL3

Description

Simple implementation of fact-base data storage for Common Lisp

Dependencies

• alexandria
• local-time
• optima
• cl-fad

Source

fact-base.asd (file)

Components

• package.lisp (file)
• util.lisp (file)
• queue.lisp (file)
• fact-base.lisp (file)
• index.lisp (file)
• unify.lisp (file)

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.asd

Location

fact-base.asd

Systems

fact-base (system)

3.1.2 fact-base/package.lisp

Parent

fact-base (system)

Location

package.lisp

Packages

fact-base

3.1.3 fact-base/util.lisp

Dependency

package.lisp (file)

Parent

fact-base (system)

Location

util.lisp

Internal Definitions

• ->key (method)
• ->key (method)
• any-variables? (function)
• binding-value (function)
• extend-bindings (function)
• fact-p (method)
• fact-p (method)
• get-binding (function)
• hash (function)
• key->symbols (method)
• list->timestamp (function)
• lookup-binding (function)
• make-range-fn (function)
• subst-bindings (function)
• temp-file-name (function)
• timestamp->list (function)
• unique-find-anywhere-if (function)
• with-open-elif (macro)

3.1.4 fact-base/queue.lisp

Dependency

util.lisp (file)

Parent

fact-base (system)

Location

queue.lisp

Internal Definitions

• empty? (method)
• entries (method)
• (setf entries) (method)
• entry-count (method)
• (setf entry-count) (method)
• last-cons (method)
• (setf last-cons) (method)
• pop! (method)
• push! (method)
• queue (function)
• queue (class)

3.1.5 fact-base/fact-base.lisp

Dependency

queue.lisp (file)

Parent

fact-base (system)

Location

fact-base.lisp

Exported Definitions

• base! (method)
• change! (method)
• current (method)
• (setf current) (method)
• delete! (method)
• delta (method)
• (setf delta) (method)
• fact-base (class)
• file-name (method)
• fork-at (method)
• index! (method)
• insert! (method)
• insert-if-unique! (method)
• insert-new! (method)
• load! (method)
• lookup (method)
• lookup (method)
• make-fact-base (function)
• multi-insert! (method)
• next-id! (method)
• rewind-by (method)
• rewind-to (method)
• rewind-to (method)
• rewind-to (method)
• tag! (method)
• tags-of (method)
• total-entries (method)
• write! (method)

Internal Definitions

• apply-entry (method)
• apply-entry! (method)
• change-fact-internal! (function)
• delete (method)
• delete-fact-internal! (function)
• earliest-entry (method)
• (setf earliest-entry) (method)
• entry-count (method)
• (setf entry-count) (method)
• fact-id (method)
• (setf fact-id) (method)
• history (method)
• in-memory? (method)
• index (method)
• (setf index) (method)
• index (class)
• insert (method)
• insert-fact-internal! (function)
• latest-entry (method)
• (setf latest-entry) (method)
• read-entry! (method)
• read-entry-from-end! (method)
• reverse-entry (method)
• reverse-entry! (method)
• reverse-from-end-until (function)
• rewind-by-internal (method)
• table (method)
• tags (method)
• (setf tags) (method)
• update-id! (function)
• write-entries! (method)
• write-entries! (method)
• write-entry! (method)

3.1.6 fact-base/index.lisp

Dependency

fact-base.lisp (file)

Parent

fact-base (system)

Location

index.lisp

Exported Definitions

• delete! (method)
• insert! (method)

Internal Definitions

• decide-index (method)
• format-index (method)
• index-case (macro)
• indexed? (method)
• lookup-index (macro)
• make-index (function)
• map-insert! (method)
• show (method)
• show (method)
• show (method)

3.1.7 fact-base/unify.lisp

Dependency

index.lisp (file)

Parent

fact-base (system)

Location

unify.lisp

Exported Definitions

for-all (macro)

Internal Definitions

• +fail+ (special variable)
• and-goals (function)
• fail? (function)
• lisp-goals (function)
• make-goal (function)
• not-goals (function)
• occurs-check (function)
• or-goals (function)
• pre-search (method)
• single-goal (function)
• unify (function)
• unify-variable (function)
• variable? (function)
• variables-in (function)

4 Packages

Packages are listed by definition order.

4.1 fact-base

Source

package.lisp (file)

Use List

• optima
• common-lisp

Exported Definitions

• base! (generic function)
• base! (method)
• change! (generic function)
• change! (method)
• current (generic function)
• current (method)
• (setf current) (method)
• (setf current) (generic function)
• delete! (generic function)
• delete! (method)
• delete! (method)
• delta (generic function)
• delta (method)
• (setf delta) (method)
• (setf delta) (generic function)
• fact-base (class)
• file-name (generic function)
• file-name (method)
• for-all (macro)
• fork-at (generic function)
• fork-at (method)
• index! (generic function)
• index! (method)
• insert! (generic function)
• insert! (method)
• insert! (method)
• insert-if-unique! (generic function)
• insert-if-unique! (method)
• insert-new! (generic function)
• insert-new! (method)
• load! (generic function)
• load! (method)
• lookup (generic function)
• lookup (method)
• lookup (method)
• make-fact-base (function)
• multi-insert! (generic function)
• multi-insert! (method)
• next-id! (generic function)
• next-id! (method)
• rewind-by (generic function)
• rewind-by (method)
• rewind-to (generic function)
• rewind-to (method)
• rewind-to (method)
• rewind-to (method)
• tag! (generic function)
• tag! (method)
• tags-of (generic function)
• tags-of (method)
• total-entries (generic function)
• total-entries (method)
• write! (generic function)
• write! (method)

Internal Definitions

• +fail+ (special variable)
• ->key (generic function)
• ->key (method)
• ->key (method)
• and-goals (function)
• any-variables? (function)
• apply-entry (generic function)
• apply-entry (method)
• apply-entry! (generic function)
• apply-entry! (method)
• binding-value (function)
• change-fact-internal! (function)
• decide-index (generic function)
• decide-index (method)
• delete (generic function)
• delete (method)
• delete-fact-internal! (function)
• earliest-entry (generic function)
• earliest-entry (method)
• (setf earliest-entry) (method)
• (setf earliest-entry) (generic function)
• empty? (generic function)
• empty? (method)
• entries (generic function)
• entries (method)
• (setf entries) (method)
• (setf entries) (generic function)
• entry-count (generic function)
• entry-count (method)
• (setf entry-count) (method)
• entry-count (method)
• (setf entry-count) (method)
• (setf entry-count) (generic function)
• extend-bindings (function)
• fact-id (generic function)
• fact-id (method)
• (setf fact-id) (method)
• (setf fact-id) (generic function)
• fact-p (generic function)
• fact-p (method)
• fact-p (method)
• fail? (function)
• format-index (generic function)
• format-index (method)
• get-binding (function)
• hash (function)
• history (generic function)
• history (method)
• in-memory? (generic function)
• in-memory? (method)
• index (generic function)
• index (method)
• (setf index) (method)
• (setf index) (generic function)
• index (class)
• index-case (macro)
• indexed? (generic function)
• indexed? (method)
• insert (generic function)
• insert (method)
• insert-fact-internal! (function)
• key->symbols (generic function)
• key->symbols (method)
• last-cons (generic function)
• last-cons (method)
• (setf last-cons) (method)
• (setf last-cons) (generic function)
• latest-entry (generic function)
• latest-entry (method)
• (setf latest-entry) (method)
• (setf latest-entry) (generic function)
• lisp-goals (function)
• list->timestamp (function)
• lookup-binding (function)
• lookup-index (macro)
• make-goal (function)
• make-index (function)
• make-range-fn (function)
• map-insert! (generic function)
• map-insert! (method)
• not-goals (function)
• occurs-check (function)
• or-goals (function)
• pop! (generic function)
• pop! (method)
• pre-search (generic function)
• pre-search (method)
• push! (generic function)
• push! (method)
• queue (function)
• queue (class)
• read-entry! (generic function)
• read-entry! (method)
• read-entry-from-end! (generic function)
• read-entry-from-end! (method)
• reverse-entry (generic function)
• reverse-entry (method)
• reverse-entry! (generic function)
• reverse-entry! (method)
• reverse-from-end-until (function)
• rewind-by-internal (generic function)
• rewind-by-internal (method)
• show (generic function)
• show (method)
• show (method)
• show (method)
• single-goal (function)
• subst-bindings (function)
• table (generic function)
• table (method)
• tags (generic function)
• tags (method)
• (setf tags) (method)
• (setf tags) (generic function)
• temp-file-name (function)
• timestamp->list (function)
• unify (function)
• unify-variable (function)
• unique-find-anywhere-if (function)
• update-id! (function)
• variable? (function)
• variables-in (function)
• with-open-elif (macro)
• write-entries! (generic function)
• write-entries! (method)
• write-entries! (method)
• write-entry! (generic function)
• write-entry! (method)

5 Definitions

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

5.1 Exported definitions

5.1.1 Macros

Macro: for-all GOAL-TERM &key IN COLLECT DO

Package

fact-base

Source

unify.lisp (file)

5.1.2 Functions

Function: make-fact-base &key INDICES FILE-NAME IN-MEMORY?

Package

fact-base

Source

fact-base.lisp (file)

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 (file)

Generic Function: change! STATE OLD NEW

Package

fact-base

Methods

Method: change! (STATE fact-base) (OLD list) (NEW list)

Source

fact-base.lisp (file)

Generic Function: current OBJECT

Generic Function: (setf current) NEW-VALUE OBJECT

Package

fact-base

Methods

Method: current (FACT-BASE fact-base)

Method: (setf current) NEW-VALUE (FACT-BASE fact-base)

The current projection of this fact-base

Source

fact-base.lisp (file)

Generic Function: delete! STATE FACT

Package

fact-base

Methods

Method: delete! (STATE index) (FACT list)

Source

index.lisp (file)

Method: delete! (STATE fact-base) (FACT list)

Source

fact-base.lisp (file)

Generic Function: delta OBJECT

Generic Function: (setf delta) NEW-VALUE OBJECT

Package

fact-base

Methods

Method: delta (FACT-BASE fact-base)

Method: (setf delta) NEW-VALUE (FACT-BASE fact-base)

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

Source

fact-base.lisp (file)

Generic Function: file-name OBJECT

Package

fact-base

Methods

Method: file-name (FACT-BASE fact-base)

The file associated with this fact-base

Source

fact-base.lisp (file)

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 (file)

Generic Function: index! STATE INDICES

Package

fact-base

Methods

Method: index! (STATE fact-base) (INDICES list)

Source

fact-base.lisp (file)

Generic Function: insert! STATE FACT

Package

fact-base

Methods

Method: insert! (STATE index) (FACT list)

Source

index.lisp (file)

Method: insert! (STATE fact-base) (FACT list)

Source

fact-base.lisp (file)

Generic Function: insert-if-unique! STATE ENTRY

Package

fact-base

Methods

Method: insert-if-unique! (STATE fact-base) (ENTRY list)

Source

fact-base.lisp (file)

Generic Function: insert-new! STATE B C

Package

fact-base

Methods

Method: insert-new! (STATE fact-base) B C

Source

fact-base.lisp (file)

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 (file)

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 (file)

Method: lookup (STATE list) &key A B C

Source

fact-base.lisp (file)

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 (file)

Generic Function: next-id! STATE

Package

fact-base

Methods

Method: next-id! (STATE fact-base)

Source

fact-base.lisp (file)

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 (file)

Generic Function: rewind-to STATE TIME

Package

fact-base

Methods

Method: rewind-to (STATE fact-base) (TAG string)

Source

fact-base.lisp (file)

Method: rewind-to (STATE fact-base) (INDEX integer)

Source

fact-base.lisp (file)

Method: rewind-to (STATE fact-base) (TIME timestamp)

Source

fact-base.lisp (file)

Generic Function: tag! STATE TAG

Package

fact-base

Methods

Method: tag! (STATE fact-base) (TAG string)

Source

fact-base.lisp (file)

Generic Function: tags-of STATE

Package

fact-base

Methods

Method: tags-of (STATE fact-base)

Source

fact-base.lisp (file)

Generic Function: total-entries STATE

Package

fact-base

Methods

Method: total-entries (STATE fact-base)

Source

fact-base.lisp (file)

Generic Function: write! STATE &key FILE-NAME

Package

fact-base

Methods

Method: write! (STATE fact-base) &key FILE-NAME

Source

fact-base.lisp (file)

5.1.4 Classes

Class: fact-base ()

Package

fact-base

Source

fact-base.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• decide-index (method)
• index! (method)
• write! (method)
• delete! (method)
• change! (method)
• insert! (method)
• tags-of (method)
• tag! (method)
• insert-if-unique! (method)
• insert-new! (method)
• multi-insert! (method)
• reverse-entry! (method)
• apply-entry! (method)
• fork-at (method)
• rewind-by (method)
• rewind-by-internal (method)
• rewind-to (method)
• rewind-to (method)
• rewind-to (method)
• lookup (method)
• next-id! (method)
• total-entries (method)
• latest-entry (method)
• latest-entry (method)
• history (method)
• in-memory? (method)
• earliest-entry (method)
• earliest-entry (method)
• entry-count (method)
• entry-count (method)
• index (method)
• index (method)
• current (method)
• current (method)
• tags (method)
• tags (method)
• delta (method)
• delta (method)
• fact-id (method)
• fact-id (method)
• file-name (method)

Direct slots

Slot: file-name

The file associated with this fact-base

Initargs

:file-name

Readers

file-name (generic function)

Slot: fact-id

The next free fact-id

Initform

0

Readers

fact-id (generic function)

Writers

(setf fact-id) (generic function)

Slot: delta

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

Initform

(fact-base::queue)

Readers

delta (generic function)

Writers

(setf delta) (generic function)

Slot: tags

The collection of history tags in effect on this fact base

Readers

tags (generic function)

Writers

(setf tags) (generic function)

Slot: current

The current projection of this fact-base

Readers

current (generic function)

Writers

(setf current) (generic function)

Slot: index

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

Initargs

:index

Readers

index (generic function)

Writers

(setf index) (generic function)

Slot: entry-count

The count of entries in disk history.

Initform

0

Readers

entry-count (generic function)

Writers

(setf entry-count) (generic function)

Slot: earliest-entry

The earliest entry in the disk history.

Initargs

:earliest-entry

Readers

earliest-entry (generic function)

Writers

(setf earliest-entry) (generic function)

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? (generic function)

Slot: history

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

Initargs

:history

Readers

history (generic function)

Slot: latest-entry

The latest entry in the disk history.

Initargs

:latest-entry

Readers

latest-entry (generic function)

Writers

(setf latest-entry) (generic function)

5.2 Internal definitions

5.2.1 Special variables

Special Variable: +fail+

Package

fact-base

Source

unify.lisp (file)

5.2.2 Macros

Macro: index-case IX-TYPE FACT &rest INDICES

Package

fact-base

Source

index.lisp (file)

Macro: lookup-index STATE &rest INDICES

Package

fact-base

Source

index.lisp (file)

Macro: with-open-elif (STREAM FILE-NAME) &body BODY

Package

fact-base

Source

util.lisp (file)

5.2.3 Functions

Function: and-goals BASE GOALS &optional BINDINGS

Package

fact-base

Source

unify.lisp (file)

Function: any-variables? EXP

Package

fact-base

Source

util.lisp (file)

Function: binding-value BINDING

Package

fact-base

Source

util.lisp (file)

Function: change-fact-internal! STATE OLD NEW &key UPDATE-DELTA?

Package

fact-base

Source

fact-base.lisp (file)

Function: delete-fact-internal! STATE FACT &key UPDATE-DELTA?

Package

fact-base

Source

fact-base.lisp (file)

Function: extend-bindings VAR VAL BINDINGS

Package

fact-base

Source

util.lisp (file)

Function: fail? THING

Package

fact-base

Source

unify.lisp (file)

Function: get-binding VAR BINDINGS

Package

fact-base

Source

util.lisp (file)

Function: hash &rest K/V-PAIRS

Package

fact-base

Source

util.lisp (file)

Function: insert-fact-internal! STATE FACT &key UPDATE-DELTA?

Package

fact-base

Source

fact-base.lisp (file)

Function: lisp-goals GOALS &optional BINDINGS

Package

fact-base

Source

unify.lisp (file)

Function: list->timestamp TIMESTAMP-LIST

Package

fact-base

Source

util.lisp (file)

Function: lookup-binding VAR BINDINGS

Package

fact-base

Source

util.lisp (file)

Function: make-goal BASE GOAL &optional BINDINGS

Package

fact-base

Source

unify.lisp (file)

Function: make-index INDICES

Package

fact-base

Source

index.lisp (file)

Function: make-range-fn &optional MIN-TIME MAX-TIME

Package

fact-base

Source

util.lisp (file)

Function: not-goals BASE GOALS &optional BINDINGS

Package

fact-base

Source

unify.lisp (file)

Function: occurs-check VAR X BINDINGS

Package

fact-base

Source

unify.lisp (file)

Function: or-goals BASE GOALS &optional BINDINGS

Package

fact-base

Source

unify.lisp (file)

Function: queue &optional ELEMS

Package

fact-base

Source

queue.lisp (file)

Function: reverse-from-end-until STATE FN

Package

fact-base

Source

fact-base.lisp (file)

Function: single-goal BASE GOAL-FORM &optional BINDINGS

Package

fact-base

Source

unify.lisp (file)

Function: subst-bindings BINDINGS TERM

Package

fact-base

Source

util.lisp (file)

Function: temp-file-name &key PREFIX

Package

fact-base

Source

util.lisp (file)

Function: timestamp->list TIMESTAMP

Package

fact-base

Source

util.lisp (file)

Function: unify X Y &optional BINDINGS

Package

fact-base

Source

unify.lisp (file)

Function: unify-variable VAR X BINDINGS

Package

fact-base

Source

unify.lisp (file)

Function: unique-find-anywhere-if PREDICATE TREE &optional FOUND-SO-FAR

Package

fact-base

Source

util.lisp (file)

Function: update-id! STATE FACT

Package

fact-base

Source

fact-base.lisp (file)

Function: variable? THING

Package

fact-base

Source

unify.lisp (file)

Function: variables-in THING

Package

fact-base

Source

unify.lisp (file)

5.2.4 Generic functions

Generic Function: ->key THING

Package

fact-base

Methods

Method: ->key (THING symbol)

Source

util.lisp (file)

Method: ->key (THING null)

Source

util.lisp (file)

Generic Function: apply-entry STATE ENTRY

Package

fact-base

Methods

Method: apply-entry (STATE list) (ENTRY list)

Source

fact-base.lisp (file)

Generic Function: apply-entry! STATE ENTRY

Package

fact-base

Methods

Method: apply-entry! (STATE fact-base) (ENTRY list)

Source

fact-base.lisp (file)

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 (file)

Generic Function: delete STATE FACT

Package

fact-base

Methods

Method: delete (STATE list) (FACT list)

Source

fact-base.lisp (file)

Generic Function: earliest-entry OBJECT

Generic Function: (setf earliest-entry) NEW-VALUE OBJECT

Package

fact-base

Methods

Method: earliest-entry (FACT-BASE fact-base)

Method: (setf earliest-entry) NEW-VALUE (FACT-BASE fact-base)

The earliest entry in the disk history.

Source

fact-base.lisp (file)

Generic Function: empty? Q

Package

fact-base

Methods

Method: empty? (Q queue)

Source

queue.lisp (file)

Generic Function: entries OBJECT

Generic Function: (setf entries) NEW-VALUE OBJECT

Package

fact-base

Methods

Method: entries (QUEUE queue)

automatically generated reader method

Source

queue.lisp (file)

Method: (setf entries) NEW-VALUE (QUEUE queue)

automatically generated writer method

Source

queue.lisp (file)

Generic Function: entry-count OBJECT

Generic Function: (setf entry-count) NEW-VALUE OBJECT

Package

fact-base

Methods

Method: entry-count (FACT-BASE fact-base)

Method: (setf entry-count) NEW-VALUE (FACT-BASE fact-base)

The count of entries in disk history.

Source

fact-base.lisp (file)

Method: entry-count (QUEUE queue)

automatically generated reader method

Source

queue.lisp (file)

Method: (setf entry-count) NEW-VALUE (QUEUE queue)

automatically generated writer method

Source

queue.lisp (file)

Generic Function: fact-id OBJECT

Generic Function: (setf fact-id) NEW-VALUE OBJECT

Package

fact-base

Methods

Method: fact-id (FACT-BASE fact-base)

Method: (setf fact-id) NEW-VALUE (FACT-BASE fact-base)

The next free fact-id

Source

fact-base.lisp (file)

Generic Function: fact-p FACT

Package

fact-base

Methods

Method: fact-p (FACT list)

Source

util.lisp (file)

Method: fact-p FACT

Source

util.lisp (file)

Generic Function: format-index IX-TYPE FACT

Package

fact-base

Methods

Method: format-index (IX-TYPE symbol) (FACT list)

Source

index.lisp (file)

Generic Function: history OBJECT

Package

fact-base

Methods

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 (file)

Generic Function: in-memory? OBJECT

Package

fact-base

Methods

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 (file)

Generic Function: index OBJECT

Generic Function: (setf index) NEW-VALUE OBJECT

Package

fact-base

Methods

Method: index (FACT-BASE fact-base)

Method: (setf index) NEW-VALUE (FACT-BASE fact-base)

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

Source

fact-base.lisp (file)

Generic Function: indexed? STATE IX-TYPE

Package

fact-base

Methods

Method: indexed? (STATE index) (IX-TYPE symbol)

Source

index.lisp (file)

Generic Function: insert STATE FACT

Package

fact-base

Methods

Method: insert (STATE list) (FACT list)

Source

fact-base.lisp (file)

Generic Function: key->symbols KEYWORD

Package

fact-base

Methods

Method: key->symbols (KEYWORD symbol)

Source

util.lisp (file)

Generic Function: last-cons OBJECT

Generic Function: (setf last-cons) NEW-VALUE OBJECT

Package

fact-base

Methods

Method: last-cons (QUEUE queue)

automatically generated reader method

Source

queue.lisp (file)

Method: (setf last-cons) NEW-VALUE (QUEUE queue)

automatically generated writer method

Source

queue.lisp (file)

Generic Function: latest-entry OBJECT

Generic Function: (setf latest-entry) NEW-VALUE OBJECT

Package

fact-base

Methods

Method: latest-entry (FACT-BASE fact-base)

Method: (setf latest-entry) NEW-VALUE (FACT-BASE fact-base)

The latest entry in the disk history.

Source

fact-base.lisp (file)

Generic Function: map-insert! STATE FACTS

Package

fact-base

Methods

Method: map-insert! (STATE index) (FACTS list)

Source

index.lisp (file)

Generic Function: pop! Q

Package

fact-base

Methods

Method: pop! (Q queue)

Source

queue.lisp (file)

Generic Function: pre-search GOAL-FORM FACTS &optional BINDINGS

Package

fact-base

Methods

Method: pre-search GOAL-FORM FACTS &optional BINDINGS

Source

unify.lisp (file)

Generic Function: push! ENTRY Q

Package

fact-base

Methods

Method: push! ENTRY (Q queue)

Source

queue.lisp (file)

Generic Function: read-entry! S

Package

fact-base

Methods

Method: read-entry! (S stream)

Source

fact-base.lisp (file)

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 (file)

Generic Function: reverse-entry STATE ENTRY

Package

fact-base

Methods

Method: reverse-entry (STATE list) (ENTRY list)

Source

fact-base.lisp (file)

Generic Function: reverse-entry! STATE ENTRY

Package

fact-base

Methods

Method: reverse-entry! (STATE fact-base) (ENTRY list)

Source

fact-base.lisp (file)

Generic Function: rewind-by-internal STATE COUNT

Package

fact-base

Methods

Method: rewind-by-internal (STATE fact-base) (COUNT integer)

Source

fact-base.lisp (file)

Generic Function: show THING &optional DEPTH

Package

fact-base

Methods

Method: show (IX index) &optional DEPTH

Source

index.lisp (file)

Method: show (TBL hash-table) &optional DEPTH

Source

index.lisp (file)

Method: show THING &optional DEPTH

Source

index.lisp (file)

Generic Function: table OBJECT

Package

fact-base

Methods

Method: table (INDEX index)

automatically generated reader method

Source

fact-base.lisp (file)

Generic Function: tags OBJECT

Generic Function: (setf tags) NEW-VALUE OBJECT

Package

fact-base

Methods

Method: tags (FACT-BASE fact-base)

Method: (setf tags) NEW-VALUE (FACT-BASE fact-base)

The collection of history tags in effect on this fact base

Source

fact-base.lisp (file)

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 (file)

Method: write-entries! (ENTRIES list) (FILE pathname) IF-EXISTS

Source

fact-base.lisp (file)

Generic Function: write-entry! ENTRY S

Package

fact-base

Methods

Method: write-entry! (ENTRY list) (S stream)

Source

fact-base.lisp (file)

5.2.5 Classes

Class: index ()

Package

fact-base

Source

fact-base.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• show (method)
• delete! (method)
• insert! (method)
• map-insert! (method)
• indexed? (method)
• table (method)

Direct slots

Slot: table

Initform

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

Readers

table (generic function)

Class: queue ()

Package

fact-base

Source

queue.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• empty? (method)
• pop! (method)
• push! (method)
• last-cons (method)
• last-cons (method)
• entry-count (method)
• entry-count (method)
• entries (method)
• entries (method)

Direct slots

Slot: entries

Initargs

:entries

Readers

entries (generic function)

Writers

(setf entries) (generic function)

Slot: entry-count

Initargs

:entry-count

Initform

0

Readers

entry-count (generic function)

Writers

(setf entry-count) (generic function)

Slot: last-cons

Initargs

:last-cons

Readers

last-cons (generic function)

Writers

(setf last-cons) (generic function)

Appendix A Indexes

A.1 Concepts

A.2 Functions