API reference

Exported functions and macros

multiple environments

(defmacro defenv (name &key redefine))
(defun defenvf (name &key redefine))
(defmacro undefenv (name))
(defun undefenvf (name))
(defmacro setenv (name))
(defun setenvf (name))
(defun environments ())                                 ;; => list of names
(defun current-environment ())                          ;; => environment name

templates

(defmacro deftemplate (name &body slots))
(defun deftemplatef (name slots))
(defmacro undeftemplate (name))
(defun undeftemplatef (name))
(defmacro ppdeftemplate (name))
(defun templates ())                                    ;; => list of names
(defun find-template (name))                            ;; => external template representation

facts

(defun facts (&optional start-index end-index at-most)) ;; => list of fact specifiers
(defmacro assert (&rest fact-specs))
(defun assertf (&rest fact-specs))
(defmacro retract (&rest fact-specs))
(defun retractf (&rest fact-specs))
(defun retract-all ())
(defmacro modify (fact-spec &rest mod-list))
(defun modifyf (fact-spec mod-list))

fact groups

(defmacro deffacts (name &body descriptions))
(defun deffactsf (name fact-specs))
(defmacro undeffacts (name))
(defun undeffactsf (name))
(defun fact-groups ())                                  ;; => list of names
(defun find-fact-group (name))                          ;; => external fact group representation
TODO: (defmacro ppdeffacts (name))

rules

(defmacro defrule (name &body rule))
(defun defrulef (name body))
(defmacro undefrule (name))
(defun undefrulef (name))
(defun rules ())                                        ;; => list of names
(defun find-rule (name))                                ;; => external rule representation
(defmacro ppdefrule (name))
(defun ppdefrulef (name))
(defun agenda ())                                       ;; => list of matches

strategies

(defmacro defstrategy (name function))
(defun defstrategyf (name function))
(defmacro undefstrategy (name))
(defun undefstrategyf (name))
(defmacro setstrategy (name))
(defun setstrategyf (name))
(defun current-strategy ())                            ;; => name
(defun strategies ())                                  ;; => list of names
(defun find-strategy (name))                           ;; => strategy function

watchers

(defmacro watch (watcher))                             ;; watcher can be facts, rules, activations, all
(defun watchf (watcher))
(defmacro unwatch (watcher))
(defun unwatchf (watcher))
(defmacro watchedp (watcher))
(defun watchedpf (watcher))

forward chaning inference execution

(defun reset ())
(defun step ())
(defun halt ())
(defun run ())

backward chaining inference execution

(defmacro defgoal (goal-spec))
(defun defgoalf (goal-spec))
TODO: (defmacro undefgoal (goal-spec))
TODO: (defun undefgoalf (goal-spec))
(defun goals ())                                       ;; => list of goal specifiers
(defun back-step ())
(defun back-run ())

environment cleanup

(defun clear ())
(defun complete-reset ())

undo/redo

(defun undo ())
(defun redo ())
(defun undo-stack ())
(defun redo-stack ())

GUI

(defun show-gui (&optional environment))