The cram-language Reference Manual

[ ? ]

1. Systems

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

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

1.1 `cram-language`

Maintainer

Lorenz Moesenlechner <moesenle@cs.tum.edu>

Author

Lorenz Moesenlechner <moesenle@cs.tum.edu>

License

BSD

Description

Coginitive plan language

Long Description

cram-language is a new plan language.

Dependencies

trivial-garbage
alexandria
cram-utilities
sb-cltl2

Definition file

cram-language.asd (Lisp file)

Component

src (module)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

2. Modules

Modules are listed depth-first from the system components tree.

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

2.1 `src/`

Parent

cram-language (system)

Location

src/

Components

packages (Lisp file)
utils (Lisp file)
task-interface (Lisp file)
fluent-interface (Lisp file)
logging (Lisp file)
with-policy (Lisp file)
default-policies (Lisp file)
tasks (module)
fluents (module)
walker (module)
language (Lisp file)
plans (Lisp file)
goals (Lisp file)
fluent-operators (Lisp file)
swank-indentation (Lisp file)
sbcl-hotpatches (Lisp file)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

2.2 `src/tasks/`

Dependencies

packages (Lisp file)
task-interface (Lisp file)
fluent-interface (Lisp file)
utils (Lisp file)
logging (Lisp file)

Parent

src (module)

Location

src/tasks/

Components

failures (Lisp file)
task (Lisp file)
task-tree (Lisp file)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

2.3 `src/fluents/`

Dependencies

packages (Lisp file)
fluent-interface (Lisp file)
task-interface (Lisp file)
logging (Lisp file)

Parent

src (module)

Location

src/fluents/

Components

fluent (Lisp file)
value-fluent (Lisp file)
fluent-net (Lisp file)
pulse-fluent (Lisp file)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

2.4 `src/walker/`

Dependency

packages (Lisp file)

Parent

src (module)

Location

src/walker/

Components

env (Lisp file)
env-impl-specific (Lisp file)
plan-tree (Lisp file)
walker (Lisp file)
interface (Lisp file)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3. Files

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

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1 Lisp

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.1 `cram-language.asd`

Location: cram-language.asd

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.2 `src/packages.lisp`

Parent

src (module)

Location

src/packages.lisp

Packages

cram-user
cram-language
cram-language-implementation
cram-walker

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.3 `src/utils.lisp`

Dependency

packages (Lisp file)

Parent

src (module)

Location

src/utils.lisp

Exported Definitions

mapcar-clean (macro)
sleep* (function)

Internal Definitions

float-/ (function)
format-gensym (function)
get-alist (function)
(setf get-alist) (function)
list-of (type)
partition (function)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.4 `src/task-interface.lisp`

Dependencies

packages (Lisp file)
utils (Lisp file)

Parent

src (module)

Location

src/task-interface.lisp

Exported Definitions

*current-path* (special variable)
*current-task* (special variable)
*task-pprint-verbosity* (special variable)
+alive+ (special variable)
+dead+ (special variable)
+done+ (special variable)
current-task (function)
define-task-variable (macro)
evaporate (generic function)
join-task (generic function)
on-suspension (macro)
result (generic function)
retry-after-suspension (macro)
status (generic function)
status-indicator (type)
suspend (generic function)
task-path (generic function)
wake-up (generic function)
with-scheduling (macro)
without-scheduling (macro)

Internal Definitions

*task-local-variables* (special variable)
child-tasks (generic function)
execute (generic function)
executed (generic function)
inherit-parent-value (function)
parent-task (generic function)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.5 `src/fluent-interface.lisp`

Dependency

packages (Lisp file)

Parent

src (module)

Location

src/fluent-interface.lisp

Exported Definitions

fluent (class)
get-update-callback (generic function)
name (method)
pulse (generic function)
register-update-callback (generic function)
remove-update-callback (generic function)
value (generic function)
wait-for (generic function)

Internal Definitions

fl-cacheable-value-mixin (class)
fl-printable-mixin (class)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.6 `src/logging.lisp`

Dependencies

packages (Lisp file)
task-interface (Lisp file)

Parent

src (module)

Location

src/logging.lisp

Exported Definitions

*log-output* (special variable)
*log-right-margin* (special variable)
+log-all+ (special variable)
+log-default+ (special variable)
+log-language+ (special variable)
+log-verbose+ (special variable)
+log-very-verbose+ (special variable)
list-active-log-tags (function)
list-available-log-tags (function)
log-disable (function)
log-enable (function)
log-event (macro)
log-set (function)
logging-enabled-p (macro)

Internal Definitions

%define-log-tags (function)
%log-event (function)
*active-log-mask* (special variable)
*log-tag-table* (special variable)
*zero-real-time* (special variable)
*zero-run-time* (special variable)
+available-log-tags+ (special variable)
define-log-tags (macro)
log-block (macro)
log-mask (function)
log-tag-offset (function)
logfmt (function)
task-abbreviated-name (function)
truncate-string (function)
what-time-is-it (function)
who-am-i (function)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.7 `src/with-policy.lisp`

Dependency

packages (Lisp file)

Parent

src (module)

Location

src/with-policy.lisp

Exported Definitions

define-policy (macro)
make-policy (macro)
name (method)
named-policy (function)
parameters (method)
policy-check-condition-met (condition)
policy-condition (condition)
policy-failure (condition)
policy-init-failed (condition)
policy-not-found (condition)
with-named-policies (macro)
with-named-policy (macro)
with-policies (macro)
with-policy (macro)

Internal Definitions

*policies* (special variable)
*policy-check-consolidation-duration* (special variable)
check (method)
clean-up (method)
description (method)
init (method)
on-with-policy-begin (generic function)
on-with-policy-end (generic function)
policy (class)
recover (method)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.8 `src/default-policies.lisp`

Dependencies

packages (Lisp file)
with-policy (Lisp file)

Parent

src (module)

Location

src/default-policies.lisp

Exported Definitions

timeout-policy (special variable)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.9 `src/tasks/failures.lisp`

Parent

tasks (module)

Location

src/tasks/failures.lisp

Exported Definitions

*break-on-plan-failures* (special variable)
*debug-on-lisp-errors* (special variable)
common-lisp-error-envelope (condition)
composite-failure (condition)
fail (function)
on-fail (generic function)
plan-failure (condition)
simple-plan-failure (condition)
with-failure-handling (macro)
with-retry-counters (macro)

Internal Definitions

%fail (function)
coerce-to-condition (function)
on-with-failure-handling-begin (generic function)
on-with-failure-handling-end (generic function)
on-with-failure-handling-handled (generic function)
on-with-failure-handling-rethrown (generic function)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.10 `src/tasks/task.lisp`

Dependency

failures (Lisp file)

Parent

tasks (module)

Location

src/tasks/task.lisp

Exported Definitions

*save-tasks* (special variable)
*task-tree* (special variable)
*tasks* (special variable)
evaporate (method)
join-task (method)
list-saved-tasks (function)
name (method)
result (method)
status (method)
suspend (method)
task (class)
task-alive (function)
task-dead (function)
task-dead-p (function)
task-done-p (function)
task-failed-p (function)
task-path (method)
task-running-p (function)
toplevel-task (class)
tv-closure (function)
wake-up (method)

Internal Definitions

%make-event (function)
%teardown (function)
%unwind-on-suspension (function)
*current-task-tree-node* (special variable)
*scheduling-enabled* (special variable)
*status-transitions* (special variable)
*suspension-handlers* (special variable)
*suspension-unwind* (special variable)
*synchronous-events* (special variable)
+time-quantum+ (special variable)
abstract-task (class)
adjust-time-quantum (function)
assert-status (function)
call-on-suspension (function)
call-with-event-loop (function)
call-with-scheduling (function)
call-without-scheduling (function)
change-status (function)
check-time-quantum (function)
child-tasks (method)
(setf child-tasks) (method)
clear-saved-tasks (function)
continuation (type)
continue-with-adjusted-time-quantum (function)
copy-event (function)
copy-message (function)
destructure-event (macro)
event (structure)
event-designator (type)
event-loop (function)
event-p (function)
event-reason (function)
(setf event-reason) (function)
event-sync (function)
(setf event-sync) (function)
event-tag (function)
(setf event-tag) (function)
event-values (function)
(setf event-values) (function)
execute (method)
execute (method)
execute (method)
execute (method)
execute (method)
executed (method)
invoke-event-loop (function)
kill-saved-tasks (function)
log-gc-event (function)
make-dummy-task (function)
make-event (function)
make-message (function)
message (structure)
message-content (function)
(setf message-content) (function)
message-from (function)
(setf message-from) (function)
message-p (function)
message-to (function)
(setf message-to) (function)
parent-task (method)
propagate-event (function)
receive-event (function)
scheduling-disabled-p (function)
scheduling-enabled-p (function)
seconds-to-internal-time (function)
send-event (function)
setup (function)
signal-time-quantum-exhausted (function)
synchronize-on-event (function)
task-code (method)
task-constraints (method)
(setf task-constraints) (method)
task-message-queue (method)
task-name (method)
time-quantum-exhausted (condition)
unwind-and-continue (function)
unwind-and-teardown (function)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.11 `src/tasks/task-tree.lisp`

Dependency

task (Lisp file)

Parent

tasks (module)

Location

src/tasks/task-tree.lisp

Exported Definitions

clear-tasks (function)
code (structure)
code-function (function)
(setf code-function) (function)
code-parameters (function)
(setf code-parameters) (function)
code-sexp (function)
(setf code-sexp) (function)
code-task (function)
(setf code-task) (function)
filter-task-tree (function)
flatten-task-tree (function)
goal-task-tree-node-goal (function)
goal-task-tree-node-p (function)
goal-task-tree-node-parameter-bindings (function)
goal-task-tree-node-pattern (function)
make-task (function)
make-task-tree-node (function)
replaceable-function (macro)
stale-task-tree-node-p (function)
sub-task (function)
task (function)
task-tree-node (function)
task-tree-node (structure)
task-tree-node-children (function)
(setf task-tree-node-children) (function)
task-tree-node-code (function)
(setf task-tree-node-code) (function)
task-tree-node-effective-code (function)
task-tree-node-p (function)
task-tree-node-parameters (function)
task-tree-node-parent (function)
(setf task-tree-node-parent) (function)
task-tree-node-path (function)
(setf task-tree-node-path) (function)
task-tree-node-result (function)
task-tree-node-status-fluent (function)
with-task-tree-node (macro)

Internal Definitions

*task-tree-print-children* (special variable)
*task-tree-print-code* (special variable)
*task-tree-print-identity* (special variable)
*task-tree-print-path* (special variable)
code-p (function)
copy-code (function)
copy-task-tree-node (function)
ensure-tree-node (function)
execute-task-tree-node (function)
make-code (function)
on-finishing-task-execution (generic function)
on-preparing-task-execution (generic function)
path-next-iteration (function)
register-task-code (function)
replace-task-code (function)
task-tree-node-code-replacements (function)
(setf task-tree-node-code-replacements) (function)
task-tree-node-lock (function)
(setf task-tree-node-lock) (function)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.12 `src/fluents/fluent.lisp`

Parent

fluents (module)

Location

src/fluents/fluent.lisp

Exported Definitions

get-update-callback (method)
peek-value (function)
pulse (method)
register-update-callback (method)
remove-update-callback (method)
value (method)
wait-for (method)
wait-for (method)
whenever (macro)

Internal Definitions

%timed-wait-for (function)
*peek-value* (special variable)
recalculate-timeout (function)
with-fluent-locked (macro)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.13 `src/fluents/value-fluent.lisp`

Dependency

fluent (Lisp file)

Parent

fluents (module)

Location

src/fluents/value-fluent.lisp

Exported Definitions

def-cpl-parameter (macro)
make-fluent (function)
on-make-fluent-hook (generic function)
value (method)
(setf value) (method)
(setf value) (generic function)
value-fluent (class)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.14 `src/fluents/fluent-net.lisp`

Dependency

fluent (Lisp file)

Parent

fluents (module)

Location

src/fluents/fluent-net.lisp

Exported Definitions

fl* (function)
fl+ (function)
fl- (function)
fl-and (function)
fl-apply (function)
fl-eq (function)
fl-eql (function)
fl-funcall (function)
fl-not (function)
fl-or (function)
fl-value-changed (function)
fl/ (function)
fl< (function)
fl= (function)
fl> (function)
pulse (method)
value (method)
value (method)

Internal Definitions

call-as-fluent-operator (function)
def-fluent-operator (macro)
define-fluent-net-wrapper (macro)
fl-member (function)
fl-net-cacheable-fluent (class)
fl-net-fluent (class)
update-value (generic function)
update-value (method)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.15 `src/fluents/pulse-fluent.lisp`

Dependency

fluent (Lisp file)

Parent

fluents (module)

Location

src/fluents/pulse-fluent.lisp

Exported Definitions

fl-pulsed (function)
value (method)

Internal Definitions

pulse-fluent (class)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.16 `src/walker/env.lisp`

Parent

walker (module)

Location

src/walker/env.lisp

Internal Definitions

*cltl2-environment-fns* (special variable)
aug-env (function)
augment-environment (function)
enclose (function)
lambda-list-keyword-p (function)
parse-macro (function)
parse-macro-function (function)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.17 `src/walker/env-impl-specific.lisp`

Dependency: env (Lisp file)
Parent: walker (module)
Location: src/walker/env-impl-specific.lisp

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.18 `src/walker/plan-tree.lisp`

Dependency

env-impl-specific (Lisp file)

Parent

walker (module)

Location

src/walker/plan-tree.lisp

Exported Definitions

find-plan-node (function)
plan-tree-node (structure)
plan-tree-node-children (function)
(setf plan-tree-node-children) (function)
plan-tree-node-parent (function)
(setf plan-tree-node-parent) (function)
plan-tree-node-path (function)
(setf plan-tree-node-path) (function)
plan-tree-node-sexp (function)
(setf plan-tree-node-sexp) (function)

Internal Definitions

copy-plan-tree-node (function)
make-plan-tree-node (function)
plan-tree-node-p (function)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.19 `src/walker/walker.lisp`

Dependency

plan-tree (Lisp file)

Parent

walker (module)

Location

src/walker/walker.lisp

Internal Definitions

*current-parent* (special variable)
*current-path* (special variable)
*shadowed-functions* (special variable)
*tag-walker-handlers* (special variable)
extend-path (function)
register-child-plan (function)
tag-form-handler (function)
walk-argument (function)
walk-binding (function)
walk-binding-list (function)
walk-block (function)
walk-cpl-tag (function)
walk-flet (function)
walk-form (function)
walk-funcall (function)
walk-function (function)
walk-labels (function)
walk-lambda (function)
walk-let (function)
walk-let* (function)
walk-list (function)
walk-list-of-lambdas (function)
walk-load-time-value (function)
walk-macrolet (function)
walk-named-lambda (function)
walk-ordinary-lambda-list (function)
walk-plan-form (function)
walk-quote (function)
with-extended-path (macro)
with-shadowed-functions (macro)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.20 `src/walker/interface.lisp`

Dependency

walker (Lisp file)

Parent

walker (module)

Location

src/walker/interface.lisp

Exported Definitions

expand-plan (function)
walk-with-tag-handler (function)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.21 `src/language.lisp`

Dependencies

packages (Lisp file)
walker (module)
tasks (module)
fluents (module)
logging (Lisp file)
with-policy (Lisp file)
default-policies (Lisp file)

Parent

src (module)

Location

src/language.lisp

Exported Definitions

get-top-level-task-tree (function)
on-top-level-cleanup-hook (generic function)
on-top-level-setup-hook (generic function)
par (macro)
par-loop (macro)
partial-order (macro)
pursue (macro)
seq (macro)
top-level (macro)
try-all (macro)
try-each-in-order (macro)
try-in-order (macro)
with-tags (macro)
with-task-suspended (macro)

Internal Definitions

*top-level-task-trees* (special variable)
def-plan-macro (macro)
named-top-level (macro)
on-begin-execute-tag-task (generic function)
on-finish-execute-tag-task (generic function)
on-finishing-named-top-level (generic function)
on-preparing-named-top-level (generic function)
remove-top-level-task-tree (function)
single-form-progv (macro)
with-parallel-childs (macro)
with-task (macro)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.22 `src/plans.lisp`

Dependencies

packages (Lisp file)
tasks (module)

Parent

src (module)

Location

src/plans.lisp

Exported Definitions

def-cram-function (macro)
def-plan (macro)
def-top-level-cram-function (macro)
def-top-level-plan (macro)
on-def-top-level-plan-hook (generic function)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.23 `src/goals.lisp`

Dependencies

packages (Lisp file)
tasks (module)

Parent

src (module)

Location

src/goals.lisp

Exported Definitions

declare-goal (macro)
def-goal (macro)
describe-goal (function)
register-goal (function)

Internal Definitions

call-goal (function)
make-goal-fun (function)
matching-goal-fun (function)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.24 `src/fluent-operators.lisp`

Dependencies

packages (Lisp file)
fluents (module)

Parent

src (module)

Location

src/fluent-operators.lisp

Exported Definitions

* (function)
+ (function)
- (function)
/ (function)
< (function)
= (function)
> (function)
eq (function)
eql (function)
not (function)
pulsed (function)
sleep (function)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.25 `src/swank-indentation.lisp`

Dependency: packages (Lisp file)
Parent: src (module)
Location: src/swank-indentation.lisp

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

3.1.26 `src/sbcl-hotpatches.lisp`

Parent: src (module)
Location: src/sbcl-hotpatches.lisp

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

4. Packages

Packages are listed by definition order.

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

4.1 `cram-user`

Source: packages (Lisp file)
Nickname: cpl-user
Use List: cram-language

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

4.2 `cram-language`

Main package of a new planning language similar to RPL.

Source

packages (Lisp file)

Nickname

cpl

Use List

common-lisp
cram-language-implementation

Used By List

cram-user

Exported Definitions

* (function)
+ (function)
- (function)
/ (function)
< (function)
= (function)
> (function)
eq (function)
eql (function)
not (function)
pulsed (function)
sleep (function)

Internal Definitions

*policies* (special variable)
*policy-check-consolidation-duration* (special variable)
check (generic function)
check (method)
clean-up (generic function)
clean-up (method)
description (generic function)
description (method)
init (generic function)
init (method)
on-begin-execute-tag-task (generic function)
on-finish-execute-tag-task (generic function)
on-finishing-named-top-level (generic function)
on-finishing-task-execution (generic function)
on-preparing-named-top-level (generic function)
on-preparing-task-execution (generic function)
on-with-failure-handling-begin (generic function)
on-with-failure-handling-end (generic function)
on-with-failure-handling-handled (generic function)
on-with-failure-handling-rethrown (generic function)
on-with-policy-begin (generic function)
on-with-policy-end (generic function)
policy (class)
policy-name (generic function)
policy-name (method)
policy-parameters (generic function)
policy-parameters (method)
recover (generic function)
recover (method)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

4.3 `cram-language-implementation`

Internal implementation package of CPL.

Source

packages (Lisp file)

Nickname

cpl-impl

Use List

common-lisp
cram-walker
cram-utilities
trivial-garbage
alexandria.0.dev

Used By List

Exported Definitions

*break-on-plan-failures* (special variable)
*current-path* (special variable)
*current-task* (special variable)
*debug-on-lisp-errors* (special variable)
*log-output* (special variable)
*log-right-margin* (special variable)
*save-tasks* (special variable)
*task-pprint-verbosity* (special variable)
*task-tree* (special variable)
*tasks* (special variable)
+alive+ (special variable)
+dead+ (special variable)
+done+ (special variable)
+log-all+ (special variable)
+log-default+ (special variable)
+log-language+ (special variable)
+log-verbose+ (special variable)
+log-very-verbose+ (special variable)
clear-tasks (function)
code (structure)
code-function (function)
(setf code-function) (function)
code-parameters (function)
(setf code-parameters) (function)
code-sexp (function)
(setf code-sexp) (function)
code-task (function)
(setf code-task) (function)
common-lisp-error-envelope (condition)
composite-failure (condition)
composite-failures (generic function)
composite-failures (method)
current-task (function)
declare-goal (macro)
def-cpl-parameter (macro)
def-cram-function (macro)
def-goal (macro)
def-plan (macro)
def-top-level-cram-function (macro)
def-top-level-plan (macro)
define-policy (macro)
define-task-variable (macro)
describe-goal (function)
envelop-error (generic function)
envelop-error (method)
evaporate (generic function)
evaporate (method)
fail (function)
filter-task-tree (function)
fl* (function)
fl+ (function)
fl- (function)
fl-and (function)
fl-apply (function)
fl-eq (function)
fl-eql (function)
fl-funcall (function)
fl-not (function)
fl-or (function)
fl-pulsed (function)
fl-value-changed (function)
fl/ (function)
fl< (function)
fl= (function)
fl> (function)
flatten-task-tree (function)
fluent (class)
get-top-level-task-tree (function)
get-update-callback (generic function)
get-update-callback (method)
goal-task-tree-node-goal (function)
goal-task-tree-node-p (function)
goal-task-tree-node-parameter-bindings (function)
goal-task-tree-node-pattern (function)
join-task (generic function)
join-task (method)
list-active-log-tags (function)
list-available-log-tags (function)
list-saved-tasks (function)
log-disable (function)
log-enable (function)
log-event (macro)
log-set (function)
logging-enabled-p (macro)
make-fluent (function)
make-policy (macro)
make-task (function)
make-task-tree-node (function)
mapcar-clean (macro)
name (generic function)
name (method)
name (method)
name (method)
named-policy (function)
on-def-top-level-plan-hook (generic function)
on-fail (generic function)
on-make-fluent-hook (generic function)
on-suspension (macro)
on-top-level-cleanup-hook (generic function)
on-top-level-setup-hook (generic function)
par (macro)
par-loop (macro)
parameters (generic function)
parameters (method)
partial-order (macro)
peek-value (function)
plan-failure (condition)
policy-check-condition-met (condition)
policy-condition (condition)
policy-failure (condition)
policy-init-failed (condition)
policy-not-found (condition)
pulse (generic function)
pulse (method)
pulse (method)
pursue (macro)
register-goal (function)
register-update-callback (generic function)
register-update-callback (method)
remove-update-callback (generic function)
remove-update-callback (method)
replaceable-function (macro)
result (generic function)
result (method)
retry-after-suspension (macro)
seq (macro)
simple-plan-failure (condition)
sleep* (function)
stale-task-tree-node-p (function)
status (generic function)
status (method)
status-indicator (type)
sub-task (function)
suspend (generic function)
suspend (method)
task (function)
task (class)
task-alive (function)
task-dead (function)
task-dead-p (function)
task-done-p (function)
task-failed-p (function)
task-path (generic function)
task-path (method)
task-running-p (function)
task-tree-node (function)
task-tree-node (structure)
task-tree-node-children (function)
(setf task-tree-node-children) (function)
task-tree-node-code (function)
(setf task-tree-node-code) (function)
task-tree-node-effective-code (function)
task-tree-node-p (function)
task-tree-node-parameters (function)
task-tree-node-parent (function)
(setf task-tree-node-parent) (function)
task-tree-node-path (function)
(setf task-tree-node-path) (function)
task-tree-node-result (function)
task-tree-node-status-fluent (function)
timeout-policy (special variable)
top-level (macro)
toplevel-task (class)
try-all (macro)
try-each-in-order (macro)
try-in-order (macro)
tv-closure (function)
value (generic function)
value (method)
value (method)
value (method)
value (method)
(setf value) (method)
value (method)
(setf value) (generic function)
value-fluent (class)
wait-for (generic function)
wait-for (method)
wait-for (method)
wake-up (generic function)
wake-up (method)
whenever (macro)
with-failure-handling (macro)
with-named-policies (macro)
with-named-policy (macro)
with-policies (macro)
with-policy (macro)
with-retry-counters (macro)
with-scheduling (macro)
with-tags (macro)
with-task-suspended (macro)
with-task-tree-node (macro)
without-scheduling (macro)

Internal Definitions

%define-log-tags (function)
%fail (function)
%log-event (function)
%make-event (function)
%teardown (function)
%timed-wait-for (function)
%unwind-on-suspension (function)
*active-log-mask* (special variable)
*current-task-tree-node* (special variable)
*log-tag-table* (special variable)
*peek-value* (special variable)
*scheduling-enabled* (special variable)
*status-transitions* (special variable)
*suspension-handlers* (special variable)
*suspension-unwind* (special variable)
*synchronous-events* (special variable)
*task-local-variables* (special variable)
*task-tree-print-children* (special variable)
*task-tree-print-code* (special variable)
*task-tree-print-identity* (special variable)
*task-tree-print-path* (special variable)
*top-level-task-trees* (special variable)
*zero-real-time* (special variable)
*zero-run-time* (special variable)
+available-log-tags+ (special variable)
+time-quantum+ (special variable)
abstract-task (class)
adjust-time-quantum (function)
assert-status (function)
call-as-fluent-operator (function)
call-goal (function)
call-on-suspension (function)
call-with-event-loop (function)
call-with-scheduling (function)
call-without-scheduling (function)
change-status (function)
check-time-quantum (function)
child-tasks (generic function)
child-tasks (method)
(setf child-tasks) (method)
(setf child-tasks) (generic function)
clear-saved-tasks (function)
code-p (function)
coerce-to-condition (function)
continuation (type)
continue-with-adjusted-time-quantum (function)
copy-code (function)
copy-event (function)
copy-message (function)
copy-task-tree-node (function)
def-fluent-operator (macro)
def-plan-macro (macro)
define-fluent-net-wrapper (macro)
define-log-tags (macro)
destructure-event (macro)
ensure-tree-node (function)
event (structure)
event-designator (type)
event-loop (function)
event-p (function)
event-reason (function)
(setf event-reason) (function)
event-sync (function)
(setf event-sync) (function)
event-tag (function)
(setf event-tag) (function)
event-values (function)
(setf event-values) (function)
execute (generic function)
execute (method)
execute (method)
execute (method)
execute (method)
execute (method)
execute-task-tree-node (function)
executed (generic function)
executed (method)
fl-cacheable-value-mixin (class)
fl-member (function)
fl-net-cacheable-fluent (class)
fl-net-fluent (class)
fl-printable-mixin (class)
float-/ (function)
format-gensym (function)
get-alist (function)
(setf get-alist) (function)
inherit-parent-value (function)
invoke-event-loop (function)
kill-saved-tasks (function)
list-of (type)
log-block (macro)
log-gc-event (function)
log-mask (function)
log-tag-offset (function)
logfmt (function)
make-code (function)
make-dummy-task (function)
make-event (function)
make-goal-fun (function)
make-message (function)
matching-goal-fun (function)
message (structure)
message-content (function)
(setf message-content) (function)
message-from (function)
(setf message-from) (function)
message-p (function)
message-to (function)
(setf message-to) (function)
named-top-level (macro)
parent-task (generic function)
parent-task (method)
partition (function)
path-next-iteration (function)
propagate-event (function)
pulse-fluent (class)
recalculate-timeout (function)
receive-event (function)
register-task-code (function)
remove-top-level-task-tree (function)
replace-task-code (function)
scheduling-disabled-p (function)
scheduling-enabled-p (function)
seconds-to-internal-time (function)
send-event (function)
setup (function)
signal-time-quantum-exhausted (function)
single-form-progv (macro)
synchronize-on-event (function)
task-abbreviated-name (function)
task-code (generic function)
task-code (method)
task-constraints (generic function)
task-constraints (method)
(setf task-constraints) (method)
(setf task-constraints) (generic function)
task-message-queue (generic function)
task-message-queue (method)
task-name (generic function)
task-name (method)
task-tree-node-code-replacements (function)
(setf task-tree-node-code-replacements) (function)
task-tree-node-lock (function)
(setf task-tree-node-lock) (function)
time-quantum-exhausted (condition)
truncate-string (function)
unwind-and-continue (function)
unwind-and-teardown (function)
update-value (generic function)
update-value (method)
what-time-is-it (function)
who-am-i (function)
with-fluent-locked (macro)
with-parallel-childs (macro)
with-task (macro)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

4.4 `cram-walker`

A fairly basic code walker for use in CPL for expanding plans.

Source

packages (Lisp file)

Nickname

walker

Use List

common-lisp

Used By List

Exported Definitions

expand-plan (function)
find-plan-node (function)
plan-tree-node (structure)
plan-tree-node-children (function)
(setf plan-tree-node-children) (function)
plan-tree-node-parent (function)
(setf plan-tree-node-parent) (function)
plan-tree-node-path (function)
(setf plan-tree-node-path) (function)
plan-tree-node-sexp (function)
(setf plan-tree-node-sexp) (function)
walk-with-tag-handler (function)

Internal Definitions

*cltl2-environment-fns* (special variable)
*current-parent* (special variable)
*current-path* (special variable)
*shadowed-functions* (special variable)
*tag-walker-handlers* (special variable)
aug-env (function)
augment-environment (function)
copy-plan-tree-node (function)
enclose (function)
extend-path (function)
lambda-list-keyword-p (function)
make-plan-tree-node (function)
parse-macro (function)
parse-macro-function (function)
plan-tree-node-p (function)
register-child-plan (function)
tag-form-handler (function)
walk-argument (function)
walk-binding (function)
walk-binding-list (function)
walk-block (function)
walk-cpl-tag (function)
walk-flet (function)
walk-form (function)
walk-funcall (function)
walk-function (function)
walk-labels (function)
walk-lambda (function)
walk-let (function)
walk-let* (function)
walk-list (function)
walk-list-of-lambdas (function)
walk-load-time-value (function)
walk-macrolet (function)
walk-named-lambda (function)
walk-ordinary-lambda-list (function)
walk-plan-form (function)
walk-quote (function)
with-extended-path (macro)
with-shadowed-functions (macro)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5. Definitions

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

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.1 Exported definitions

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.1.1 Special variables

Special Variable: *break-on-plan-failures*

Like *BREAK-ON-SIGNALS*, but for plan failures.

Package: cram-language-implementation
Source: failures (Lisp file)

Special Variable: *current-path*

Contains the current path (in reverse order).

Package: cram-language-implementation
Source: task-interface (Lisp file)

Special Variable: *current-task*

Dynamically bound current task.

Package: cram-language-implementation
Source: task-interface (Lisp file)

Special Variable: *debug-on-lisp-errors*

Indicates if the debugger should be entered at the location where a
common lisp error is raised.

Package: cram-language-implementation
Source: failures (Lisp file)

Special Variable: *log-output*

Where should logging output go to?

Package: cram-language-implementation
Source: logging (Lisp file)

Special Variable: *log-right-margin*

Value for *PRINT-RIGHT-MARGIN* when printing log entries.
Good values between 120 - 150, depending on your window width.

Package: cram-language-implementation
Source: logging (Lisp file)

Special Variable: *save-tasks*

When t, every task to be executed is pushed to *tasks*.

Package: cram-language-implementation
Source: task (Lisp file)

Special Variable: *task-pprint-verbosity*

Verbosity level for how TASK objects are printed.
A value of 0 means that no information is printed that may depend
on a lock.

Package: cram-language-implementation
Source: task-interface (Lisp file)

Special Variable: *task-tree*

The task tree of the current top-level plan.

Package: cram-language-implementation
Source: task (Lisp file)

Special Variable: *tasks*

Queue of all running tasks.

Package: cram-language-implementation
Source: task (Lisp file)

Special Variable: +alive+

Package: cram-language-implementation
Source: task-interface (Lisp file)

Special Variable: +dead+

Package: cram-language-implementation
Source: task-interface (Lisp file)

Special Variable: +done+

Package: cram-language-implementation
Source: task-interface (Lisp file)

Special Variable: +log-all+

Package: cram-language-implementation
Source: logging (Lisp file)

Special Variable: +log-default+

Package: cram-language-implementation
Source: logging (Lisp file)

Special Variable: +log-language+

Package: cram-language-implementation
Source: logging (Lisp file)

Special Variable: +log-verbose+

Package: cram-language-implementation
Source: logging (Lisp file)

Special Variable: +log-very-verbose+

Package: cram-language-implementation
Source: logging (Lisp file)

Special Variable: timeout-policy

Package: cram-language-implementation
Source: default-policies (Lisp file)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.1.2 Macros

Macro: declare-goal NAME LAMBDA-LIST &body BODY

Declares the goal ‘name’. Before matching goals defined with
‘def-goal’ are executed, ‘body’ is executed with ‘pattern’ lexically
bound to the parameter specified when the goal was called. ‘body’ is
executed in an unnamed block that allows for suppressing the execution
of any goal. The idea behind that is that ‘body’ can verify if the
goal already holds and suppress execution of any code.

Package: cram-language-implementation
Source: goals (Lisp file)

Macro: def-cpl-parameter NAME &optional VAL DOC

Defines a global variable (like DEFPARAMETER) that is implemented as a
fluent. You can access it like a lisp variable with "NAME", and also setf it like a lisp variable "(SETF NAME)" - note there is no need for
"(VALUE NAME)". However the variable being implemented as a fluent means that the access is implicitely synchronized with a lock, and all changes are traced if fluent tracing is enabled.

You cannot directly access the implementing fluent which means that you cannot use it for building fluent nets or in cpl-constructs like
WHENEVER. (Just use a normal variable containing a fluent for those purposes).

You can use this for example for defining global datastructures that need not participate directly in cpl constructs, but should be traced in the execution trace and/or accessed by multiple tasks/threads simultaniously.

Package: cram-language-implementation
Source: value-fluent (Lisp file)

Macro: def-cram-function NAME LAMBDA-LIST &rest BODY

Defines a cram function. All functions that should appear in the
task-tree must be defined with def-cram-function.

CAVEAT: See docstring of def-top-level-cram-function.

Package: cram-language-implementation
Source: plans (Lisp file)

Macro: def-goal (NAME &rest PATTERN) &body BODY

Defines a new goal. Goals always have the form

(<name> [pattern]*)

where patterns can be arbitrary expressions containing
variables (indicated by a ?-prefix) and symbols.
Example: (achieve (loc ?obj ?location)) When defining goals with
similar expressions (e.g. (loc Robot ?l) and (loc ?a ?b)) the most
specific expression must be defined first. Otherwise, the previously
defined expression will be overwritten.

In the lexical environment of ‘body’, the function (SUCCEED [values])
is defined which performs a non-local exit, returning ‘values’ as
return values.

Package: cram-language-implementation
Source: goals (Lisp file)

Macro: def-plan NAME LAMBDA-LIST &rest BODY

Package: cram-language-implementation
Source: plans (Lisp file)

Macro: def-top-level-cram-function NAME ARGS &body BODY

Defines a top-level cram function. Every top-level function has its
own episode-knowledge and task-tree.

CAVEAT: Don’t have surrounding FLET / LABLES / MACROLET /
SYMBOL-MACROLET / LET / etc when using DEF-TOP-LEVEL-CRAM-FUNCTION
or DEF-CRAM-FUNCTION (unless you really know what you are
doing). They could mess with (WITH-TAGS ...) or shadow globally
defined plans, which would not be picked up by WITH-TAGS /
EXPAND-PLAN. See the comment before the definition of WITH-TAGS for
more details.

Package: cram-language-implementation
Source: plans (Lisp file)

Macro: def-top-level-plan NAME LAMBDA-LIST &body BODY

Package: cram-language-implementation
Source: plans (Lisp file)

Macro: define-policy NAME PARAMETERS &rest PROPERTIES

This macro implicitly calls ‘make-policy’, and pushes the generated
policy onto the list of defined policies, thus making it accessible to ‘named-policy’ and ‘with-named-policy’ by its name. The usage is the
same as for ‘make-policy’:

> (define-policy policy-1 (param-1 param-2)
"The documentation string for this policy"
(:init (do-initialization-here))
(:check (do-checking-here))
(:recover (do-recovering-here))
(:clean-up (do-cleaning-up-here)))

Package: cram-language-implementation
Source: with-policy (Lisp file)

Macro: define-task-variable NAME &optional GLOBAL-VALUE DOCSTRING &key TYPE INIT-FUNCTION IGNORE-PACKAGE-LOCKS

Define a binding for ‘name’ as a special variable, and in
particular as a task variable.

‘global-value’ is the variable’s global value; if not given, the
variable is unbound. ‘docstring’ is its documentation string. ‘type’
is, optionally, its globally proclaimed type.

A task variable is a binding that is established and initialized right
before execution of a task. The binding is task-local, meaning that
assignment to it won’t affect the variable’s global binding, or
bindings within other tasks.

The initialization is performed by ‘init-function’ which must be a
function of three parameters: the TASK object going to be executed,
the TASK object of the parent task, and the previous value of ‘name’
in the parent. In case the task object is a TOPLEVEL-TASK, the second
argument will be NIL, and the third one will be the global value.

Task variables can hence be used for different purposes:

1. to initialize a variable based on the task object to be executed.

2. to initialize a variable based on the task’s parent.

3. to inherit a task variable’s value from its parent.

In case ‘init-function’ is not given, the default behaviour is the
behaviour of the 3rd item.

Package: cram-language-implementation
Source: task-interface (Lisp file)

Macro: log-event &body CLAUSES

Logs an event specified by ‘clauses’ to *LOG-OUTPUT*.

Syntax:

clauses ::= (:CONTEXT fmt-ctrl . fmt-args)
| (:DISPLAY fmt-ctrl . fmt-args)
| (:TAGS tag+)

A log entry will look like

Where

<realtime> denotes a timestamp relative to *ZERO-REAL-TIME*,

<runtime> denotes a timestamp relative to *ZERO-RUN-TIME*,

<current task> denotes the name of the currently active task,

<context> denotes the result of the format-control ‘fmt-ctrl’ applied to the format-arguments ‘fmt-args’ of the
given :CONTEXT clause,

<display> ditto but for the :DISPLAY clause.

The :TAGS clause specifies the log tags that must be active for
this LOG-EVENT to emit any output.

It is hence possible to specify the degree of logging in a very fine-grained way: log tags can be dynamically enabled by
LOG-ENABLE, disabled by LOG-DISABLE, and set by LOG-SET.

Most defined log tags correspond to constructs of cpl or the underlying implementation. Use the :debug tag for adding (temporary) debug messages.

For convenience, the following constants are defined to enable a
bunch of tags at once:

+LOG-ALL+ - set of all available tags

+LOG-DEFAULT+ - a predefined default set

+LOG-VERBOSE+ - +LOG-DEFAULT+ + more

+LOG-VERY-VERBOSE+ - +LOG-VERBOSE+ + even more

+LOG-LANGUAGE+ - set of all CRAM language constructs.

5.1.3 Functions

Function: * &rest ARGS

Package: cram-language
Source: fluent-operators (Lisp file)

Function: + &rest ARGS

Package: cram-language
Source: fluent-operators (Lisp file)

Function: - &rest ARGS

Package: cram-language
Source: fluent-operators (Lisp file)

Function: / &rest ARGS

Package: cram-language
Source: fluent-operators (Lisp file)

Function: < &rest ARGS

Package: cram-language
Source: fluent-operators (Lisp file)

Function: = &rest ARGS

Package: cram-language
Source: fluent-operators (Lisp file)

Function: > &rest ARGS

Package: cram-language
Source: fluent-operators (Lisp file)

Function: clear-tasks TASK-TREE-NODE

Removes recursively all tasks from the tree. Keeps tree structure and
leaves code-replacements in place.

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: code-function INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task-tree (Lisp file)
Writer: (setf code-function) (function)

Function: (setf code-function) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task-tree (Lisp file)
Reader: code-function (function)

Function: code-parameters INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task-tree (Lisp file)
Writer: (setf code-parameters) (function)

Function: (setf code-parameters) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task-tree (Lisp file)
Reader: code-parameters (function)

Function: code-sexp INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task-tree (Lisp file)
Writer: (setf code-sexp) (function)

Function: (setf code-sexp) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task-tree (Lisp file)
Reader: code-sexp (function)

Function: code-task INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task-tree (Lisp file)
Writer: (setf code-task) (function)

Function: (setf code-task) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task-tree (Lisp file)
Reader: code-task (function)

Function: current-task

Package: cram-language-implementation
Source: task-interface (Lisp file)

Function: describe-goal GOAL

Package: cram-language-implementation
Source: goals (Lisp file)

Function: eq &rest ARGS

Package: cram-language
Source: fluent-operators (Lisp file)

Function: eql &rest ARGS

Package: cram-language
Source: fluent-operators (Lisp file)

Function: expand-plan FORM

Expand-plan takes a sexp and macroexpands it. Whenever it encounters a call
to a plan it continues by expanding the sexp that defined that plan and thus builds up a hierarchie of plans (plan-tree). Expand-plan returns two values: The resulting plan tree and the macroexpansion of form (with calls to plans still in place) of which the plan tree will be the most interesting. The root of the plan-tree returned by expand-plan doesn’t correspond to a plan call, but the form that was passed to expand-plan.

Package: cram-walker
Source: interface (Lisp file)

Function: fail &rest ARGS

Package: cram-language-implementation
Source: failures (Lisp file)

Function: filter-task-tree PREDICATE TREE

Returns a copy of the task tree which contains only nodes that satisfy ‘predicate’. CAVEAT: If a node does not satisfy ‘predicate’ then none of its descendants will appear in the filtered tre, even if they satisfy ‘preidacte’. Assume that the root saisfies ‘predicate’, otherwise there would be no tree to return.

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: find-plan-node PLAN-TREE PATH

Return the plan-tree-node specified by the path. Returns nil, if the path
is not valid.

Package: cram-walker
Source: plan-tree (Lisp file)

Function: fl* &rest FL-ARGS521

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: fl+ &rest FL-ARGS445

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: fl- &rest FL-ARGS483

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: fl-and &rest FL-ARGS635

The and-operator for fluents. It is fundamentally different to the
definition of common-lisp’s and in that it is not implemented as a
macro. That means, all args are evaluated when using fl-and.

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: fl-apply FUN ARG &rest MORE-ARGS

FIXME

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: fl-eq &rest FL-ARGS331

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: fl-eql &rest FL-ARGS369

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: fl-funcall &rest FL-ARGS720

Generic fluent-operator. Applys args to function whenever a
fluent in args changes.

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: fl-not &rest FL-ARGS597

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: fl-or &rest FL-ARGS661

The or-operator for fluents. For more information on why it is a
function please refere to the documentation of fl-and.

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: fl-pulsed FLUENT &key HANDLE-MISSED-PULSES

Returns a fluent whose value becomes T only and only if its parent
fluent has been pulsed. How long it stays T depends on the parameter ‘handle-missed-pulses’. It can be either :NEVER :ONCE or :ALWAYS:

- :NEVER means that missed pulses are ignored, i.e. the initial
value is always NIL and becomes T only when ‘fluent’ gets
pulsed. It stays T only for exactly one call of VALUE, even if
more than one pulse occured since the last call to VALUE.

- :ONCE is similar to :NEVER but has an initial value of T if
‘fluent’ has been pulsed at least once before.

- :ALWAYS means that the VALUE method returns T for exactly the
number of pulses of ‘fluent’.

Please note that the value of a PULSE-FLUENT changes from one call to
another. That means it is not re-entrant, and FL-PULSED should not be
bound to a variable or passed around. This could lead to unwanted
behavior if one thread catches pulses another one was to handle.

Package: cram-language-implementation
Source: pulse-fluent (Lisp file)

Function: fl-value-changed FLUENT &key TEST KEY

Returns a fluent that gets pulsed and has the value T whenever
‘fluent’ changes its value.

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: fl/ &rest FL-ARGS559

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: fl< &rest FL-ARGS217

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: fl= &rest FL-ARGS293

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: fl> &rest FL-ARGS255

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: flatten-task-tree TASK-TREE

Returns a list of all the nodes in the tree.

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: get-top-level-task-tree NAME

Returns the task tree for a named top level (top level plan).

Package: cram-language-implementation
Source: language (Lisp file)

Function: goal-task-tree-node-goal TASK-TREE-NODE

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: goal-task-tree-node-p TASK-TREE-NODE

Returns true if ‘task-tree-node’ is a goal task.

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: goal-task-tree-node-parameter-bindings TASK-TREE-NODE

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: goal-task-tree-node-pattern TASK-TREE-NODE

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: list-active-log-tags

List all log tags active at the moment.

Package: cram-language-implementation
Source: logging (Lisp file)

Function: list-available-log-tags

List all available log tags.

Package: cram-language-implementation
Source: logging (Lisp file)

Function: list-saved-tasks

Package: cram-language-implementation
Source: task (Lisp file)

Function: log-disable TAGS

Disable each tag in ‘tags’.
Corresponding LOG-EVENTs will cease to emit any output.

Package: cram-language-implementation
Source: logging (Lisp file)

Function: log-enable TAGS

Enable each tag in ‘tags’.
Corresponding LOG-EVENTs will begin to emit output.

Package: cram-language-implementation
Source: logging (Lisp file)

Function: log-set TAGS

Enable only the tags in ‘tags’, disabling all other tags first.
Corresponding LOG-EVENTs will being / cease to emit output.

Package: cram-language-implementation
Source: logging (Lisp file)

Function: make-fluent &rest ARGS &key CLASS NAME VALUE ALLOW-TRACING MAX-TRACING-FREQ &allow-other-keys

Use this to create fluents. Default class is VALUE-FLUENT.

Pass :ALLOW-TRACING NIL to never trace this fluent (default T).

Pass :MAX-TRACING-FREQ to restrict the frequency with which updates to this fluents are traced. The unit is ’1/second’. Default is NIL (meaning no restriction).

Package: cram-language-implementation
Source: value-fluent (Lisp file)

Function: make-task &key NAME SEXP FUNCTION PATH PARAMETERS

Returns a runnable task for the path

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: make-task-tree-node &key (CODE DUM42) (CODE-REPLACEMENTS DUM43) (PARENT DUM44) (CHILDREN DUM45) (PATH DUM46) (LOCK DUM47)

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: named-policy POLICY-NAME

Returns the policy by the name ‘policy-name’ from the list of
defined policies. If the policy by this name is not in the list, the ‘policy-not-found’ condition is signalled. Usage:

> (named-policy ’policy-name)

Package: cram-language-implementation
Source: with-policy (Lisp file)

Function: not &rest ARGS

Package: cram-language
Source: fluent-operators (Lisp file)

Function: peek-value FLUENT

Return the same value as VALUE, except that this never changes the state of the flunet. E.g. for PULSE-FLUENT the internal counter is not incremented.

Package: cram-language-implementation
Source: fluent (Lisp file)

Function: plan-tree-node-children INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-walker
Source: plan-tree (Lisp file)
Writer: (setf plan-tree-node-children) (function)

Function: (setf plan-tree-node-children) NEW-VALUE INSTANCE

Package: cram-walker
Source: plan-tree (Lisp file)
Reader: plan-tree-node-children (function)

Function: plan-tree-node-parent INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-walker
Source: plan-tree (Lisp file)
Writer: (setf plan-tree-node-parent) (function)

Function: (setf plan-tree-node-parent) NEW-VALUE INSTANCE

Package: cram-walker
Source: plan-tree (Lisp file)
Reader: plan-tree-node-parent (function)

Function: plan-tree-node-path INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-walker
Source: plan-tree (Lisp file)
Writer: (setf plan-tree-node-path) (function)

Function: (setf plan-tree-node-path) NEW-VALUE INSTANCE

Package: cram-walker
Source: plan-tree (Lisp file)
Reader: plan-tree-node-path (function)

Function: plan-tree-node-sexp INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-walker
Source: plan-tree (Lisp file)
Writer: (setf plan-tree-node-sexp) (function)

Function: (setf plan-tree-node-sexp) NEW-VALUE INSTANCE

Package: cram-walker
Source: plan-tree (Lisp file)
Reader: plan-tree-node-sexp (function)

Function: pulsed &rest ARGS

Package: cram-language
Source: fluent-operators (Lisp file)

Function: register-goal NAME PATTERN GOAL-FUN &optional DOC-STRING

Package: cram-language-implementation
Source: goals (Lisp file)

Function: sleep SECONDS

Package: cram-language
Source: fluent-operators (Lisp file)

Function: sleep* SECONDS

Package: cram-language-implementation
Source: utils (Lisp file)

Function: stale-task-tree-node-p NODE

Returns true if node is stale, i.e. it has no associated task object.

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: sub-task PATH

Small helper function to get a sub-task of the current task.

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: task PATH

Small helper function to get a task from a path.

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: task-alive TASK

Returns a fluent indicating if the task is alive

Package: cram-language-implementation
Source: task (Lisp file)

Function: task-dead TASK

Package: cram-language-implementation
Source: task (Lisp file)

Function: task-dead-p TASK

Package: cram-language-implementation
Source: task (Lisp file)

Function: task-done-p TASK

Package: cram-language-implementation
Source: task (Lisp file)

Function: task-failed-p TASK

Package: cram-language-implementation
Source: task (Lisp file)

Function: task-running-p TASK

Package: cram-language-implementation
Source: task (Lisp file)

Function: task-tree-node PATH

Returns the task-tree node for path or nil.

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: task-tree-node-children INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task-tree (Lisp file)
Writer: (setf task-tree-node-children) (function)

Function: (setf task-tree-node-children) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task-tree (Lisp file)
Reader: task-tree-node-children (function)

Function: task-tree-node-code INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task-tree (Lisp file)
Writer: (setf task-tree-node-code) (function)

Function: (setf task-tree-node-code) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task-tree (Lisp file)
Reader: task-tree-node-code (function)

Function: task-tree-node-effective-code NODE

Returns the effective code of the node. I.e. the code that is
actually executed. When the node has replacements, the current
replacement is used, otherwise the original code.

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: task-tree-node-p OBJECT

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: task-tree-node-parameters TASK-TREE-NODE

Return the parameters with which the task was called. Assume node is not stale.

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: task-tree-node-parent INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task-tree (Lisp file)
Writer: (setf task-tree-node-parent) (function)

Function: (setf task-tree-node-parent) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task-tree (Lisp file)
Reader: task-tree-node-parent (function)

Function: task-tree-node-path INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task-tree (Lisp file)
Writer: (setf task-tree-node-path) (function)

Function: (setf task-tree-node-path) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task-tree (Lisp file)
Reader: task-tree-node-path (function)

Function: task-tree-node-result TASK-TREE-NODE

Return the tasks result. Assume node is not stale.

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: task-tree-node-status-fluent TASK-TREE-NODE

Return the tasks status fluent. Assume node is not stale.

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: tv-closure TASK PARENT-TASK CONTINUATION

Establish bindings for task variables and initialize them.

Package: cram-language-implementation
Source: task (Lisp file)

Function: walk-with-tag-handler FORM TAG-HANDLER ENV

Macroexpands form and calls tag-handler once for every (:tag name body)
form it encounters. The two parameters passed to the tag-handler are name and body. Returns the expansion of form.

Package: cram-walker
Source: interface (Lisp file)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.1.4 Generic functions

Generic Function: composite-failures CONDITION

Package

Methods

Method: composite-failures (CONDITION composite-failure)

Generic Function: envelop-error CONDITION

Package

Methods

Method: envelop-error (CONDITION common-lisp-error-envelope)

Generic Function: evaporate TASK &key REASON SYNC SYNC

Terminates a task.

Package

Source

task-interface (Lisp file)

Methods

Method: evaporate (TASK abstract-task) &key REASON SYNC

Source: task (Lisp file)

Generic Function: get-update-callback FLUENT NAME

Returns the callback with given name or NIL if it doesn’t exist.

Package

Source

fluent-interface (Lisp file)

Methods

Method: get-update-callback (FLUENT fluent) NAME

Source: fluent (Lisp file)

Generic Function: join-task TASK

Waits for ‘task’ to finish.
When ‘task’ fails, this function rethrows the failure; when ‘task’ succeeds, it returns the result values of ‘task’.

Package

Source

task-interface (Lisp file)

Methods

Method: join-task (TASK abstract-task)

Source: task (Lisp file)

Generic Function: name OBJECT

Package

Methods

Method: name (ABSTRACT-TASK abstract-task)

The name of the task. Mostly for debugging reasons.
Should also become the name of the thread executing
the task.

Source: task (Lisp file)

Method: name (POLICY policy)

automatically generated reader method

Source: with-policy (Lisp file)

Method: name (FLUENT fluent)

The name of the fluent. Should be a globally unique symbol.

Source: fluent-interface (Lisp file)

Generic Function: on-def-top-level-plan-hook PLAN-NAME

Executed when a top-level-plan is defined.

Package: cram-language-implementation
Source: plans (Lisp file)
Method Combination: hooks

Generic Function: on-fail DATUM

Hook that is executed whenever a condition is
signaled using FAIL.

Package: cram-language-implementation
Source: failures (Lisp file)
Method Combination: hooks

Generic Function: on-make-fluent-hook FLUENT ALLOW-TRACING MAX-TRACING-FREQ

This is a generic function with hook method
combination. All defined methods are executed after a fluent is created.

Package: cram-language-implementation
Source: value-fluent (Lisp file)
Method Combination: hooks

Generic Function: on-top-level-cleanup-hook TOP-LEVEL-NAME

All defined hooks are exected after the top level task has
been joined. The call is made when the dynamic environment established by the return values of ON-TOP-LEVEL-SETUP-HOOK is still in effect. The call to this hook is protected by an unwind protect.

Package: cram-language-implementation
Source: language (Lisp file)
Method Combination: hooks

Generic Function: on-top-level-setup-hook TOP-LEVEL-NAME TASK-TREE

All defined hooks are executed before the top level task is
created. The task-tree passed is the root of the task-tree used in this top level. Each method must return a cons cell with a list of symbols in the car and a list of values in the cdr. The lists of all methods are concatenated and the passed to a progv to establish the dynamic environment where the top-level task is executed.

Package

Source

language (Lisp file)

Method Combination

hooks

Options: :hook-combination, (lambda (&rest cram-language-implementation::results) (loop cram-language-implementation::for cram-language-implementation::r cram-language-implementation::in cram-language-implementation::results append (car cram-language-implementation::r) cram-language-implementation::into cram-language-implementation::symbols append (cdr cram-language-implementation::r) cram-language-implementation::into values cram-language-implementation::finally (return (cons cram-language-implementation::symbols values))))

Generic Function: parameters OBJECT

Package

Methods

Method: parameters (POLICY policy)

automatically generated reader method

Source: with-policy (Lisp file)

Generic Function: pulse FLUENT

Method to trigger the fluent, i.e. notifying all waiting threads,
but without actually changing the fluent value.

Package

Source

fluent-interface (Lisp file)

Methods

Method: pulse (FLUENT fl-net-cacheable-fluent) around

Source: fluent-net (Lisp file)

Method: pulse (FLUENT fluent)

Source: fluent (Lisp file)

Generic Function: register-update-callback FLUENT NAME UPDATE-FUN

Method to register an update callback under the corresponding
name. When the name is already known, an error is signaled.

Package

Source

fluent-interface (Lisp file)

Methods

Method: register-update-callback (FLUENT fluent) NAME UPDATE-FUN

Source: fluent (Lisp file)

Generic Function: remove-update-callback FLUENT NAME

Method to remove the update callback with the given name.

Package

Source

fluent-interface (Lisp file)

Methods

Method: remove-update-callback (FLUENT fluent) NAME

Source: fluent (Lisp file)

Generic Function: result TASK

Returns the result of the thread. For multiple values, this
function also returns multiple values.

Package

Source

task-interface (Lisp file)

Methods

Method: result (TASK abstract-task)

Source: task (Lisp file)

Generic Function: status TASK

Returns the status fluent of the task.

Package

Source

task-interface (Lisp file)

Methods

Method: status (ABSTRACT-TASK abstract-task)

Fluent indicating the task status.
Cf. STATUS-INDICATOR.

Source: task (Lisp file)

Generic Function: suspend TASK &key REASON SYNC SYNC

Blocks a thread until it is terminated or awaken.

Package

Source

task-interface (Lisp file)

Methods

Method: suspend (TASK abstract-task) &key REASON SYNC

Source: task (Lisp file)

Generic Function: task-path TASK

Returns the path of the task.

Package

Source

task-interface (Lisp file)

Methods

Method: task-path (ABSTRACT-TASK abstract-task)

The path of the task.

Source: task (Lisp file)

Generic Function: value FLUENT

Reader method, returning the fluent’s value

Package

Source

fluent-interface (Lisp file)

Writer

(setf value) (generic function)

Methods

Method: value (FLUENT pulse-fluent)

Source: pulse-fluent (Lisp file)

Method: value (FLUENT fl-net-cacheable-fluent)

Source: fluent-net (Lisp file)

Method: value (FLUENT fl-net-fluent)

Source: fluent-net (Lisp file)

Method: value (FLUENT value-fluent)

Source: value-fluent (Lisp file)

Method: value VAR

Default handler. It seems to be a quite good idea to allow the
usage of value for all types of objects.

Source: fluent (Lisp file)

Generic Function: (setf value) NEW-VALUE FLUENT

Setter method to set the new value of the fluent

Package

Source

value-fluent (Lisp file)

Reader

value (generic function)

Methods

Method: (setf value) NEW-VALUE (FLUENT value-fluent)

Generic Function: wait-for FLUENT &key TIMEOUT TIMEOUT &allow-other-keys

Method to block the current thread until the value of ‘fluent’
becomes non-nil. If ‘timeout’ is specified, waits for at least
timeout and returns.

Package

Source

fluent-interface (Lisp file)

Methods

Method: wait-for (FLUENT fluent) &key TIMEOUT

Source: fluent (Lisp file)

Method: wait-for VAR &key &allow-other-keys

Source: fluent (Lisp file)

Generic Function: wake-up TASK &key REASON SYNC SYNC

Wakes up ‘task’ if it’s suspended; otherwise do nothing.

Package

Source

task-interface (Lisp file)

Methods

Method: wake-up (TASK abstract-task) &key REASON SYNC

Source: task (Lisp file)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.1.5 Conditions

Condition: common-lisp-error-envelope

Package

Source

failures (Lisp file)

Direct superclasses

plan-failure (condition)

Direct methods

envelop-error (method)

Direct slots

Slot: error

Initargs: :error
Readers: envelop-error (generic function)

Condition: composite-failure

Package

Source

failures (Lisp file)

Direct superclasses

plan-failure (condition)

Direct methods

composite-failures (method)

Direct slots

Slot: failures

Initargs: :failures
Initform: ’nil
Readers: composite-failures (generic function)

Condition: plan-failure

Condition which denotes a plan failure.

Package

Source

failures (Lisp file)

Direct superclasses

serious-condition

Direct subclasses

simple-plan-failure (condition)
composite-failure (condition)
common-lisp-error-envelope (condition)

Condition: policy-check-condition-met

Package: cram-language-implementation
Source: with-policy (Lisp file)
Direct superclasses: policy-failure (condition)

Condition: policy-condition

Package

Source

with-policy (Lisp file)

Direct superclasses

condition

Direct subclasses

policy-not-found (condition)
policy-failure (condition)

Direct methods

policy-name (method)

Direct slots

Slot: name

Initargs: :name
Readers: policy-name (generic function)

Condition: policy-failure

Package

Source

with-policy (Lisp file)

Direct superclasses

policy-condition (condition)

Direct subclasses

policy-init-failed (condition)
policy-check-condition-met (condition)

Direct methods

policy-parameters (method)

Direct slots

Slot: parameters

Initargs: :parameters
Readers: policy-parameters (generic function)

Condition: policy-init-failed

Package: cram-language-implementation
Source: with-policy (Lisp file)
Direct superclasses: policy-failure (condition)

Condition: policy-not-found

Package: cram-language-implementation
Source: with-policy (Lisp file)
Direct superclasses: policy-condition (condition)

Condition: simple-plan-failure

Package

Source

failures (Lisp file)

Direct superclasses

plan-failure (condition)
simple-condition

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.1.6 Structures

Structure: code

Represents a piece of code that can be replaced. It contains the
sexp as well as a function object that can be executed. Further, it
contains the top-level task and all tasks in the lexical environment
of the top-level task. This can be used to get the variable bindings
of a specific task without the need to walk the task tree.

Package

Source

task-tree (Lisp file)

Direct superclasses

structure-object

Direct slots

Slot: sexp

Readers: code-sexp (function)
Writers: (setf code-sexp) (function)

Slot: function

Readers: code-function (function)
Writers: (setf code-function) (function)

Slot: task

Readers: code-task (function)
Writers: (setf code-task) (function)

Slot: parameters

Readers: code-parameters (function)
Writers: (setf code-parameters) (function)

Structure: plan-tree-node

Package

cram-walker

Source

plan-tree (Lisp file)

Direct superclasses

structure-object

Direct methods

print-object

Direct slots

Slot: sexp

Readers: plan-tree-node-sexp (function)
Writers: (setf plan-tree-node-sexp) (function)

Slot: path

Readers: plan-tree-node-path (function)
Writers: (setf plan-tree-node-path) (function)

Slot: parent

Readers: plan-tree-node-parent (function)
Writers: (setf plan-tree-node-parent) (function)

Slot: children

Readers: plan-tree-node-children (function)
Writers: (setf plan-tree-node-children) (function)

Structure: task-tree-node

Package

Source

task-tree (Lisp file)

Direct superclasses

structure-object

Direct methods

print-object

Direct slots

Slot: code

Readers: task-tree-node-code (function)
Writers: (setf task-tree-node-code) (function)

Slot: code-replacements

Initform: (list)
Readers: task-tree-node-code-replacements (function)
Writers: (setf task-tree-node-code-replacements) (function)

Slot: parent

Readers: task-tree-node-parent (function)
Writers: (setf task-tree-node-parent) (function)

Slot: children

Readers: task-tree-node-children (function)
Writers: (setf task-tree-node-children) (function)

Slot: path

Readers: task-tree-node-path (function)
Writers: (setf task-tree-node-path) (function)

Slot: lock

Initform: (sb-thread:make-mutex)
Readers: task-tree-node-lock (function)
Writers: (setf task-tree-node-lock) (function)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.1.7 Classes

Class: fluent

Package

Source

fluent-interface (Lisp file)

Direct superclasses

standard-object

Direct subclasses

value-fluent (class)
fl-net-fluent (class)
fl-net-cacheable-fluent (class)
pulse-fluent (class)

Direct methods

pulse (method)
wait-for (method)
remove-update-callback (method)
get-update-callback (method)
register-update-callback (method)
print-object
initialize-instance
name (method)

Direct slots

Slot: name

The name of the fluent. Should be a globally unique symbol.

Type: symbol
Initargs: :name
Initform: (gensym "fluent-")
Readers: name (generic function)

Slot: on-update

Hash-table of update callbacks, being executed on every change of
the value. The update callback is a function with no parameters.

Type: hash-table
Initform: (make-hash-table :test ’eq)

Slot: pulse-count

For internal use. Indicates a pulse.

Initargs: :pulse-count
Initform: 0

Slot: changed-condition: For internal use. Posix condition variable/waitqueue
used for notification when value changed.

Slot: value-lock: For internal use. Lock to be used with for access synchronization.

Class: task

Package: cram-language-implementation
Source: task (Lisp file)
Direct superclasses: abstract-task (class)
Direct methods: execute (method)

Class: toplevel-task

Package: cram-language-implementation
Source: task (Lisp file)
Direct superclasses: abstract-task (class)

Class: value-fluent

Package

Source

value-fluent (Lisp file)

Direct superclasses

fl-printable-mixin (class)
fl-cacheable-value-mixin (class)
fluent (class)

Direct methods

value
value (method)
print-object

Direct slots

Slot: value

The value of the fluent

Initargs: :value

Slot: test

Test to check for value changes (used in setf value).

Initargs: :test
Initform: #’eql

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.1.8 Types

Type: status-indicator

Cf. *STATUS-TRANSITIONS*

Package: cram-language-implementation
Source: task-interface (Lisp file)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.2 Internal definitions

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.2.1 Special variables

Special Variable: *active-log-mask*

A bitmask representing the currently enabled log tags.

Package: cram-language-implementation
Source: logging (Lisp file)

Special Variable: *cltl2-environment-fns*

The functions for augmenting the environment as defined in CLTL2 are not in the ANSI Standard and thus implementation-spefic. This lists the functions needed and is assigned in env-impl-specific.lisp.

Package: cram-walker
Source: env (Lisp file)

Special Variable: *current-parent*

Contains the current parent when constructing the plan tree during code walking. If we call walk-form with this being nil, it doesnt build a tree, nor follow plan calls.

Package: cram-walker
Source: walker (Lisp file)

Special Variable: *current-path*

Current path during walking and creating the plan tree.

Package: cram-walker
Source: walker (Lisp file)

Special Variable: *current-task-tree-node*

The current task tree node.

Package: cram-language-implementation
Source: task (Lisp file)

Special Variable: *log-tag-table*

Package: cram-language-implementation
Source: logging (Lisp file)

Special Variable: *peek-value*

This is used to implement PEEK-VALUE.

Package: cram-language-implementation
Source: fluent (Lisp file)

Special Variable: *policies*

List of defined policies

Package: cram-language
Source: with-policy (Lisp file)

Special Variable: *policy-check-consolidation-duration*

Package: cram-language
Source: with-policy (Lisp file)

Special Variable: *scheduling-enabled*

Package: cram-language-implementation
Source: task (Lisp file)

Special Variable: *shadowed-functions*

This picks up the shaddowed function while walking, so we dont need to
access the environment (which is not possible in a standardized way, not even with whats in CLTL2).

Package: cram-walker
Source: walker (Lisp file)

Special Variable: *status-transitions*

Valid transitions from one task’s status to the next.

Package: cram-language-implementation
Source: task (Lisp file)

Special Variable: *suspension-handlers*

Package: cram-language-implementation
Source: task (Lisp file)

Special Variable: *suspension-unwind*

Package: cram-language-implementation
Source: task (Lisp file)

Special Variable: *synchronous-events*

Indicates if we want to use synchronized events

Package: cram-language-implementation
Source: task (Lisp file)

Special Variable: *tag-walker-handlers*

When a (:tag name body) form is encounterd during code walking,
all functions in the list that *tag-walker-handlers* refers to are called with the 2 parameters name and body.

Package: cram-walker
Source: walker (Lisp file)

Special Variable: *task-local-variables*

Package: cram-language-implementation
Source: task-interface (Lisp file)

Special Variable: *task-tree-print-children*

Determines how task-tree-nodes are pretty-printed. One of (nil :count :full). Default :count

Package: cram-language-implementation
Source: task-tree (Lisp file)

Special Variable: *task-tree-print-code*

Determines how task-tree-nodes are pretty-printed. Generalized Boolean. Default nil

Package: cram-language-implementation
Source: task-tree (Lisp file)

Special Variable: *task-tree-print-identity*

Determines how task-tree-nodes are pretty-printed. Generalized Boolean. Default t

Package: cram-language-implementation
Source: task-tree (Lisp file)

Special Variable: *task-tree-print-path*

Determines how task-tree-nodes are pretty-printed. One of (nil :one :full). Default :full

Package: cram-language-implementation
Source: task-tree (Lisp file)

Special Variable: *top-level-task-trees*

The task tree for named top levels (top level plans) is stored in this hash-table by indexed by the plan name (which is a symbol).

Package: cram-language-implementation
Source: language (Lisp file)

Special Variable: *zero-real-time*

Base timestamp to compute relative real-time timestamps from.
This variable gets its value from the top-level task, all sub tasks
will just inherit it.

Package: cram-language-implementation
Source: logging (Lisp file)

Special Variable: *zero-run-time*

Like *ZERO-REAL-TIME*, but for run-time timestamps.

Package: cram-language-implementation
Source: logging (Lisp file)

Special Variable: +available-log-tags+

Package: cram-language-implementation
Source: logging (Lisp file)

Special Variable: +time-quantum+

Period in seconds at which an entrance into the event loop is
scheduled.

Package: cram-language-implementation
Source: task (Lisp file)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.2.2 Macros

Macro: def-fluent-operator &whole W NAME ARGS &body BODY

def-fluent-operator allows to define fluent operators. It creates a
new function with the given name. When it is called with a fluent
in its parameter list, a fluent network is returned, with the
function body as its calculator. Otherwise, the body is called
directly.

We need one special case. Some operators need to always pulse the
returned fluent net. This is solved by havin a second value. When
the body returns a non-nil second value, the fluent net is always
pulsed, otherwise only when the fluent net value has changed.

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Macro: def-plan-macro NAME LAMBDA-LIST &body BODY

Wrapper around DEFMACRO for defining macros constituting cpl constructs
used in plans.

DEF-PLAN-MACRO wraps ‘body’ in code that checks that it is only used within cpl plans. More precicesly the macro includes a check that it is used in a dynamic context where *CURRENT-TASK* is not nil. Otherwise an ERROR condition is signaled (at runtime).

DEF-PLAN-MACRO also adds information about the plan macro (‘lambda-list’ and ‘body’) to the symbol ‘name’, so the plan walker can use this information during plan expansion. This information can also be used for plan transformation.

5.2.3 Functions

Function: %define-log-tags NAMES

Package: cram-language-implementation
Source: logging (Lisp file)

Function: %fail DATUM ARGS

Package: cram-language-implementation
Source: failures (Lisp file)

Function: %log-event CTX-CONTROL CTX-ARGS DISPLAY-CONTROL DISPLAY-ARGS

Package: cram-language-implementation
Source: logging (Lisp file)

Function: %make-event TAG VALUES REASON SYNC

Package: cram-language-implementation
Source: task (Lisp file)

Function: %teardown TASK FINAL-STATUS RESULT REASON SYNC

Package: cram-language-implementation
Source: task (Lisp file)

Function: %timed-wait-for FLUENT TIMEOUT

Package: cram-language-implementation
Source: fluent (Lisp file)

Function: %unwind-on-suspension BODY-THUNK AFTER-SUSPENSION-CONTINUATION

If a suspension occurs during the execution of ‘body-thunk’,
unwind out of ‘body-thunk’, continue the suspension process, and
after wakeup execute ‘after-suspension-continuation’.

Package: cram-language-implementation
Source: task (Lisp file)

Function: adjust-time-quantum &optional NEW

Renew the current time quantum.

Package: cram-language-implementation
Source: task (Lisp file)

Function: assert-status TASK STATUS &rest MORE

Package: cram-language-implementation
Source: task (Lisp file)

Function: aug-env ENV KIND BINDINGS

Returns a new environment that is like env, with the according variable, macro, symbol-macro or function bindings added. Other than CLTL2’s augment-environment, this is designed to be especially convenient to call from within the walker.

Package: cram-walker
Source: env (Lisp file)

Function: augment-environment ENV &key VARIABLE SYMBOL-MACRO FUNCTION MACRO DECLARE

Calls the implementation specific CLTL2 function.

Package: cram-walker
Source: env (Lisp file)

Function: call-as-fluent-operator FUNCTION ARGS &key FLUENTS NAME FORCE-NO-CACHE

The meat of DEF-FLUENT-OPERATOR.

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: call-goal NAME ARGS

Package: cram-language-implementation
Source: goals (Lisp file)

Function: call-on-suspension ON-SUSPENSION-THUNK BODY-THUNK

Package: cram-language-implementation
Source: task (Lisp file)

Function: call-with-event-loop THUNK CONSTRAINTS

Execute ‘thunk’, and periodically enter the event-loop.

Package: cram-language-implementation
Source: task (Lisp file)

Function: call-with-scheduling THUNK

Execute ‘thunk’, and signal TIME-QUANTUM-EXHAUSTED if the current
time quantum is exhausted.

Package: cram-language-implementation
Source: task (Lisp file)

Function: call-without-scheduling THUNK

Package: cram-language-implementation
Source: task (Lisp file)

Function: change-status TASK NEW-STATUS

Package: cram-language-implementation
Source: task (Lisp file)

Function: check-time-quantum

Check whether we already exceeded our current time quantum.

Package: cram-language-implementation
Source: task (Lisp file)

Function: clear-saved-tasks

Package: cram-language-implementation
Source: task (Lisp file)

Function: code-p OBJECT

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: coerce-to-condition DATUM ARGUMENTS DEFAULT-TYPE

Package: cram-language-implementation
Source: failures (Lisp file)

Function: continue-with-adjusted-time-quantum &optional NEW-QUANTUM C

Package: cram-language-implementation
Source: task (Lisp file)

Function: copy-code INSTANCE

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: copy-event INSTANCE

Package: cram-language-implementation
Source: task (Lisp file)

Function: copy-message INSTANCE

Package: cram-language-implementation
Source: task (Lisp file)

Function: copy-plan-tree-node INSTANCE

Package: cram-walker
Source: plan-tree (Lisp file)

Function: copy-task-tree-node INSTANCE

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: enclose LAMBDA-EXPRESSION &optional ENV

Calls the implementation specific CLTL2 function.

Package: cram-walker
Source: env (Lisp file)

Function: ensure-tree-node PATH &optional TASK-TREE

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: event-loop CURRENT-TASK &optional EVENT WAIT-FOR-EVENT

Package: cram-language-implementation
Source: task (Lisp file)

Function: event-p OBJECT

Package: cram-language-implementation
Source: task (Lisp file)

Function: event-reason INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task (Lisp file)
Writer: (setf event-reason) (function)

Function: (setf event-reason) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task (Lisp file)
Reader: event-reason (function)

Function: event-sync INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task (Lisp file)
Writer: (setf event-sync) (function)

Function: (setf event-sync) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task (Lisp file)
Reader: event-sync (function)

Function: event-tag INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task (Lisp file)
Writer: (setf event-tag) (function)

Function: (setf event-tag) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task (Lisp file)
Reader: event-tag (function)

Function: event-values INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task (Lisp file)
Writer: (setf event-values) (function)

Function: (setf event-values) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task (Lisp file)
Reader: event-values (function)

Function: execute-task-tree-node NODE

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: extend-path TYPE LABEL CURRENT-PATH

Package: cram-walker
Source: walker (Lisp file)

Function: fl-member &rest FL-ARGS407

Package: cram-language-implementation
Source: fluent-net (Lisp file)

Function: float-/ A B

Package: cram-language-implementation
Source: utils (Lisp file)

Function: format-gensym FORMAT-STRING &rest FORMAT-ARGS

Package: cram-language-implementation
Source: utils (Lisp file)

Function: get-alist NAME ALIST &rest KEYS &key KEY TEST TEST-NOT

Function: (setf get-alist) NEW-VALUE NAME ALIST &rest KEYS &key KEY TEST TEST-NOT

Package: cram-language-implementation
Source: utils (Lisp file)

Function: inherit-parent-value TASK PARENT-TASK PARENT-VALUE

Package: cram-language-implementation
Source: task-interface (Lisp file)

Function: invoke-event-loop &optional EVENT

Package: cram-language-implementation
Source: task (Lisp file)

Function: kill-saved-tasks

Package: cram-language-implementation
Source: task (Lisp file)

Function: lambda-list-keyword-p OBJ

Package: cram-walker
Source: env (Lisp file)

Function: log-gc-event

Package: cram-language-implementation
Source: task (Lisp file)

Function: log-mask TAGS

Package: cram-language-implementation
Source: logging (Lisp file)

Function: log-tag-offset TAG

Package: cram-language-implementation
Source: logging (Lisp file)

Function: logfmt STREAM FORMAT-CONTROL &rest FORMAT-ARGS

Package: cram-language-implementation
Source: logging (Lisp file)

Function: make-code &key (SEXP DUM0) (FUNCTION DUM1) (TASK DUM2) (PARAMETERS DUM3)

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: make-dummy-task THREAD

Package: cram-language-implementation
Source: task (Lisp file)

Function: make-event EVENT-DESIGNATOR &optional REASON SYNC

Package: cram-language-implementation
Source: task (Lisp file)

Function: make-goal-fun NAME PATTERN DECLARATIONS BODY

Package: cram-language-implementation
Source: goals (Lisp file)

Function: make-message &key (FROM DUM864) (TO DUM865) (CONTENT DUM866)

Package: cram-language-implementation
Source: task (Lisp file)

Function: make-plan-tree-node &key (SEXP DUM0) (PATH DUM1) (PARENT DUM2) (CHILDREN DUM3)

Package: cram-walker
Source: plan-tree (Lisp file)

Function: matching-goal-fun NAME ARGS &optional GOAL-FUNS

Package: cram-language-implementation
Source: goals (Lisp file)

Function: message-content INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task (Lisp file)
Writer: (setf message-content) (function)

Function: (setf message-content) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task (Lisp file)
Reader: message-content (function)

Function: message-from INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task (Lisp file)
Writer: (setf message-from) (function)

Function: (setf message-from) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task (Lisp file)
Reader: message-from (function)

Function: message-p OBJECT

Package: cram-language-implementation
Source: task (Lisp file)

Function: message-to INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task (Lisp file)
Writer: (setf message-to) (function)

Function: (setf message-to) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task (Lisp file)
Reader: message-to (function)

Function: parse-macro NAME LAMBDA-LIST BODY &optional ENV

Calls the implementation specific CLTL2 function.

Package: cram-walker
Source: env (Lisp file)

Function: parse-macro-function FORM ENV

Combines enclose and parse-macro, to return something that can be passed to augment-environment.

Package: cram-walker
Source: env (Lisp file)

Function: partition PREDICATE LIST &key KEY

Equivalent to (VALUES (REMOVE-IF-NOT P L) (REMOVE-IF P L)).

Package: cram-language-implementation
Source: utils (Lisp file)

Function: path-next-iteration PATH-PART

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: plan-tree-node-p OBJECT

Package: cram-walker
Source: plan-tree (Lisp file)

Function: propagate-event TASK EVENT

Propagate ‘event’ down to the childs of ‘task’.

Package: cram-language-implementation
Source: task (Lisp file)

Function: recalculate-timeout TIMEOUT START-TIME

Package: cram-language-implementation
Source: fluent (Lisp file)

Function: receive-event &key WAIT

If an event is currently pending, return it, otherwise return NIL.
If ‘wait’ is true, block until an event arises.

Package: cram-language-implementation
Source: task (Lisp file)

Function: register-child-plan CHILD

Package: cram-walker
Source: walker (Lisp file)

Function: register-task-code SEXP FUNCTION &key PATH TASK-TREE REPLACE-REGISTERED

Registers a code as the default code of a specific task tree
node. If the parameter ’replace-registered’ is true, old code is
always overwritten. Returns the node.

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: remove-top-level-task-tree NAME

Removes the task tree for a named top level from the global hash table
where those all named top level task trees. You usually won’t need this, but you can use it to clean up after using named-top-level directly,
e.g. in a test suite.

Package: cram-language-implementation
Source: language (Lisp file)

Function: replace-task-code SEXP FUNCTION PATH &optional TASK-TREE

Adds a code replacement to a specific task tree node.

Package: cram-language-implementation
Source: task-tree (Lisp file)

Function: scheduling-disabled-p

Package: cram-language-implementation
Source: task (Lisp file)

Function: scheduling-enabled-p

Package: cram-language-implementation
Source: task (Lisp file)

Function: seconds-to-internal-time TIMEOUT

Package: cram-language-implementation
Source: task (Lisp file)

Function: send-event TASK EVENT &optional NO-SYNC

Send ‘event’ to ‘task’.
If ‘no-sync’ is true, no synchronization is performed on ‘event’,
the decision to do so is left to the caller.

Package: cram-language-implementation
Source: task (Lisp file)

Function: setup CHILD-TASK PARENT-TASK

Initialize ‘child-task’ for execution.
Also register it as child to ‘parent-task’.

Package: cram-language-implementation
Source: task (Lisp file)

Function: signal-time-quantum-exhausted

Package: cram-language-implementation
Source: task (Lisp file)

Function: synchronize-on-event EVENT CHILD-TASKS

If ‘event’ is a synchronized event, wait until ‘child-tasks’
acted on it.

Package: cram-language-implementation
Source: task (Lisp file)

Function: tag-form-handler FORM

Package: cram-walker
Source: walker (Lisp file)

Function: task-abbreviated-name TASK &optional LENGTH

Package: cram-language-implementation
Source: logging (Lisp file)

Function: task-tree-node-code-replacements INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task-tree (Lisp file)
Writer: (setf task-tree-node-code-replacements) (function)

Function: (setf task-tree-node-code-replacements) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task-tree (Lisp file)
Reader: task-tree-node-code-replacements (function)

Function: task-tree-node-lock INSTANCE

Return whether debug-block represents elsewhere code.

Package: cram-language-implementation
Source: task-tree (Lisp file)
Writer: (setf task-tree-node-lock) (function)

Function: (setf task-tree-node-lock) NEW-VALUE INSTANCE

Package: cram-language-implementation
Source: task-tree (Lisp file)
Reader: task-tree-node-lock (function)

Function: truncate-string STRING MAX-LENGTH

Truncate ‘string’ if its length exceeds ‘max-length’. We truncate
in the middle of the string because start and end are usually
crucial to discriminate the abbreviation.

Package: cram-language-implementation
Source: logging (Lisp file)

Function: unwind-and-continue HANDLERS UNWIND CONTINUATION

Unwind using ‘unwind’, then invoke ‘handlers’, and call
‘continuation’.

Package: cram-language-implementation
Source: task (Lisp file)

Function: unwind-and-teardown STATUS RESULT REASON SYNC

Package: cram-language-implementation
Source: task (Lisp file)

Function: walk-argument ARG ENV

Walk lambda argument (part of an ordinary lambda list). If it is a list of
at least two elements, walk the cadr. Walk nothing else.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-binding B ENV

Walk variable binding like found in let.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-binding-list LIST ENV LET*-STYLE-BINDINGS

Walk list of variable bindings like found in let or let*. If let*-style-bindings is not nil, the bindings are expanded like in a let*.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-block FORM ENV

Walk all but car and cadr.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-cpl-tag FORM ENV

Package: cram-walker
Source: walker (Lisp file)

Function: walk-flet FORM ENV

Walk the function definitions and the walk the body with the functions
added to the environment.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-form FORM ENV

Takes a form and an environment and walkes the form if neccessary, after macroexpanding it fully and considering special cases.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-funcall FORM ENV

Walk all but car.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-function FORM ENV

Walk the cadr. Handle special case of cadr being (lambda () ...), or (setf ...)

Package: cram-walker
Source: walker (Lisp file)

Function: walk-labels FORM ENV

Add the function definitions to the environment, then walk those
definitions and the body.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-lambda FORM ENV

Walk argument list and body.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-let FORM ENV &key LET*-STYLE-BINDINGS

Walk list of bindings and body.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-let* FORM ENV

Package: cram-walker
Source: walker (Lisp file)

Function: walk-list LIST ENV

Walk each element of the list.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-list-of-lambdas LIST ENV

Walk each element like a lambda form.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-load-time-value FORM ENV

Walk the cadr in a nil lexical environment.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-macrolet FORM ENV

Add macro or symbol-macro definitions to the environment and proceed
expanding the body (wrapped in a locally).

Package: cram-walker
Source: walker (Lisp file)

Function: walk-named-lambda FORM ENV

Walk argument list and body.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-ordinary-lambda-list LIST ENV

Walk lambda argument list (ordinary lambda list).

Package: cram-walker
Source: walker (Lisp file)

Function: walk-plan-form FORM ENV

Handles a plan or tag form and creates a node in the plan tree.

Package: cram-walker
Source: walker (Lisp file)

Function: walk-quote FORM ENV

Don’t walk anything

Package: cram-walker
Source: walker (Lisp file)

Function: what-time-is-it KIND

Current timestamp relative to *ZERO-REAL-TIME*, or *ZERO-RUN-TIME*
depending on ‘kind’.

Package: cram-language-implementation
Source: logging (Lisp file)

Function: who-am-i

Either the name of the current task, or of the current thread.

Package: cram-language-implementation
Source: logging (Lisp file)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.2.4 Generic functions

Generic Function: check OBJECT

Package

Methods

Method: check (POLICY policy)

automatically generated reader method

Source: with-policy (Lisp file)

Generic Function: child-tasks TASK

Returns the (currently unsorted) list of child tasks.

Package

Source

task-interface (Lisp file)

Writer

(setf child-tasks) (generic function)

Methods

Method: child-tasks (ABSTRACT-TASK abstract-task)

The list of child tasks.

Source: task (Lisp file)

Generic Function: (setf child-tasks) NEW-VALUE OBJECT

Package

Reader

child-tasks (generic function)

Methods

Method: (setf child-tasks) NEW-VALUE (ABSTRACT-TASK abstract-task)

The list of child tasks.

Source: task (Lisp file)

Generic Function: clean-up OBJECT

Package

Methods

Method: clean-up (POLICY policy)

automatically generated reader method

Source: with-policy (Lisp file)

Generic Function: description OBJECT

Package

Methods

Method: description (POLICY policy)

automatically generated reader method

Source: with-policy (Lisp file)

Generic Function: execute TASK

When the task has been instantiated without a thread function or
the function has not been executed yet, it can be executed with
this method. When ‘ignore-no-parent’ is true, no error message is signaled when *CURRENT-TASK* is unbound.

Package

Source

task-interface (Lisp file)

Methods

Method: execute (NEW-TASK abstract-task) after

Source: task (Lisp file)

Method: execute (NEW-TASK abstract-task)

Source: task (Lisp file)

Method: execute (NEW-TASK abstract-task) around

Source: task (Lisp file)

Method: execute (TASK task) before

Source: task (Lisp file)

Method: execute (TASK abstract-task) before

Source: task (Lisp file)

Generic Function: executed TASK

Returns NIL if the task has not been executed yet.

Package

Source

task-interface (Lisp file)

Methods

Method: executed (TASK abstract-task)

Source: task (Lisp file)

Generic Function: init OBJECT

Package

Methods

Method: init (POLICY policy)

automatically generated reader method

Source: with-policy (Lisp file)

Generic Function: on-begin-execute-tag-task NAME

Package: cram-language
Source: language (Lisp file)
Method Combination: hooks

Generic Function: on-finish-execute-tag-task ID

Package: cram-language
Source: language (Lisp file)
Method Combination: hooks

Generic Function: on-finishing-named-top-level ID

Package: cram-language
Source: language (Lisp file)
Method Combination: hooks

Generic Function: on-finishing-task-execution ID

Package: cram-language
Source: task-tree (Lisp file)
Method Combination: hooks

Generic Function: on-preparing-named-top-level NAME

Package: cram-language
Source: language (Lisp file)
Method Combination: hooks

Generic Function: on-preparing-task-execution NAME LOG-PARAMETERS LOG-PATTERN

Package: cram-language
Source: task-tree (Lisp file)
Method Combination: hooks

Generic Function: on-with-failure-handling-begin CLAUSES

Package: cram-language
Source: failures (Lisp file)
Method Combination: hooks

Generic Function: on-with-failure-handling-end ID

Package: cram-language
Source: failures (Lisp file)
Method Combination: hooks

Generic Function: on-with-failure-handling-handled ID

Package: cram-language
Source: failures (Lisp file)
Method Combination: hooks

Generic Function: on-with-failure-handling-rethrown ID

Package: cram-language
Source: failures (Lisp file)
Method Combination: hooks

Generic Function: on-with-policy-begin NAME PARAMETERS

Package: cram-language
Source: with-policy (Lisp file)
Method Combination: hooks

Generic Function: on-with-policy-end ID SUCCESS

Package: cram-language
Source: with-policy (Lisp file)
Method Combination: hooks

Generic Function: parent-task TASK

Returns the parent task.

Package

Source

task-interface (Lisp file)

Methods

Method: parent-task (ABSTRACT-TASK abstract-task)

The parent task.

Source: task (Lisp file)

Generic Function: policy-name CONDITION

Package

Methods

Method: policy-name (CONDITION policy-condition)

Generic Function: policy-parameters CONDITION

Package

Methods

Method: policy-parameters (CONDITION policy-failure)

Generic Function: recover OBJECT

Package

Methods

Method: recover (POLICY policy)

automatically generated reader method

Source: with-policy (Lisp file)

Generic Function: task-code OBJECT

Package

Methods

Method: task-code (ABSTRACT-TASK abstract-task)

The code of the path.

Source: task (Lisp file)

Generic Function: task-constraints OBJECT

Generic Function: (setf task-constraints) NEW-VALUE OBJECT

Package

Methods

Method: task-constraints (ABSTRACT-TASK abstract-task)

Method: (setf task-constraints) NEW-VALUE (ABSTRACT-TASK abstract-task)

The list of ordering constraint fluents. The task
is not allowed to start running before all fluents
are true.

Source: task (Lisp file)

Generic Function: task-message-queue OBJECT

Package

Methods

Method: task-message-queue (ABSTRACT-TASK abstract-task)

automatically generated reader method

Source: task (Lisp file)

Generic Function: task-name OBJECT

Package

Methods

Method: task-name (ABSTRACT-TASK abstract-task)

The name of the task. Mostly for debugging reasons.
Should also become the name of the thread executing
the task.

Source: task (Lisp file)

Generic Function: update-value FLUENT

Re-calculates the value of the fluent. This method
returns two values, the new value and T if the value actually
changed.

Package

Source

fluent-net (Lisp file)

Methods

Method: update-value (FLUENT fl-net-cacheable-fluent)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.2.5 Conditions

Condition: time-quantum-exhausted

Always signaled with an associated restart CONTINUE-WITH-ADJUSTED-TIME-QUANTUM.

Package: cram-language-implementation
Source: task (Lisp file)
Direct superclasses: condition

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.2.6 Structures

Structure: event

Package

Source

task (Lisp file)

Direct superclasses

structure-object

Direct methods

print-object

Direct slots

Slot: tag

Type: keyword
Initform: (alexandria.0.dev:required-argument ’cram-language-implementation:tag)
Readers: event-tag (function)
Writers: (setf event-tag) (function)

Slot: reason

Type: (or null simple-string)
Readers: event-reason (function)
Writers: (setf event-reason) (function)

Slot: values

Type: list
Readers: event-values (function)
Writers: (setf event-values) (function)

Slot: sync

Type: boolean
Readers: event-sync (function)
Writers: (setf event-sync) (function)

Structure: message

Package

Source

task (Lisp file)

Direct superclasses

structure-object

Direct slots

Slot: from

Type: cram-language-implementation::abstract-task
Initform: (alexandria.0.dev:required-argument ’cram-language-implementation::from)
Readers: message-from (function)
Writers: (setf message-from) (function)

Slot: to

Type: cram-language-implementation::abstract-task
Initform: (alexandria.0.dev:required-argument ’cram-language-implementation::to)
Readers: message-to (function)
Writers: (setf message-to) (function)

Slot: content

Type: cram-language-implementation::event
Initform: (alexandria.0.dev:required-argument ’cram-language-implementation::content)
Readers: message-content (function)
Writers: (setf message-content) (function)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.2.7 Classes

Class: abstract-task

Package

Source

task (Lisp file)

Direct superclasses

standard-object

Direct subclasses

task (class)
toplevel-task (class)

Direct methods

execute (method)
execute (method)
execute (method)
execute (method)
evaporate (method)
wake-up (method)
suspend (method)
join-task (method)
result (method)
executed (method)
print-object
initialize-instance
task-message-queue (method)
task-constraints
task-constraints (method)
task-code (method)
task-path (method)
status (method)
child-tasks
child-tasks (method)
parent-task (method)
task-name (method)
name (method)

Direct slots

Slot: name

The name of the task. Mostly for debugging reasons.
Should also become the name of the thread executing
the task.

Type

(or symbol string null)

Initargs

:name

Initform

(gensym "unknown-")

Readers

name (generic function)
task-name (generic function)

Slot: thread

The internal thread object of the lisp implementation.

Type: (or sb-thread:thread null)

Slot: parent-task

The parent task.

Type: (or cram-language-implementation::abstract-task null)
Readers: parent-task (generic function)

Slot: child-tasks

The list of child tasks.

Type: (cram-language-implementation::list-of cram-language-implementation::abstract-task)
Initform: (list)
Readers: child-tasks (generic function)
Writers: (setf child-tasks) (generic function)

Slot: status

Fluent indicating the task status.
Cf. STATUS-INDICATOR.

Type: cram-language-implementation:fluent
Readers: status (generic function)

Slot: result

The result of the task. When it terminates
normally, the slot contains the list of return
values. For evaporated tasks, it contains nil and
for failed tasks, it contains the condition
object.

Type: (or list null condition)

Slot: thread-fun

The function of the task.

Type: (or function null)
Initargs: :thread-fun

Slot: path

The path of the task.

Type: list
Initargs: :path
Initform: cram-language-implementation:*current-path*
Readers: task-path (generic function)

Slot: code

The code of the path.

Type: (or cram-language-implementation:code null)
Initform: (and cram-language-implementation::*current-task-tree-node* (cram-language-implementation:task-tree-node-code cram-language-implementation::*current-task-tree-node*))
Readers: task-code (generic function)

Slot: constraints

The list of ordering constraint fluents. The task
is not allowed to start running before all fluents
are true.

Type: (cram-language-implementation::list-of cram-language-implementation:fluent)
Initform: (list)
Readers: task-constraints (generic function)
Writers: (setf task-constraints) (generic function)

Slot: message-queue

Type: sb-concurrency:mailbox
Initform: (sb-concurrency:make-mailbox)
Readers: task-message-queue (generic function)

Class: fl-cacheable-value-mixin

This mixin indicates that the value of this fluent
can be cached, i.e. it doesn’t change wihtout sending a pulse.

Package

Source

fluent-interface (Lisp file)

Direct superclasses

standard-object

Direct subclasses

value-fluent (class)
fl-net-cacheable-fluent (class)

Class: fl-net-cacheable-fluent

Package

Source

fluent-net (Lisp file)

Direct superclasses

fl-printable-mixin (class)
fl-cacheable-value-mixin (class)
fluent (class)

Direct methods

pulse (method)
value (method)
update-value (method)

Direct slots

Slot: calculate-value-fun

Initargs: :calculate-value-fun

Slot: value

The cached value of this
fluent network.

Initargs: :value

Class: fl-net-fluent

Class of fluent networks that directly depend on
fluents that are not cachable.

Package

Source

fluent-net (Lisp file)

Direct superclasses

fluent (class)

Direct methods

value (method)

Direct slots

Slot: calculate-value-fun

The function object to
calculate the value of the fluent.

Initargs: :calculate-value-fun

Class: fl-printable-mixin

This mixin indicates the value of the fluent can be
printed by the pretty-printer. This is not the case for PULSE
fluents, for instance.

Package

Source

fluent-interface (Lisp file)

Direct superclasses

standard-object

Direct subclasses

value-fluent (class)
fl-net-cacheable-fluent (class)

Class: policy

Package

Source

with-policy (Lisp file)

Direct superclasses

standard-object

Direct methods

clean-up (method)
recover (method)
check (method)
init (method)
description (method)
parameters (method)
name (method)

Direct slots

Slot: name

Initargs: :name
Readers: name (generic function)

Slot: parameters

Initargs: :parameters
Readers: parameters (generic function)

Slot: description

Initargs: :description
Readers: description (generic function)

Slot: init

Initargs: :init
Readers: init (generic function)

Slot: check

Initargs: :check
Readers: check (generic function)

Slot: recover

Initargs: :recover
Readers: recover (generic function)

Slot: clean-up

Initargs: :clean-up
Readers: clean-up (generic function)

Class: pulse-fluent

Package

Source

pulse-fluent (Lisp file)

Direct superclasses

fluent (class)

Direct methods

value (method)

Direct slots

Slot: handle-missed-pulses

Initargs: :handle-missed-pulses

Slot: processed-pulse-count

# pulses we have processed
so far. We don’t want to use pulse-count
since it is used in wait-for to determine if something changed. This slot is used to
compute the value.

Initargs: :processed-pulse-count
Initform: 0

Slot: reference-pulse-count

The pulse count of the
fluent we are monitoring.

Initargs: :reference-pulse-count
Initform: 0

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

5.2.8 Types

Type: continuation

Package: cram-language-implementation
Source: task (Lisp file)

Type: event-designator

An event-designator is a either a keyword naming the event, or a
list whose car is such a keyword and whose cdr is a list of
values. The list of values represent additional parameters of the
event and can be destructured in DESTRUCTURE-EVENT.

Package: cram-language-implementation
Source: task (Lisp file)

Type: list-of TYPE

Package: cram-language-implementation
Source: utils (Lisp file)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

A. Indexes

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

A.1 Concepts

Jump to:	C F L M S

	Index Entry	Section

C
	`cram-language.asd`	3.1.1 `cram-language.asd`

F
	File, Lisp, `cram-language.asd`	3.1.1 `cram-language.asd`
	File, Lisp, `src/default-policies.lisp`	3.1.8 `src/default-policies.lisp`
	File, Lisp, `src/fluent-interface.lisp`	3.1.5 `src/fluent-interface.lisp`
	File, Lisp, `src/fluent-operators.lisp`	3.1.24 `src/fluent-operators.lisp`
	File, Lisp, `src/fluents/fluent-net.lisp`	3.1.14 `src/fluents/fluent-net.lisp`
	File, Lisp, `src/fluents/fluent.lisp`	3.1.12 `src/fluents/fluent.lisp`
	File, Lisp, `src/fluents/pulse-fluent.lisp`	3.1.15 `src/fluents/pulse-fluent.lisp`
	File, Lisp, `src/fluents/value-fluent.lisp`	3.1.13 `src/fluents/value-fluent.lisp`
	File, Lisp, `src/goals.lisp`	3.1.23 `src/goals.lisp`
	File, Lisp, `src/language.lisp`	3.1.21 `src/language.lisp`
	File, Lisp, `src/logging.lisp`	3.1.6 `src/logging.lisp`
	File, Lisp, `src/packages.lisp`	3.1.2 `src/packages.lisp`
	File, Lisp, `src/plans.lisp`	3.1.22 `src/plans.lisp`
	File, Lisp, `src/sbcl-hotpatches.lisp`	3.1.26 `src/sbcl-hotpatches.lisp`
	File, Lisp, `src/swank-indentation.lisp`	3.1.25 `src/swank-indentation.lisp`
	File, Lisp, `src/task-interface.lisp`	3.1.4 `src/task-interface.lisp`
	File, Lisp, `src/tasks/failures.lisp`	3.1.9 `src/tasks/failures.lisp`
	File, Lisp, `src/tasks/task-tree.lisp`	3.1.11 `src/tasks/task-tree.lisp`
	File, Lisp, `src/tasks/task.lisp`	3.1.10 `src/tasks/task.lisp`
	File, Lisp, `src/utils.lisp`	3.1.3 `src/utils.lisp`
	File, Lisp, `src/walker/env-impl-specific.lisp`	3.1.17 `src/walker/env-impl-specific.lisp`
	File, Lisp, `src/walker/env.lisp`	3.1.16 `src/walker/env.lisp`
	File, Lisp, `src/walker/interface.lisp`	3.1.20 `src/walker/interface.lisp`
	File, Lisp, `src/walker/plan-tree.lisp`	3.1.18 `src/walker/plan-tree.lisp`
	File, Lisp, `src/walker/walker.lisp`	3.1.19 `src/walker/walker.lisp`
	File, Lisp, `src/with-policy.lisp`	3.1.7 `src/with-policy.lisp`

L
	Lisp File, `cram-language.asd`	3.1.1 `cram-language.asd`
	Lisp File, `src/default-policies.lisp`	3.1.8 `src/default-policies.lisp`
	Lisp File, `src/fluent-interface.lisp`	3.1.5 `src/fluent-interface.lisp`
	Lisp File, `src/fluent-operators.lisp`	3.1.24 `src/fluent-operators.lisp`
	Lisp File, `src/fluents/fluent-net.lisp`	3.1.14 `src/fluents/fluent-net.lisp`
	Lisp File, `src/fluents/fluent.lisp`	3.1.12 `src/fluents/fluent.lisp`
	Lisp File, `src/fluents/pulse-fluent.lisp`	3.1.15 `src/fluents/pulse-fluent.lisp`
	Lisp File, `src/fluents/value-fluent.lisp`	3.1.13 `src/fluents/value-fluent.lisp`
	Lisp File, `src/goals.lisp`	3.1.23 `src/goals.lisp`
	Lisp File, `src/language.lisp`	3.1.21 `src/language.lisp`
	Lisp File, `src/logging.lisp`	3.1.6 `src/logging.lisp`
	Lisp File, `src/packages.lisp`	3.1.2 `src/packages.lisp`
	Lisp File, `src/plans.lisp`	3.1.22 `src/plans.lisp`
	Lisp File, `src/sbcl-hotpatches.lisp`	3.1.26 `src/sbcl-hotpatches.lisp`
	Lisp File, `src/swank-indentation.lisp`	3.1.25 `src/swank-indentation.lisp`
	Lisp File, `src/task-interface.lisp`	3.1.4 `src/task-interface.lisp`
	Lisp File, `src/tasks/failures.lisp`	3.1.9 `src/tasks/failures.lisp`
	Lisp File, `src/tasks/task-tree.lisp`	3.1.11 `src/tasks/task-tree.lisp`
	Lisp File, `src/tasks/task.lisp`	3.1.10 `src/tasks/task.lisp`
	Lisp File, `src/utils.lisp`	3.1.3 `src/utils.lisp`
	Lisp File, `src/walker/env-impl-specific.lisp`	3.1.17 `src/walker/env-impl-specific.lisp`
	Lisp File, `src/walker/env.lisp`	3.1.16 `src/walker/env.lisp`
	Lisp File, `src/walker/interface.lisp`	3.1.20 `src/walker/interface.lisp`
	Lisp File, `src/walker/plan-tree.lisp`	3.1.18 `src/walker/plan-tree.lisp`
	Lisp File, `src/walker/walker.lisp`	3.1.19 `src/walker/walker.lisp`
	Lisp File, `src/with-policy.lisp`	3.1.7 `src/with-policy.lisp`

M
	Module, `src/`	2.1 `src/`
	Module, `src/fluents/`	2.3 `src/fluents/`
	Module, `src/tasks/`	2.2 `src/tasks/`
	Module, `src/walker/`	2.4 `src/walker/`

S
	`src/`	2.1 `src/`
	`src/default-policies.lisp`	3.1.8 `src/default-policies.lisp`
	`src/fluent-interface.lisp`	3.1.5 `src/fluent-interface.lisp`
	`src/fluent-operators.lisp`	3.1.24 `src/fluent-operators.lisp`
	`src/fluents/`	2.3 `src/fluents/`
	`src/fluents/fluent-net.lisp`	3.1.14 `src/fluents/fluent-net.lisp`
	`src/fluents/fluent.lisp`	3.1.12 `src/fluents/fluent.lisp`
	`src/fluents/pulse-fluent.lisp`	3.1.15 `src/fluents/pulse-fluent.lisp`
	`src/fluents/value-fluent.lisp`	3.1.13 `src/fluents/value-fluent.lisp`
	`src/goals.lisp`	3.1.23 `src/goals.lisp`
	`src/language.lisp`	3.1.21 `src/language.lisp`
	`src/logging.lisp`	3.1.6 `src/logging.lisp`
	`src/packages.lisp`	3.1.2 `src/packages.lisp`
	`src/plans.lisp`	3.1.22 `src/plans.lisp`
	`src/sbcl-hotpatches.lisp`	3.1.26 `src/sbcl-hotpatches.lisp`
	`src/swank-indentation.lisp`	3.1.25 `src/swank-indentation.lisp`
	`src/task-interface.lisp`	3.1.4 `src/task-interface.lisp`
	`src/tasks/`	2.2 `src/tasks/`
	`src/tasks/failures.lisp`	3.1.9 `src/tasks/failures.lisp`
	`src/tasks/task-tree.lisp`	3.1.11 `src/tasks/task-tree.lisp`
	`src/tasks/task.lisp`	3.1.10 `src/tasks/task.lisp`
	`src/utils.lisp`	3.1.3 `src/utils.lisp`
	`src/walker/`	2.4 `src/walker/`
	`src/walker/env-impl-specific.lisp`	3.1.17 `src/walker/env-impl-specific.lisp`
	`src/walker/env.lisp`	3.1.16 `src/walker/env.lisp`
	`src/walker/interface.lisp`	3.1.20 `src/walker/interface.lisp`
	`src/walker/plan-tree.lisp`	3.1.18 `src/walker/plan-tree.lisp`
	`src/walker/walker.lisp`	3.1.19 `src/walker/walker.lisp`
	`src/with-policy.lisp`	3.1.7 `src/with-policy.lisp`

Jump to:	C F L M S

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

A.2 Functions

Jump to:	% ( * + - / < = > A C D E F G I J K L M N O P R S T U V W

	Index Entry	Section

%
	`%define-log-tags`	5.2.3 Functions
	`%fail`	5.2.3 Functions
	`%log-event`	5.2.3 Functions
	`%make-event`	5.2.3 Functions
	`%teardown`	5.2.3 Functions
	`%timed-wait-for`	5.2.3 Functions
	`%unwind-on-suspension`	5.2.3 Functions

(
	`(`	5.1.3 Functions
	`(`	5.1.3 Functions
	`(`	5.1.3 Functions
	`(`	5.1.3 Functions
	`(`	5.1.3 Functions
	`(`	5.1.3 Functions
	`(`	5.1.3 Functions
	`(`	5.1.3 Functions
	`(`	5.1.3 Functions
	`(`	5.1.3 Functions
	`(`	5.1.3 Functions
	`(`	5.1.3 Functions
	`(`	5.1.4 Generic functions
	`(`	5.1.4 Generic functions
	`(`	5.2.3 Functions
	`(`	5.2.3 Functions
	`(`	5.2.3 Functions
	`(`	5.2.3 Functions
	`(`	5.2.3 Functions
	`(`	5.2.3 Functions
	`(`	5.2.3 Functions
	`(`	5.2.3 Functions
	`(`	5.2.3 Functions
	`(`	5.2.3 Functions
	`(`	5.2.4 Generic functions
	`(`	5.2.4 Generic functions
	`(`	5.2.4 Generic functions
	`(`	5.2.4 Generic functions

*
	`*`	5.1.3 Functions

+
	`+`	5.1.3 Functions

-
	`-`	5.1.3 Functions

/
	`/`	5.1.3 Functions

<
	`<`	5.1.3 Functions

=
	`=`	5.1.3 Functions

>
	`>`	5.1.3 Functions

A
	`adjust-time-quantum`	5.2.3 Functions
	`assert-status`	5.2.3 Functions
	`aug-env`	5.2.3 Functions
	`augment-environment`	5.2.3 Functions

C
	`call-as-fluent-operator`	5.2.3 Functions
	`call-goal`	5.2.3 Functions
	`call-on-suspension`	5.2.3 Functions
	`call-with-event-loop`	5.2.3 Functions
	`call-with-scheduling`	5.2.3 Functions
	`call-without-scheduling`	5.2.3 Functions
	`change-status`	5.2.3 Functions
	`check`	5.2.4 Generic functions
	`check`	5.2.4 Generic functions
	`check-time-quantum`	5.2.3 Functions
	`child-tasks`	5.2.4 Generic functions
	`child-tasks`	5.2.4 Generic functions
	`clean-up`	5.2.4 Generic functions
	`clean-up`	5.2.4 Generic functions
	`clear-saved-tasks`	5.2.3 Functions
	`clear-tasks`	5.1.3 Functions
	`code-function`	5.1.3 Functions
	`code-p`	5.2.3 Functions
	`code-parameters`	5.1.3 Functions
	`code-sexp`	5.1.3 Functions
	`code-task`	5.1.3 Functions
	`coerce-to-condition`	5.2.3 Functions
	`composite-failures`	5.1.4 Generic functions
	`composite-failures`	5.1.4 Generic functions
	`continue-with-adjusted-time-quantum`	5.2.3 Functions
	`copy-code`	5.2.3 Functions
	`copy-event`	5.2.3 Functions
	`copy-message`	5.2.3 Functions
	`copy-plan-tree-node`	5.2.3 Functions
	`copy-task-tree-node`	5.2.3 Functions
	`current-task`	5.1.3 Functions

D
	`declare-goal`	5.1.2 Macros
	`def-cpl-parameter`	5.1.2 Macros
	`def-cram-function`	5.1.2 Macros
	`def-fluent-operator`	5.2.2 Macros
	`def-goal`	5.1.2 Macros
	`def-plan`	5.1.2 Macros
	`def-plan-macro`	5.2.2 Macros
	`def-top-level-cram-function`	5.1.2 Macros
	`def-top-level-plan`	5.1.2 Macros
	`define-fluent-net-wrapper`	5.2.2 Macros
	`define-log-tags`	5.2.2 Macros
	`define-policy`	5.1.2 Macros
	`define-task-variable`	5.1.2 Macros
	`describe-goal`	5.1.3 Functions
	`description`	5.2.4 Generic functions
	`description`	5.2.4 Generic functions
	`destructure-event`	5.2.2 Macros

E
	`enclose`	5.2.3 Functions
	`ensure-tree-node`	5.2.3 Functions
	`envelop-error`	5.1.4 Generic functions
	`envelop-error`	5.1.4 Generic functions
	`eq`	5.1.3 Functions
	`eql`	5.1.3 Functions
	`evaporate`	5.1.4 Generic functions
	`evaporate`	5.1.4 Generic functions
	`event-loop`	5.2.3 Functions
	`event-p`	5.2.3 Functions
	`event-reason`	5.2.3 Functions
	`event-sync`	5.2.3 Functions
	`event-tag`	5.2.3 Functions
	`event-values`	5.2.3 Functions
	`execute`	5.2.4 Generic functions
	`execute`	5.2.4 Generic functions
	`execute`	5.2.4 Generic functions
	`execute`	5.2.4 Generic functions
	`execute`	5.2.4 Generic functions
	`execute`	5.2.4 Generic functions
	`execute-task-tree-node`	5.2.3 Functions
	`executed`	5.2.4 Generic functions
	`executed`	5.2.4 Generic functions
	`expand-plan`	5.1.3 Functions
	`extend-path`	5.2.3 Functions

F
	`fail`	5.1.3 Functions
	`filter-task-tree`	5.1.3 Functions
	`find-plan-node`	5.1.3 Functions
	`fl*`	5.1.3 Functions
	`fl+`	5.1.3 Functions
	`fl-`	5.1.3 Functions
	`fl-and`	5.1.3 Functions
	`fl-apply`	5.1.3 Functions
	`fl-eq`	5.1.3 Functions
	`fl-eql`	5.1.3 Functions
	`fl-funcall`	5.1.3 Functions
	`fl-member`	5.2.3 Functions
	`fl-not`	5.1.3 Functions
	`fl-or`	5.1.3 Functions
	`fl-pulsed`	5.1.3 Functions
	`fl-value-changed`	5.1.3 Functions
	`fl/`	5.1.3 Functions
	`fl<`	5.1.3 Functions
	`fl=`	5.1.3 Functions
	`fl>`	5.1.3 Functions
	`flatten-task-tree`	5.1.3 Functions
	`float-/`	5.2.3 Functions
	`format-gensym`	5.2.3 Functions
	`Function, %define-log-tags`	5.2.3 Functions
	`Function, %fail`	5.2.3 Functions
	`Function, %log-event`	5.2.3 Functions
	`Function, %make-event`	5.2.3 Functions
	`Function, %teardown`	5.2.3 Functions
	`Function, %timed-wait-for`	5.2.3 Functions
	`Function, %unwind-on-suspension`	5.2.3 Functions
	`Function, (setf code-function)`	5.1.3 Functions
	`Function, (setf code-parameters)`	5.1.3 Functions
	`Function, (setf code-sexp)`	5.1.3 Functions
	`Function, (setf code-task)`	5.1.3 Functions
	`Function, (setf event-reason)`	5.2.3 Functions
	`Function, (setf event-sync)`	5.2.3 Functions
	`Function, (setf event-tag)`	5.2.3 Functions
	`Function, (setf event-values)`	5.2.3 Functions
	`Function, (setf get-alist)`	5.2.3 Functions
	`Function, (setf message-content)`	5.2.3 Functions
	`Function, (setf message-from)`	5.2.3 Functions
	`Function, (setf message-to)`	5.2.3 Functions
	`Function, (setf plan-tree-node-children)`	5.1.3 Functions
	`Function, (setf plan-tree-node-parent)`	5.1.3 Functions
	`Function, (setf plan-tree-node-path)`	5.1.3 Functions
	`Function, (setf plan-tree-node-sexp)`	5.1.3 Functions
	`Function, (setf task-tree-node-children)`	5.1.3 Functions
	`Function, (setf task-tree-node-code)`	5.1.3 Functions
	`Function, (setf task-tree-node-code-replacements)`	5.2.3 Functions
	`Function, (setf task-tree-node-lock)`	5.2.3 Functions
	`Function, (setf task-tree-node-parent)`	5.1.3 Functions
	`Function, (setf task-tree-node-path)`	5.1.3 Functions
	`Function, *`	5.1.3 Functions
	`Function, +`	5.1.3 Functions
	`Function, -`	5.1.3 Functions
	`Function, /`	5.1.3 Functions
	`Function, <`	5.1.3 Functions
	`Function, =`	5.1.3 Functions
	`Function, >`	5.1.3 Functions
	`Function, adjust-time-quantum`	5.2.3 Functions
	`Function, assert-status`	5.2.3 Functions
	`Function, aug-env`	5.2.3 Functions
	`Function, augment-environment`	5.2.3 Functions
	`Function, call-as-fluent-operator`	5.2.3 Functions
	`Function, call-goal`	5.2.3 Functions
	`Function, call-on-suspension`	5.2.3 Functions
	`Function, call-with-event-loop`	5.2.3 Functions
	`Function, call-with-scheduling`	5.2.3 Functions
	`Function, call-without-scheduling`	5.2.3 Functions
	`Function, change-status`	5.2.3 Functions
	`Function, check-time-quantum`	5.2.3 Functions
	`Function, clear-saved-tasks`	5.2.3 Functions
	`Function, clear-tasks`	5.1.3 Functions
	`Function, code-function`	5.1.3 Functions
	`Function, code-p`	5.2.3 Functions
	`Function, code-parameters`	5.1.3 Functions
	`Function, code-sexp`	5.1.3 Functions
	`Function, code-task`	5.1.3 Functions
	`Function, coerce-to-condition`	5.2.3 Functions
	`Function, continue-with-adjusted-time-quantum`	5.2.3 Functions
	`Function, copy-code`	5.2.3 Functions
	`Function, copy-event`	5.2.3 Functions
	`Function, copy-message`	5.2.3 Functions
	`Function, copy-plan-tree-node`	5.2.3 Functions
	`Function, copy-task-tree-node`	5.2.3 Functions
	`Function, current-task`	5.1.3 Functions
	`Function, describe-goal`	5.1.3 Functions
	`Function, enclose`	5.2.3 Functions
	`Function, ensure-tree-node`	5.2.3 Functions
	`Function, eq`	5.1.3 Functions
	`Function, eql`	5.1.3 Functions
	`Function, event-loop`	5.2.3 Functions
	`Function, event-p`	5.2.3 Functions
	`Function, event-reason`	5.2.3 Functions
	`Function, event-sync`	5.2.3 Functions
	`Function, event-tag`	5.2.3 Functions
	`Function, event-values`	5.2.3 Functions
	`Function, execute-task-tree-node`	5.2.3 Functions
	`Function, expand-plan`	5.1.3 Functions
	`Function, extend-path`	5.2.3 Functions
	`Function, fail`	5.1.3 Functions
	`Function, filter-task-tree`	5.1.3 Functions
	`Function, find-plan-node`	5.1.3 Functions
	`Function, fl*`	5.1.3 Functions
	`Function, fl+`	5.1.3 Functions
	`Function, fl-`	5.1.3 Functions
	`Function, fl-and`	5.1.3 Functions
	`Function, fl-apply`	5.1.3 Functions
	`Function, fl-eq`	5.1.3 Functions
	`Function, fl-eql`	5.1.3 Functions
	`Function, fl-funcall`	5.1.3 Functions
	`Function, fl-member`	5.2.3 Functions
	`Function, fl-not`	5.1.3 Functions
	`Function, fl-or`	5.1.3 Functions
	`Function, fl-pulsed`	5.1.3 Functions
	`Function, fl-value-changed`	5.1.3 Functions
	`Function, fl/`	5.1.3 Functions
	`Function, fl<`	5.1.3 Functions
	`Function, fl=`	5.1.3 Functions
	`Function, fl>`	5.1.3 Functions
	`Function, flatten-task-tree`	5.1.3 Functions
	`Function, float-/`	5.2.3 Functions
	`Function, format-gensym`	5.2.3 Functions
	`Function, get-alist`	5.2.3 Functions
	`Function, get-top-level-task-tree`	5.1.3 Functions
	`Function, goal-task-tree-node-goal`	5.1.3 Functions
	`Function, goal-task-tree-node-p`	5.1.3 Functions
	`Function, goal-task-tree-node-parameter-bindings`	5.1.3 Functions
	`Function, goal-task-tree-node-pattern`	5.1.3 Functions
	`Function, inherit-parent-value`	5.2.3 Functions
	`Function, invoke-event-loop`	5.2.3 Functions
	`Function, kill-saved-tasks`	5.2.3 Functions
	`Function, lambda-list-keyword-p`	5.2.3 Functions
	`Function, list-active-log-tags`	5.1.3 Functions
	`Function, list-available-log-tags`	5.1.3 Functions
	`Function, list-saved-tasks`	5.1.3 Functions
	`Function, log-disable`	5.1.3 Functions
	`Function, log-enable`	5.1.3 Functions
	`Function, log-gc-event`	5.2.3 Functions
	`Function, log-mask`	5.2.3 Functions
	`Function, log-set`	5.1.3 Functions
	`Function, log-tag-offset`	5.2.3 Functions
	`Function, logfmt`	5.2.3 Functions
	`Function, make-code`	5.2.3 Functions
	`Function, make-dummy-task`	5.2.3 Functions
	`Function, make-event`	5.2.3 Functions
	`Function, make-fluent`	5.1.3 Functions
	`Function, make-goal-fun`	5.2.3 Functions
	`Function, make-message`	5.2.3 Functions
	`Function, make-plan-tree-node`	5.2.3 Functions
	`Function, make-task`	5.1.3 Functions
	`Function, make-task-tree-node`	5.1.3 Functions
	`Function, matching-goal-fun`	5.2.3 Functions
	`Function, message-content`	5.2.3 Functions
	`Function, message-from`	5.2.3 Functions
	`Function, message-p`	5.2.3 Functions
	`Function, message-to`	5.2.3 Functions
	`Function, named-policy`	5.1.3 Functions
	`Function, not`	5.1.3 Functions
	`Function, parse-macro`	5.2.3 Functions
	`Function, parse-macro-function`	5.2.3 Functions
	`Function, partition`	5.2.3 Functions
	`Function, path-next-iteration`	5.2.3 Functions
	`Function, peek-value`	5.1.3 Functions
	`Function, plan-tree-node-children`	5.1.3 Functions
	`Function, plan-tree-node-p`	5.2.3 Functions
	`Function, plan-tree-node-parent`	5.1.3 Functions
	`Function, plan-tree-node-path`	5.1.3 Functions
	`Function, plan-tree-node-sexp`	5.1.3 Functions
	`Function, propagate-event`	5.2.3 Functions
	`Function, pulsed`	5.1.3 Functions
	`Function, recalculate-timeout`	5.2.3 Functions
	`Function, receive-event`	5.2.3 Functions
	`Function, register-child-plan`	5.2.3 Functions
	`Function, register-goal`	5.1.3 Functions
	`Function, register-task-code`	5.2.3 Functions
	`Function, remove-top-level-task-tree`	5.2.3 Functions
	`Function, replace-task-code`	5.2.3 Functions
	`Function, scheduling-disabled-p`	5.2.3 Functions
	`Function, scheduling-enabled-p`	5.2.3 Functions
	`Function, seconds-to-internal-time`	5.2.3 Functions
	`Function, send-event`	5.2.3 Functions
	`Function, setup`	5.2.3 Functions
	`Function, signal-time-quantum-exhausted`	5.2.3 Functions
	`Function, sleep`	5.1.3 Functions
	`Function, sleep*`	5.1.3 Functions
	`Function, stale-task-tree-node-p`	5.1.3 Functions
	`Function, sub-task`	5.1.3 Functions
	`Function, synchronize-on-event`	5.2.3 Functions
	`Function, tag-form-handler`	5.2.3 Functions
	`Function, task`	5.1.3 Functions
	`Function, task-abbreviated-name`	5.2.3 Functions
	`Function, task-alive`	5.1.3 Functions
	`Function, task-dead`	5.1.3 Functions
	`Function, task-dead-p`	5.1.3 Functions
	`Function, task-done-p`	5.1.3 Functions
	`Function, task-failed-p`	5.1.3 Functions
	`Function, task-running-p`	5.1.3 Functions
	`Function, task-tree-node`	5.1.3 Functions
	`Function, task-tree-node-children`	5.1.3 Functions
	`Function, task-tree-node-code`	5.1.3 Functions
	`Function, task-tree-node-code-replacements`	5.2.3 Functions
	`Function, task-tree-node-effective-code`	5.1.3 Functions
	`Function, task-tree-node-lock`	5.2.3 Functions
	`Function, task-tree-node-p`	5.1.3 Functions
	`Function, task-tree-node-parameters`	5.1.3 Functions
	`Function, task-tree-node-parent`	5.1.3 Functions
	`Function, task-tree-node-path`	5.1.3 Functions
	`Function, task-tree-node-result`	5.1.3 Functions
	`Function, task-tree-node-status-fluent`	5.1.3 Functions
	`Function, truncate-string`	5.2.3 Functions
	`Function, tv-closure`	5.1.3 Functions
	`Function, unwind-and-continue`	5.2.3 Functions
	`Function, unwind-and-teardown`	5.2.3 Functions
	`Function, walk-argument`	5.2.3 Functions
	`Function, walk-binding`	5.2.3 Functions
	`Function, walk-binding-list`	5.2.3 Functions
	`Function, walk-block`	5.2.3 Functions
	`Function, walk-cpl-tag`	5.2.3 Functions
	`Function, walk-flet`	5.2.3 Functions
	`Function, walk-form`	5.2.3 Functions
	`Function, walk-funcall`	5.2.3 Functions
	`Function, walk-function`	5.2.3 Functions
	`Function, walk-labels`	5.2.3 Functions
	`Function, walk-lambda`	5.2.3 Functions
	`Function, walk-let`	5.2.3 Functions
	`Function, walk-let*`	5.2.3 Functions
	`Function, walk-list`	5.2.3 Functions
	`Function, walk-list-of-lambdas`	5.2.3 Functions
	`Function, walk-load-time-value`	5.2.3 Functions
	`Function, walk-macrolet`	5.2.3 Functions
	`Function, walk-named-lambda`	5.2.3 Functions
	`Function, walk-ordinary-lambda-list`	5.2.3 Functions
	`Function, walk-plan-form`	5.2.3 Functions
	`Function, walk-quote`	5.2.3 Functions
	`Function, walk-with-tag-handler`	5.1.3 Functions
	`Function, what-time-is-it`	5.2.3 Functions
	`Function, who-am-i`	5.2.3 Functions

G
	`Generic Function, (setf child-tasks)`	5.2.4 Generic functions
	`Generic Function, (setf task-constraints)`	5.2.4 Generic functions
	`Generic Function, (setf value)`	5.1.4 Generic functions
	`Generic Function, check`	5.2.4 Generic functions
	`Generic Function, child-tasks`	5.2.4 Generic functions
	`Generic Function, clean-up`	5.2.4 Generic functions
	`Generic Function, composite-failures`	5.1.4 Generic functions
	`Generic Function, description`	5.2.4 Generic functions
	`Generic Function, envelop-error`	5.1.4 Generic functions
	`Generic Function, evaporate`	5.1.4 Generic functions
	`Generic Function, execute`	5.2.4 Generic functions
	`Generic Function, executed`	5.2.4 Generic functions
	`Generic Function, get-update-callback`	5.1.4 Generic functions
	`Generic Function, init`	5.2.4 Generic functions
	`Generic Function, join-task`	5.1.4 Generic functions
	`Generic Function, name`	5.1.4 Generic functions
	`Generic Function, on-begin-execute-tag-task`	5.2.4 Generic functions
	`Generic Function, on-def-top-level-plan-hook`	5.1.4 Generic functions
	`Generic Function, on-fail`	5.1.4 Generic functions
	`Generic Function, on-finish-execute-tag-task`	5.2.4 Generic functions
	`Generic Function, on-finishing-named-top-level`	5.2.4 Generic functions
	`Generic Function, on-finishing-task-execution`	5.2.4 Generic functions
	`Generic Function, on-make-fluent-hook`	5.1.4 Generic functions
	`Generic Function, on-preparing-named-top-level`	5.2.4 Generic functions
	`Generic Function, on-preparing-task-execution`	5.2.4 Generic functions
	`Generic Function, on-top-level-cleanup-hook`	5.1.4 Generic functions
	`Generic Function, on-top-level-setup-hook`	5.1.4 Generic functions
	`Generic Function, on-with-failure-handling-begin`	5.2.4 Generic functions
	`Generic Function, on-with-failure-handling-end`	5.2.4 Generic functions
	`Generic Function, on-with-failure-handling-handled`	5.2.4 Generic functions
	`Generic Function, on-with-failure-handling-rethrown`	5.2.4 Generic functions
	`Generic Function, on-with-policy-begin`	5.2.4 Generic functions
	`Generic Function, on-with-policy-end`	5.2.4 Generic functions
	`Generic Function, parameters`	5.1.4 Generic functions
	`Generic Function, parent-task`	5.2.4 Generic functions
	`Generic Function, policy-name`	5.2.4 Generic functions
	`Generic Function, policy-parameters`	5.2.4 Generic functions
	`Generic Function, pulse`	5.1.4 Generic functions
	`Generic Function, recover`	5.2.4 Generic functions
	`Generic Function, register-update-callback`	5.1.4 Generic functions
	`Generic Function, remove-update-callback`	5.1.4 Generic functions
	`Generic Function, result`	5.1.4 Generic functions
	`Generic Function, status`	5.1.4 Generic functions
	`Generic Function, suspend`	5.1.4 Generic functions
	`Generic Function, task-code`	5.2.4 Generic functions
	`Generic Function, task-constraints`	5.2.4 Generic functions
	`Generic Function, task-message-queue`	5.2.4 Generic functions
	`Generic Function, task-name`	5.2.4 Generic functions
	`Generic Function, task-path`	5.1.4 Generic functions
	`Generic Function, update-value`	5.2.4 Generic functions
	`Generic Function, value`	5.1.4 Generic functions
	`Generic Function, wait-for`	5.1.4 Generic functions
	`Generic Function, wake-up`	5.1.4 Generic functions
	`get-alist`	5.2.3 Functions
	`get-top-level-task-tree`	5.1.3 Functions
	`get-update-callback`	5.1.4 Generic functions
	`get-update-callback`	5.1.4 Generic functions
	`goal-task-tree-node-goal`	5.1.3 Functions
	`goal-task-tree-node-p`	5.1.3 Functions
	`goal-task-tree-node-parameter-bindings`	5.1.3 Functions
	`goal-task-tree-node-pattern`	5.1.3 Functions

I
	`inherit-parent-value`	5.2.3 Functions
	`init`	5.2.4 Generic functions
	`init`	5.2.4 Generic functions
	`invoke-event-loop`	5.2.3 Functions

J
	`join-task`	5.1.4 Generic functions
	`join-task`	5.1.4 Generic functions

K
	`kill-saved-tasks`	5.2.3 Functions

L
	`lambda-list-keyword-p`	5.2.3 Functions
	`list-active-log-tags`	5.1.3 Functions
	`list-available-log-tags`	5.1.3 Functions
	`list-saved-tasks`	5.1.3 Functions
	`log-block`	5.2.2 Macros
	`log-disable`	5.1.3 Functions
	`log-enable`	5.1.3 Functions
	`log-event`	5.1.2 Macros
	`log-gc-event`	5.2.3 Functions
	`log-mask`	5.2.3 Functions
	`log-set`	5.1.3 Functions
	`log-tag-offset`	5.2.3 Functions
	`logfmt`	5.2.3 Functions
	`logging-enabled-p`	5.1.2 Macros

M
	`Macro, declare-goal`	5.1.2 Macros
	`Macro, def-cpl-parameter`	5.1.2 Macros
	`Macro, def-cram-function`	5.1.2 Macros
	`Macro, def-fluent-operator`	5.2.2 Macros
	`Macro, def-goal`	5.1.2 Macros
	`Macro, def-plan`	5.1.2 Macros
	`Macro, def-plan-macro`	5.2.2 Macros
	`Macro, def-top-level-cram-function`	5.1.2 Macros
	`Macro, def-top-level-plan`	5.1.2 Macros
	`Macro, define-fluent-net-wrapper`	5.2.2 Macros
	`Macro, define-log-tags`	5.2.2 Macros
	`Macro, define-policy`	5.1.2 Macros
	`Macro, define-task-variable`	5.1.2 Macros
	`Macro, destructure-event`	5.2.2 Macros
	`Macro, log-block`	5.2.2 Macros
	`Macro, log-event`	5.1.2 Macros
	`Macro, logging-enabled-p`	5.1.2 Macros
	`Macro, make-policy`	5.1.2 Macros
	`Macro, mapcar-clean`	5.1.2 Macros
	`Macro, named-top-level`	5.2.2 Macros
	`Macro, on-suspension`	5.1.2 Macros
	`Macro, par`	5.1.2 Macros
	`Macro, par-loop`	5.1.2 Macros
	`Macro, partial-order`	5.1.2 Macros
	`Macro, pursue`	5.1.2 Macros
	`Macro, replaceable-function`	5.1.2 Macros
	`Macro, retry-after-suspension`	5.1.2 Macros
	`Macro, seq`	5.1.2 Macros
	`Macro, single-form-progv`	5.2.2 Macros
	`Macro, top-level`	5.1.2 Macros
	`Macro, try-all`	5.1.2 Macros
	`Macro, try-each-in-order`	5.1.2 Macros
	`Macro, try-in-order`	5.1.2 Macros
	`Macro, whenever`	5.1.2 Macros
	`Macro, with-extended-path`	5.2.2 Macros
	`Macro, with-failure-handling`	5.1.2 Macros
	`Macro, with-fluent-locked`	5.2.2 Macros
	`Macro, with-named-policies`	5.1.2 Macros
	`Macro, with-named-policy`	5.1.2 Macros
	`Macro, with-parallel-childs`	5.2.2 Macros
	`Macro, with-policies`	5.1.2 Macros
	`Macro, with-policy`	5.1.2 Macros
	`Macro, with-retry-counters`	5.1.2 Macros
	`Macro, with-scheduling`	5.1.2 Macros
	`Macro, with-shadowed-functions`	5.2.2 Macros
	`Macro, with-tags`	5.1.2 Macros
	`Macro, with-task`	5.2.2 Macros
	`Macro, with-task-suspended`	5.1.2 Macros
	`Macro, with-task-tree-node`	5.1.2 Macros
	`Macro, without-scheduling`	5.1.2 Macros
	`make-code`	5.2.3 Functions
	`make-dummy-task`	5.2.3 Functions
	`make-event`	5.2.3 Functions
	`make-fluent`	5.1.3 Functions
	`make-goal-fun`	5.2.3 Functions
	`make-message`	5.2.3 Functions
	`make-plan-tree-node`	5.2.3 Functions
	`make-policy`	5.1.2 Macros
	`make-task`	5.1.3 Functions
	`make-task-tree-node`	5.1.3 Functions
	`mapcar-clean`	5.1.2 Macros
	`matching-goal-fun`	5.2.3 Functions
	`message-content`	5.2.3 Functions
	`message-from`	5.2.3 Functions
	`message-p`	5.2.3 Functions
	`message-to`	5.2.3 Functions
	`Method, (setf child-tasks)`	5.2.4 Generic functions
	`Method, (setf task-constraints)`	5.2.4 Generic functions
	`Method, (setf value)`	5.1.4 Generic functions
	`Method, check`	5.2.4 Generic functions
	`Method, child-tasks`	5.2.4 Generic functions
	`Method, clean-up`	5.2.4 Generic functions
	`Method, composite-failures`	5.1.4 Generic functions
	`Method, description`	5.2.4 Generic functions
	`Method, envelop-error`	5.1.4 Generic functions
	`Method, evaporate`	5.1.4 Generic functions
	`Method, execute`	5.2.4 Generic functions
	`Method, execute`	5.2.4 Generic functions
	`Method, execute`	5.2.4 Generic functions
	`Method, execute`	5.2.4 Generic functions
	`Method, execute`	5.2.4 Generic functions
	`Method, executed`	5.2.4 Generic functions
	`Method, get-update-callback`	5.1.4 Generic functions
	`Method, init`	5.2.4 Generic functions
	`Method, join-task`	5.1.4 Generic functions
	`Method, name`	5.1.4 Generic functions
	`Method, name`	5.1.4 Generic functions
	`Method, name`	5.1.4 Generic functions
	`Method, parameters`	5.1.4 Generic functions
	`Method, parent-task`	5.2.4 Generic functions
	`Method, policy-name`	5.2.4 Generic functions
	`Method, policy-parameters`	5.2.4 Generic functions
	`Method, pulse`	5.1.4 Generic functions
	`Method, pulse`	5.1.4 Generic functions
	`Method, recover`	5.2.4 Generic functions
	`Method, register-update-callback`	5.1.4 Generic functions
	`Method, remove-update-callback`	5.1.4 Generic functions
	`Method, result`	5.1.4 Generic functions
	`Method, status`	5.1.4 Generic functions
	`Method, suspend`	5.1.4 Generic functions
	`Method, task-code`	5.2.4 Generic functions
	`Method, task-constraints`	5.2.4 Generic functions
	`Method, task-message-queue`	5.2.4 Generic functions
	`Method, task-name`	5.2.4 Generic functions
	`Method, task-path`	5.1.4 Generic functions
	`Method, update-value`	5.2.4 Generic functions
	`Method, value`	5.1.4 Generic functions
	`Method, value`	5.1.4 Generic functions
	`Method, value`	5.1.4 Generic functions
	`Method, value`	5.1.4 Generic functions
	`Method, value`	5.1.4 Generic functions
	`Method, wait-for`	5.1.4 Generic functions
	`Method, wait-for`	5.1.4 Generic functions
	`Method, wake-up`	5.1.4 Generic functions

N
	`name`	5.1.4 Generic functions
	`name`	5.1.4 Generic functions
	`name`	5.1.4 Generic functions
	`name`	5.1.4 Generic functions
	`named-policy`	5.1.3 Functions
	`named-top-level`	5.2.2 Macros
	`not`	5.1.3 Functions

O
	`on-begin-execute-tag-task`	5.2.4 Generic functions
	`on-def-top-level-plan-hook`	5.1.4 Generic functions
	`on-fail`	5.1.4 Generic functions
	`on-finish-execute-tag-task`	5.2.4 Generic functions
	`on-finishing-named-top-level`	5.2.4 Generic functions
	`on-finishing-task-execution`	5.2.4 Generic functions
	`on-make-fluent-hook`	5.1.4 Generic functions
	`on-preparing-named-top-level`	5.2.4 Generic functions
	`on-preparing-task-execution`	5.2.4 Generic functions
	`on-suspension`	5.1.2 Macros
	`on-top-level-cleanup-hook`	5.1.4 Generic functions
	`on-top-level-setup-hook`	5.1.4 Generic functions
	`on-with-failure-handling-begin`	5.2.4 Generic functions
	`on-with-failure-handling-end`	5.2.4 Generic functions
	`on-with-failure-handling-handled`	5.2.4 Generic functions
	`on-with-failure-handling-rethrown`	5.2.4 Generic functions
	`on-with-policy-begin`	5.2.4 Generic functions
	`on-with-policy-end`	5.2.4 Generic functions

P
	`par`	5.1.2 Macros
	`par-loop`	5.1.2 Macros
	`parameters`	5.1.4 Generic functions
	`parameters`	5.1.4 Generic functions
	`parent-task`	5.2.4 Generic functions
	`parent-task`	5.2.4 Generic functions
	`parse-macro`	5.2.3 Functions
	`parse-macro-function`	5.2.3 Functions
	`partial-order`	5.1.2 Macros
	`partition`	5.2.3 Functions
	`path-next-iteration`	5.2.3 Functions
	`peek-value`	5.1.3 Functions
	`plan-tree-node-children`	5.1.3 Functions
	`plan-tree-node-p`	5.2.3 Functions
	`plan-tree-node-parent`	5.1.3 Functions
	`plan-tree-node-path`	5.1.3 Functions
	`plan-tree-node-sexp`	5.1.3 Functions
	`policy-name`	5.2.4 Generic functions
	`policy-name`	5.2.4 Generic functions
	`policy-parameters`	5.2.4 Generic functions
	`policy-parameters`	5.2.4 Generic functions
	`propagate-event`	5.2.3 Functions
	`pulse`	5.1.4 Generic functions
	`pulse`	5.1.4 Generic functions
	`pulse`	5.1.4 Generic functions
	`pulsed`	5.1.3 Functions
	`pursue`	5.1.2 Macros

R
	`recalculate-timeout`	5.2.3 Functions
	`receive-event`	5.2.3 Functions
	`recover`	5.2.4 Generic functions
	`recover`	5.2.4 Generic functions
	`register-child-plan`	5.2.3 Functions
	`register-goal`	5.1.3 Functions
	`register-task-code`	5.2.3 Functions
	`register-update-callback`	5.1.4 Generic functions
	`register-update-callback`	5.1.4 Generic functions
	`remove-top-level-task-tree`	5.2.3 Functions
	`remove-update-callback`	5.1.4 Generic functions
	`remove-update-callback`	5.1.4 Generic functions
	`replace-task-code`	5.2.3 Functions
	`replaceable-function`	5.1.2 Macros
	`result`	5.1.4 Generic functions
	`result`	5.1.4 Generic functions
	`retry-after-suspension`	5.1.2 Macros

S
	`scheduling-disabled-p`	5.2.3 Functions
	`scheduling-enabled-p`	5.2.3 Functions
	`seconds-to-internal-time`	5.2.3 Functions
	`send-event`	5.2.3 Functions
	`seq`	5.1.2 Macros
	`setup`	5.2.3 Functions
	`signal-time-quantum-exhausted`	5.2.3 Functions
	`single-form-progv`	5.2.2 Macros
	`sleep`	5.1.3 Functions
	`sleep*`	5.1.3 Functions
	`stale-task-tree-node-p`	5.1.3 Functions
	`status`	5.1.4 Generic functions
	`status`	5.1.4 Generic functions
	`sub-task`	5.1.3 Functions
	`suspend`	5.1.4 Generic functions
	`suspend`	5.1.4 Generic functions
	`synchronize-on-event`	5.2.3 Functions

T
	`tag-form-handler`	5.2.3 Functions
	`task`	5.1.3 Functions
	`task-abbreviated-name`	5.2.3 Functions
	`task-alive`	5.1.3 Functions
	`task-code`	5.2.4 Generic functions
	`task-code`	5.2.4 Generic functions
	`task-constraints`	5.2.4 Generic functions
	`task-constraints`	5.2.4 Generic functions
	`task-dead`	5.1.3 Functions
	`task-dead-p`	5.1.3 Functions
	`task-done-p`	5.1.3 Functions
	`task-failed-p`	5.1.3 Functions
	`task-message-queue`	5.2.4 Generic functions
	`task-message-queue`	5.2.4 Generic functions
	`task-name`	5.2.4 Generic functions
	`task-name`	5.2.4 Generic functions
	`task-path`	5.1.4 Generic functions
	`task-path`	5.1.4 Generic functions
	`task-running-p`	5.1.3 Functions
	`task-tree-node`	5.1.3 Functions
	`task-tree-node-children`	5.1.3 Functions
	`task-tree-node-code`	5.1.3 Functions
	`task-tree-node-code-replacements`	5.2.3 Functions
	`task-tree-node-effective-code`	5.1.3 Functions
	`task-tree-node-lock`	5.2.3 Functions
	`task-tree-node-p`	5.1.3 Functions
	`task-tree-node-parameters`	5.1.3 Functions
	`task-tree-node-parent`	5.1.3 Functions
	`task-tree-node-path`	5.1.3 Functions
	`task-tree-node-result`	5.1.3 Functions
	`task-tree-node-status-fluent`	5.1.3 Functions
	`top-level`	5.1.2 Macros
	`truncate-string`	5.2.3 Functions
	`try-all`	5.1.2 Macros
	`try-each-in-order`	5.1.2 Macros
	`try-in-order`	5.1.2 Macros
	`tv-closure`	5.1.3 Functions

U
	`unwind-and-continue`	5.2.3 Functions
	`unwind-and-teardown`	5.2.3 Functions
	`update-value`	5.2.4 Generic functions
	`update-value`	5.2.4 Generic functions

V
	`value`	5.1.4 Generic functions
	`value`	5.1.4 Generic functions
	`value`	5.1.4 Generic functions
	`value`	5.1.4 Generic functions
	`value`	5.1.4 Generic functions
	`value`	5.1.4 Generic functions

W
	`wait-for`	5.1.4 Generic functions
	`wait-for`	5.1.4 Generic functions
	`wait-for`	5.1.4 Generic functions
	`wake-up`	5.1.4 Generic functions
	`wake-up`	5.1.4 Generic functions
	`walk-argument`	5.2.3 Functions
	`walk-binding`	5.2.3 Functions
	`walk-binding-list`	5.2.3 Functions
	`walk-block`	5.2.3 Functions
	`walk-cpl-tag`	5.2.3 Functions
	`walk-flet`	5.2.3 Functions
	`walk-form`	5.2.3 Functions
	`walk-funcall`	5.2.3 Functions
	`walk-function`	5.2.3 Functions
	`walk-labels`	5.2.3 Functions
	`walk-lambda`	5.2.3 Functions
	`walk-let`	5.2.3 Functions
	`walk-let*`	5.2.3 Functions
	`walk-list`	5.2.3 Functions
	`walk-list-of-lambdas`	5.2.3 Functions
	`walk-load-time-value`	5.2.3 Functions
	`walk-macrolet`	5.2.3 Functions
	`walk-named-lambda`	5.2.3 Functions
	`walk-ordinary-lambda-list`	5.2.3 Functions
	`walk-plan-form`	5.2.3 Functions
	`walk-quote`	5.2.3 Functions
	`walk-with-tag-handler`	5.1.3 Functions
	`what-time-is-it`	5.2.3 Functions
	`whenever`	5.1.2 Macros
	`who-am-i`	5.2.3 Functions
	`with-extended-path`	5.2.2 Macros
	`with-failure-handling`	5.1.2 Macros
	`with-fluent-locked`	5.2.2 Macros
	`with-named-policies`	5.1.2 Macros
	`with-named-policy`	5.1.2 Macros
	`with-parallel-childs`	5.2.2 Macros
	`with-policies`	5.1.2 Macros
	`with-policy`	5.1.2 Macros
	`with-retry-counters`	5.1.2 Macros
	`with-scheduling`	5.1.2 Macros
	`with-shadowed-functions`	5.2.2 Macros
	`with-tags`	5.1.2 Macros
	`with-task`	5.2.2 Macros
	`with-task-suspended`	5.1.2 Macros
	`with-task-tree-node`	5.1.2 Macros
	`without-scheduling`	5.1.2 Macros

Jump to:	% ( * + - / < = > A C D E F G I J K L M N O P R S T U V W

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

A.3 Variables

Jump to:	* + C D E F H I L M N O P R S T V

	Index Entry	Section

*
	`active-log-mask`	5.2.1 Special variables
	`break-on-plan-failures`	5.1.1 Special variables
	`cltl2-environment-fns`	5.2.1 Special variables
	`current-parent`	5.2.1 Special variables
	`current-path`	5.1.1 Special variables
	`current-path`	5.2.1 Special variables
	`current-task`	5.1.1 Special variables
	`current-task-tree-node`	5.2.1 Special variables
	`debug-on-lisp-errors`	5.1.1 Special variables
	`log-output`	5.1.1 Special variables
	`log-right-margin`	5.1.1 Special variables
	`log-tag-table`	5.2.1 Special variables
	`peek-value`	5.2.1 Special variables
	`policies`	5.2.1 Special variables
	`policy-check-consolidation-duration`	5.2.1 Special variables
	`save-tasks`	5.1.1 Special variables
	`scheduling-enabled`	5.2.1 Special variables
	`shadowed-functions`	5.2.1 Special variables
	`status-transitions`	5.2.1 Special variables
	`suspension-handlers`	5.2.1 Special variables
	`suspension-unwind`	5.2.1 Special variables
	`synchronous-events`	5.2.1 Special variables
	`tag-walker-handlers`	5.2.1 Special variables
	`task-local-variables`	5.2.1 Special variables
	`task-pprint-verbosity`	5.1.1 Special variables
	`task-tree`	5.1.1 Special variables
	`task-tree-print-children`	5.2.1 Special variables
	`task-tree-print-code`	5.2.1 Special variables
	`task-tree-print-identity`	5.2.1 Special variables
	`task-tree-print-path`	5.2.1 Special variables
	`tasks`	5.1.1 Special variables
	`top-level-task-trees`	5.2.1 Special variables
	`zero-real-time`	5.2.1 Special variables
	`zero-run-time`	5.2.1 Special variables

+
	`+alive+`	5.1.1 Special variables
	`+available-log-tags+`	5.2.1 Special variables
	`+dead+`	5.1.1 Special variables
	`+done+`	5.1.1 Special variables
	`+log-all+`	5.1.1 Special variables
	`+log-default+`	5.1.1 Special variables
	`+log-language+`	5.1.1 Special variables
	`+log-verbose+`	5.1.1 Special variables
	`+log-very-verbose+`	5.1.1 Special variables
	`+time-quantum+`	5.2.1 Special variables

C
	`calculate-value-fun`	5.2.7 Classes
	`calculate-value-fun`	5.2.7 Classes
	`changed-condition`	5.1.7 Classes
	`check`	5.2.7 Classes
	`child-tasks`	5.2.7 Classes
	`children`	5.1.6 Structures
	`children`	5.1.6 Structures
	`clean-up`	5.2.7 Classes
	`code`	5.1.6 Structures
	`code`	5.2.7 Classes
	`code-replacements`	5.1.6 Structures
	`constraints`	5.2.7 Classes
	`content`	5.2.6 Structures

D
	`description`	5.2.7 Classes

E
	`error`	5.1.5 Conditions

F
	`failures`	5.1.5 Conditions
	`from`	5.2.6 Structures
	`function`	5.1.6 Structures

H
	`handle-missed-pulses`	5.2.7 Classes

I
	`init`	5.2.7 Classes

L
	`lock`	5.1.6 Structures

M
	`message-queue`	5.2.7 Classes

N
	`name`	5.1.5 Conditions
	`name`	5.1.7 Classes
	`name`	5.2.7 Classes
	`name`	5.2.7 Classes

O
	`on-update`	5.1.7 Classes

P
	`parameters`	5.1.5 Conditions
	`parameters`	5.1.6 Structures
	`parameters`	5.2.7 Classes
	`parent`	5.1.6 Structures
	`parent`	5.1.6 Structures
	`parent-task`	5.2.7 Classes
	`path`	5.1.6 Structures
	`path`	5.1.6 Structures
	`path`	5.2.7 Classes
	`processed-pulse-count`	5.2.7 Classes
	`pulse-count`	5.1.7 Classes

R
	`reason`	5.2.6 Structures
	`recover`	5.2.7 Classes
	`reference-pulse-count`	5.2.7 Classes
	`result`	5.2.7 Classes

S
	`sexp`	5.1.6 Structures
	`sexp`	5.1.6 Structures
	`Slot, calculate-value-fun`	5.2.7 Classes
	`Slot, calculate-value-fun`	5.2.7 Classes
	`Slot, changed-condition`	5.1.7 Classes
	`Slot, check`	5.2.7 Classes
	`Slot, child-tasks`	5.2.7 Classes
	`Slot, children`	5.1.6 Structures
	`Slot, children`	5.1.6 Structures
	`Slot, clean-up`	5.2.7 Classes
	`Slot, code`	5.1.6 Structures
	`Slot, code`	5.2.7 Classes
	`Slot, code-replacements`	5.1.6 Structures
	`Slot, constraints`	5.2.7 Classes
	`Slot, content`	5.2.6 Structures
	`Slot, description`	5.2.7 Classes
	`Slot, error`	5.1.5 Conditions
	`Slot, failures`	5.1.5 Conditions
	`Slot, from`	5.2.6 Structures
	`Slot, function`	5.1.6 Structures
	`Slot, handle-missed-pulses`	5.2.7 Classes
	`Slot, init`	5.2.7 Classes
	`Slot, lock`	5.1.6 Structures
	`Slot, message-queue`	5.2.7 Classes
	`Slot, name`	5.1.5 Conditions
	`Slot, name`	5.1.7 Classes
	`Slot, name`	5.2.7 Classes
	`Slot, name`	5.2.7 Classes
	`Slot, on-update`	5.1.7 Classes
	`Slot, parameters`	5.1.5 Conditions
	`Slot, parameters`	5.1.6 Structures
	`Slot, parameters`	5.2.7 Classes
	`Slot, parent`	5.1.6 Structures
	`Slot, parent`	5.1.6 Structures
	`Slot, parent-task`	5.2.7 Classes
	`Slot, path`	5.1.6 Structures
	`Slot, path`	5.1.6 Structures
	`Slot, path`	5.2.7 Classes
	`Slot, processed-pulse-count`	5.2.7 Classes
	`Slot, pulse-count`	5.1.7 Classes
	`Slot, reason`	5.2.6 Structures
	`Slot, recover`	5.2.7 Classes
	`Slot, reference-pulse-count`	5.2.7 Classes
	`Slot, result`	5.2.7 Classes
	`Slot, sexp`	5.1.6 Structures
	`Slot, sexp`	5.1.6 Structures
	`Slot, status`	5.2.7 Classes
	`Slot, sync`	5.2.6 Structures
	`Slot, tag`	5.2.6 Structures
	`Slot, task`	5.1.6 Structures
	`Slot, test`	5.1.7 Classes
	`Slot, thread`	5.2.7 Classes
	`Slot, thread-fun`	5.2.7 Classes
	`Slot, to`	5.2.6 Structures
	`Slot, value`	5.1.7 Classes
	`Slot, value`	5.2.7 Classes
	`Slot, value-lock`	5.1.7 Classes
	`Slot, values`	5.2.6 Structures
	`Special Variable, active-log-mask`	5.2.1 Special variables
	`Special Variable, break-on-plan-failures`	5.1.1 Special variables
	`Special Variable, cltl2-environment-fns`	5.2.1 Special variables
	`Special Variable, current-parent`	5.2.1 Special variables
	`Special Variable, current-path`	5.1.1 Special variables
	`Special Variable, current-path`	5.2.1 Special variables
	`Special Variable, current-task`	5.1.1 Special variables
	`Special Variable, current-task-tree-node`	5.2.1 Special variables
	`Special Variable, debug-on-lisp-errors`	5.1.1 Special variables
	`Special Variable, log-output`	5.1.1 Special variables
	`Special Variable, log-right-margin`	5.1.1 Special variables
	`Special Variable, log-tag-table`	5.2.1 Special variables
	`Special Variable, peek-value`	5.2.1 Special variables
	`Special Variable, policies`	5.2.1 Special variables
	`Special Variable, policy-check-consolidation-duration`	5.2.1 Special variables
	`Special Variable, save-tasks`	5.1.1 Special variables
	`Special Variable, scheduling-enabled`	5.2.1 Special variables
	`Special Variable, shadowed-functions`	5.2.1 Special variables
	`Special Variable, status-transitions`	5.2.1 Special variables
	`Special Variable, suspension-handlers`	5.2.1 Special variables
	`Special Variable, suspension-unwind`	5.2.1 Special variables
	`Special Variable, synchronous-events`	5.2.1 Special variables
	`Special Variable, tag-walker-handlers`	5.2.1 Special variables
	`Special Variable, task-local-variables`	5.2.1 Special variables
	`Special Variable, task-pprint-verbosity`	5.1.1 Special variables
	`Special Variable, task-tree`	5.1.1 Special variables
	`Special Variable, task-tree-print-children`	5.2.1 Special variables
	`Special Variable, task-tree-print-code`	5.2.1 Special variables
	`Special Variable, task-tree-print-identity`	5.2.1 Special variables
	`Special Variable, task-tree-print-path`	5.2.1 Special variables
	`Special Variable, tasks`	5.1.1 Special variables
	`Special Variable, top-level-task-trees`	5.2.1 Special variables
	`Special Variable, zero-real-time`	5.2.1 Special variables
	`Special Variable, zero-run-time`	5.2.1 Special variables
	`Special Variable, +alive+`	5.1.1 Special variables
	`Special Variable, +available-log-tags+`	5.2.1 Special variables
	`Special Variable, +dead+`	5.1.1 Special variables
	`Special Variable, +done+`	5.1.1 Special variables
	`Special Variable, +log-all+`	5.1.1 Special variables
	`Special Variable, +log-default+`	5.1.1 Special variables
	`Special Variable, +log-language+`	5.1.1 Special variables
	`Special Variable, +log-verbose+`	5.1.1 Special variables
	`Special Variable, +log-very-verbose+`	5.1.1 Special variables
	`Special Variable, +time-quantum+`	5.2.1 Special variables
	`Special Variable, timeout-policy`	5.1.1 Special variables
	`status`	5.2.7 Classes
	`sync`	5.2.6 Structures

T
	`tag`	5.2.6 Structures
	`task`	5.1.6 Structures
	`test`	5.1.7 Classes
	`thread`	5.2.7 Classes
	`thread-fun`	5.2.7 Classes
	`timeout-policy`	5.1.1 Special variables
	`to`	5.2.6 Structures

V
	`value`	5.1.7 Classes
	`value`	5.2.7 Classes
	`value-lock`	5.1.7 Classes
	`values`	5.2.6 Structures

Jump to:	* + C D E F H I L M N O P R S T V

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[ ? ]

A.4 Data types

Jump to:	A C E F L M P S T V

	Index Entry	Section

A
	`abstract-task`	5.2.7 Classes

C
	`Class, abstract-task`	5.2.7 Classes
	`Class, fl-cacheable-value-mixin`	5.2.7 Classes
	`Class, fl-net-cacheable-fluent`	5.2.7 Classes
	`Class, fl-net-fluent`	5.2.7 Classes
	`Class, fl-printable-mixin`	5.2.7 Classes
	`Class, fluent`	5.1.7 Classes
	`Class, policy`	5.2.7 Classes
	`Class, pulse-fluent`	5.2.7 Classes
	`Class, task`	5.1.7 Classes
	`Class, toplevel-task`	5.1.7 Classes
	`Class, value-fluent`	5.1.7 Classes
	`code`	5.1.6 Structures
	`common-lisp-error-envelope`	5.1.5 Conditions
	`composite-failure`	5.1.5 Conditions
	`Condition, common-lisp-error-envelope`	5.1.5 Conditions
	`Condition, composite-failure`	5.1.5 Conditions
	`Condition, plan-failure`	5.1.5 Conditions
	`Condition, policy-check-condition-met`	5.1.5 Conditions
	`Condition, policy-condition`	5.1.5 Conditions
	`Condition, policy-failure`	5.1.5 Conditions
	`Condition, policy-init-failed`	5.1.5 Conditions
	`Condition, policy-not-found`	5.1.5 Conditions
	`Condition, simple-plan-failure`	5.1.5 Conditions
	`Condition, time-quantum-exhausted`	5.2.5 Conditions
	`continuation`	5.2.8 Types
	`cram-language`	1.1 `cram-language`
	`cram-language`	4.2 `cram-language`
	`cram-language-implementation`	4.3 `cram-language-implementation`
	`cram-user`	4.1 `cram-user`
	`cram-walker`	4.4 `cram-walker`

E
	`event`	5.2.6 Structures
	`event-designator`	5.2.8 Types

F
	`fl-cacheable-value-mixin`	5.2.7 Classes
	`fl-net-cacheable-fluent`	5.2.7 Classes
	`fl-net-fluent`	5.2.7 Classes
	`fl-printable-mixin`	5.2.7 Classes
	`fluent`	5.1.7 Classes

L
	`list-of`	5.2.8 Types

M
	`message`	5.2.6 Structures

P
	`Package, cram-language`	4.2 `cram-language`
	`Package, cram-language-implementation`	4.3 `cram-language-implementation`
	`Package, cram-user`	4.1 `cram-user`
	`Package, cram-walker`	4.4 `cram-walker`
	`plan-failure`	5.1.5 Conditions
	`plan-tree-node`	5.1.6 Structures
	`policy`	5.2.7 Classes
	`policy-check-condition-met`	5.1.5 Conditions
	`policy-condition`	5.1.5 Conditions
	`policy-failure`	5.1.5 Conditions
	`policy-init-failed`	5.1.5 Conditions
	`policy-not-found`	5.1.5 Conditions
	`pulse-fluent`	5.2.7 Classes

S
	`simple-plan-failure`	5.1.5 Conditions
	`status-indicator`	5.1.8 Types
	`Structure, code`	5.1.6 Structures
	`Structure, event`	5.2.6 Structures
	`Structure, message`	5.2.6 Structures
	`Structure, plan-tree-node`	5.1.6 Structures
	`Structure, task-tree-node`	5.1.6 Structures
	`System, cram-language`	1.1 `cram-language`

T
	`task`	5.1.7 Classes
	`task-tree-node`	5.1.6 Structures
	`time-quantum-exhausted`	5.2.5 Conditions
	`toplevel-task`	5.1.7 Classes
	`Type, continuation`	5.2.8 Types
	`Type, event-designator`	5.2.8 Types
	`Type, list-of`	5.2.8 Types
	`Type, status-indicator`	5.1.8 Types

V
	`value-fluent`	5.1.7 Classes

Jump to:	A C E F L M P S T V

[Top]

[ ? ]

1. Systems
- 1.1 cram-language
2. Modules
3. Files
- 3.1 Lisp
4. Packages
5. Definitions
- 5.1 Exported definitions
- 5.2 Internal definitions
A. Indexes

[Top]