The fact-base Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The fact-base Reference Manual

This is the fact-base Reference Manual, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 11:45:25 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

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

See also

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


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

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


Previous: , Up: Systems   [Contents][Index]

2.1 fact-base

Author

Inaimathi <leo.zovic@gmail.com>

License

AGPL3

Description

Simple implementation of fact-base data storage for Common Lisp

Dependencies
Source

fact-base.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

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


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 fact-base.asd

Location

fact-base.asd

Systems

fact-base (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 fact-base/package.lisp

Parent

fact-base (system)

Location

package.lisp

Packages

fact-base


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.3 fact-base/util.lisp

Dependency

package.lisp (file)

Parent

fact-base (system)

Location

util.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.4 fact-base/queue.lisp

Dependency

util.lisp (file)

Parent

fact-base (system)

Location

queue.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.5 fact-base/fact-base.lisp

Dependency

queue.lisp (file)

Parent

fact-base (system)

Location

fact-base.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.6 fact-base/index.lisp

Dependency

fact-base.lisp (file)

Parent

fact-base (system)

Location

index.lisp

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

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

Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

4.1 fact-base

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

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


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Macros

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

fact-base

Source

unify.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Functions

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

fact-base

Source

fact-base.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Classes

Class: fact-base ()
Package

fact-base

Source

fact-base.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
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)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Special variables

Special Variable: +fail+
Package

fact-base

Source

unify.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

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)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

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)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

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)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.5 Classes

Class: index ()
Package

fact-base

Source

fact-base.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
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
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)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L  
Index Entry  Section

F
fact-base.asd: The fact-base<dot>asd file
fact-base/fact-base.lisp: The fact-base/fact-base<dot>lisp file
fact-base/index.lisp: The fact-base/index<dot>lisp file
fact-base/package.lisp: The fact-base/package<dot>lisp file
fact-base/queue.lisp: The fact-base/queue<dot>lisp file
fact-base/unify.lisp: The fact-base/unify<dot>lisp file
fact-base/util.lisp: The fact-base/util<dot>lisp file
File, Lisp, fact-base.asd: The fact-base<dot>asd file
File, Lisp, fact-base/fact-base.lisp: The fact-base/fact-base<dot>lisp file
File, Lisp, fact-base/index.lisp: The fact-base/index<dot>lisp file
File, Lisp, fact-base/package.lisp: The fact-base/package<dot>lisp file
File, Lisp, fact-base/queue.lisp: The fact-base/queue<dot>lisp file
File, Lisp, fact-base/unify.lisp: The fact-base/unify<dot>lisp file
File, Lisp, fact-base/util.lisp: The fact-base/util<dot>lisp file

L
Lisp File, fact-base.asd: The fact-base<dot>asd file
Lisp File, fact-base/fact-base.lisp: The fact-base/fact-base<dot>lisp file
Lisp File, fact-base/index.lisp: The fact-base/index<dot>lisp file
Lisp File, fact-base/package.lisp: The fact-base/package<dot>lisp file
Lisp File, fact-base/queue.lisp: The fact-base/queue<dot>lisp file
Lisp File, fact-base/unify.lisp: The fact-base/unify<dot>lisp file
Lisp File, fact-base/util.lisp: The fact-base/util<dot>lisp file

Jump to:   F   L  

Next: , Previous: , Up: Indexes   [Contents][Index]

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): Exported generic functions
(setf current): Exported generic functions
(setf delta): Exported generic functions
(setf delta): Exported generic functions
(setf earliest-entry): Internal generic functions
(setf earliest-entry): Internal generic functions
(setf entries): Internal generic functions
(setf entries): Internal generic functions
(setf entry-count): Internal generic functions
(setf entry-count): Internal generic functions
(setf entry-count): Internal generic functions
(setf fact-id): Internal generic functions
(setf fact-id): Internal generic functions
(setf index): Internal generic functions
(setf index): Internal generic functions
(setf last-cons): Internal generic functions
(setf last-cons): Internal generic functions
(setf latest-entry): Internal generic functions
(setf latest-entry): Internal generic functions
(setf tags): Internal generic functions
(setf tags): Internal generic functions

-
->key: Internal generic functions
->key: Internal generic functions
->key: Internal generic functions

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

B
base!: Exported generic functions
base!: Exported generic functions
binding-value: Internal functions

C
change!: Exported generic functions
change!: Exported generic functions
change-fact-internal!: Internal functions
current: Exported generic functions
current: Exported generic functions

D
decide-index: Internal generic functions
decide-index: Internal generic functions
delete: Internal generic functions
delete: Internal generic functions
delete!: Exported generic functions
delete!: Exported generic functions
delete!: Exported generic functions
delete-fact-internal!: Internal functions
delta: Exported generic functions
delta: Exported generic functions

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

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

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

H
hash: Internal functions
history: Internal generic functions
history: Internal generic functions

I
in-memory?: Internal generic functions
in-memory?: Internal generic functions
index: Internal generic functions
index: Internal generic functions
index!: Exported generic functions
index!: Exported generic functions
index-case: Internal macros
indexed?: Internal generic functions
indexed?: Internal generic functions
insert: Internal generic functions
insert: Internal generic functions
insert!: Exported generic functions
insert!: Exported generic functions
insert!: Exported generic functions
insert-fact-internal!: Internal functions
insert-if-unique!: Exported generic functions
insert-if-unique!: Exported generic functions
insert-new!: Exported generic functions
insert-new!: Exported generic functions

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

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

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

N
next-id!: Exported generic functions
next-id!: Exported generic functions
not-goals: Internal functions

O
occurs-check: Internal functions
or-goals: Internal functions

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

Q
queue: Internal functions

R
read-entry!: Internal generic functions
read-entry!: Internal generic functions
read-entry-from-end!: Internal generic functions
read-entry-from-end!: Internal generic functions
reverse-entry: Internal generic functions
reverse-entry: Internal generic functions
reverse-entry!: Internal generic functions
reverse-entry!: Internal generic functions
reverse-from-end-until: Internal functions
rewind-by: Exported generic functions
rewind-by: Exported generic functions
rewind-by-internal: Internal generic functions
rewind-by-internal: Internal generic functions
rewind-to: Exported generic functions
rewind-to: Exported generic functions
rewind-to: Exported generic functions
rewind-to: Exported generic functions

S
show: Internal generic functions
show: Internal generic functions
show: Internal generic functions
show: Internal generic functions
single-goal: Internal functions
subst-bindings: Internal functions

T
table: Internal generic functions
table: Internal generic functions
tag!: Exported generic functions
tag!: Exported generic functions
tags: Internal generic functions
tags: Internal generic functions
tags-of: Exported generic functions
tags-of: Exported generic functions
temp-file-name: Internal functions
timestamp->list: Internal functions
total-entries: Exported generic functions
total-entries: Exported generic functions

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

V
variable?: Internal functions
variables-in: Internal functions

W
with-open-elif: Internal macros
write!: Exported generic functions
write!: Exported generic functions
write-entries!: Internal generic functions
write-entries!: Internal generic functions
write-entries!: Internal generic functions
write-entry!: Internal generic functions
write-entry!: Internal generic 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  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   +  
C   D   E   F   H   I   L   S   T  
Index Entry  Section

+
+fail+: Internal special variables

C
current: Exported classes

D
delta: Exported classes

E
earliest-entry: Exported classes
entries: Internal classes
entry-count: Exported classes
entry-count: Internal classes

F
fact-id: Exported classes
file-name: Exported classes

H
history: Exported classes

I
in-memory?: Exported classes
index: Exported classes

L
last-cons: Internal classes
latest-entry: Exported classes

S
Slot, current: Exported classes
Slot, delta: Exported classes
Slot, earliest-entry: Exported classes
Slot, entries: Internal classes
Slot, entry-count: Exported classes
Slot, entry-count: Internal classes
Slot, fact-id: Exported classes
Slot, file-name: Exported classes
Slot, history: Exported classes
Slot, in-memory?: Exported classes
Slot, index: Exported classes
Slot, last-cons: Internal classes
Slot, latest-entry: Exported classes
Slot, table: Internal classes
Slot, tags: Exported classes
Special Variable, +fail+: Internal special variables

T
table: Internal classes
tags: Exported classes

Jump to:   +  
C   D   E   F   H   I   L   S   T  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   C   F   I   P   Q   S  
Index Entry  Section

C
Class, fact-base: Exported classes
Class, index: Internal classes
Class, queue: Internal classes

F
fact-base: The fact-base system
fact-base: The fact-base package
fact-base: Exported classes

I
index: Internal classes

P
Package, fact-base: The fact-base package

Q
queue: Internal classes

S
System, fact-base: The fact-base system

Jump to:   C   F   I   P   Q   S