The cram-language Reference Manual

This is the cram-language Reference Manual, generated automatically by Declt version 2.0 patchlevel 1 "Benjamin Sisko" on Mon Feb 01 17:49:04 2016 GMT+1.

1. Systems

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

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)

2. Modules

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

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)

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)

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)

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)

3. Files

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

3.1 Lisp

3.1.1 cram-language.asd

Location

cram-language.asd

3.1.2 src/packages.lisp

Parent

src (module)

Location

src/packages.lisp

Packages

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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

Dependency

env (Lisp file)

Parent

walker (module)

Location

src/walker/env-impl-specific.lisp

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)

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)

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)

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)

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)

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)

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)

3.1.25 src/swank-indentation.lisp

Dependency

packages (Lisp file)

Parent

src (module)

Location

src/swank-indentation.lisp

3.1.26 src/sbcl-hotpatches.lisp

Parent

src (module)

Location

src/sbcl-hotpatches.lisp

4. Packages

Packages are listed by definition order.

4.1 cram-user

Source

packages (Lisp file)

Nickname

cpl-user

Use List

cram-language

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)

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

cram-language

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)

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

cram-language-implementation

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)

5. Definitions

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

5.1 Exported definitions

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)

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

<realtime> , <runtime> - <current task> > <context> ; <display>

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.

See also

LIST-AVAILABLE-LOG-TAGS

LIST-ACTIVE-LOG-TAGS

DEFINE-LOG-TAGS

*LOG-RIGHT-MARGIN*

Package

cram-language-implementation

Source

logging (Lisp file)

Macro: logging-enabled-p &rest TAGS

Is any tag in ‘tags’ active at the moment?

Package

cram-language-implementation

Source

logging (Lisp file)

Macro: make-policy NAME PARAMETERS &rest DOC-AND-PROPERTIES

Generates a policy based on the information supplied. ‘name’
specifies an internal name for the policy, to be used with
‘named-policy’, or ‘with-named-policy’. ‘parameters’ is a list of
parameter symbols to be used by code inside the policy. Every time, a
piece of code inside the policy is executed, these parameters (with
assigned values from the ‘with-policy’, or ‘with-named-policy’ call)
are passed to the code segments. The ‘properties’ variable holds a
list of labelled code segments for execution during certain phases. An
example would look like this:

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

This returns a policy object to be used with ‘with-policy’. For
further information about when each function block is executed, see ‘with-policy’. The semantics of the ‘properties’ variable are like
this:

- Forms given via ‘:init’ are executed exactly once, when the policy
is initialized for usage. In case this function returns ‘nil’,
execution of the ‘body’ code is not started, none of the other
policy code blocks are executed, and a failure of type
‘policy-init-failed’ is thrown.

- A function given under the label ‘:check’ is executed every time ‘with-policy’ checks if the policy condition is met or not. If this
function returns ‘t’, the condition is met, the ‘:recover’ function
block is executed, and the execution of both, the policy, and the
wrapped body code of ‘with-policy’ is stopped.

- Either when the policy (due to a met policy condition), or the
wrapped body of ‘with-policy’ code stopped execution of the current
code block, the ‘:clean-up’ function block is executed to perform
clean-up procedures.

Package

cram-language-implementation

Source

with-policy (Lisp file)

Macro: mapcar-clean FUNCTION LIST &rest MORE-LISTS

Automatically removes all ‘NIL’ entries from a generated list after
performing a ‘mapcar’.

Package

cram-language-implementation

Source

utils (Lisp file)

Macro: on-suspension WHEN-SUSPENDED-FORM &body BODY

Executes ‘when-suspended-form’ whenever a suspension event occurs
while ‘form’ is being executed.

Non local exits out of ‘when-suspended-form’ are prohibited.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Macro: par &body FORMS

Executes forms in parallel. Fails if one fails. Succeeds if all
succeed.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: par-loop (VAR SEQUENCE) &body BODY

Executes body in parallel for each ‘var’ in ‘sequence’.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: partial-order (&body STEPS) &body ORDERINGS

Specify ordering constraints for ‘steps’. ‘steps’ are executed in
an implicit PAR form. ‘orderings’ is a list of orderings. An ordering
always has the form:

(:order <contstraining-task> <constrained-task>)

‘constraining-task’ and ‘constrained-task’ are task objects. That
means, they can be either be defined in the current lexical
environment (over a :tag) or by either using the function TASK to
reference the task by its absolute path or the function SUB-TASK to
reference it by its path relative to the PARTIAL-ORDER form.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: pursue &body FORMS

Execute forms in parallel. Succeed if one succeeds, fail if one
fails.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: replaceable-function NAME LAMBDA-LIST PARAMETERS PATH-PART &body BODY

Besides the replacement of simple code parts defined with ’with-task-tree-node’, it is necessary to also pass parameters to the replaceable code
parts. For that, replaceable functions can be defined. They are not
real functions, i.e. they do change any symbol-function or change
the lexical environment. ’name’ is used to mark such functions in
the code-sexp. More specifically, the sexp is built like follows: ‘(replaceable-function ,name ,lambda-list ,@body).
The ’parameters’ parameter contains the values to call the function with.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Macro: retry-after-suspension &body BODY

Execute ‘body’, and return its values.

In case a suspension event occurs during the execution, ‘body’ is completely unwound, and the suspension takes place _outside_ of
‘body’. After wakeup, ‘body’ is executed again.

The intended use case is to unwind out of critical sections to
ensure that a task won’t suspend while holding on locks.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Macro: seq &body FORMS

Executes forms sequentially. Fails if one fail. Succeeds if all
succeed.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: top-level &body BODY

Anonymous top-level, e.g. for interactive use. See NAMED-TOP-LEVEL for details.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: try-all &body FORMS

Try forms in parallel. Succeed if one succeeds, fail if all fail.
In the case of a failure, a condition of type ’composite-failure’
is signaled, containing the list of all error messages and data.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: try-each-in-order (VARIABLE LIST) &body BODY

Executes ‘body’ with ‘variable’ bound to each element in ‘list’
sequentially until ‘body’ succeeds, i.e. returns the result of
‘body’ as soon as ‘body’ succeeds and stops iterating.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: try-in-order &body FORMS

Execute forms sequentially. Succeed if one succeeds, fail if all fail.
In case of failure, a composite-failure is signaled.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: whenever (CONDITION-FLUENT &key WAIT-STATUS) &body BODY

Executes ‘body’ whenever ‘condition-fluent’ is pulsed or non-nil.
The ‘body’ forms are executed in an implicit block named NIL. The parameter ‘wait-status’ has the same meaning as in WAIT-FOR

Package

cram-language-implementation

Source

fluent (Lisp file)

Macro: with-failure-handling CLAUSES &body BODY

Macro that replaces handler-case in cram-language. This is
necessary because error handling does not work across multiple
threads. When an error is signaled, it is put into an envelope to
avoid invocation of the debugger multiple times. When handling errors,
this envelope must also be taken into account.

We also need a mechanism to retry since errors can be caused by plan
execution and the environment is highly non-deterministic. Therefore,
it is possible to use the function ‘retry’ that is lexically bound
within with-failure-handling and causes a re-execution of the body.

When an error is unhandled, it is passed up to the next failure
handling form (exactly like handler-bind). Errors are handled by
invoking the retry function or by doing a non-local exit. Note that with-failure-handling implicitly creates an unnamed block,
i.e. ‘return’ can be used.

Package

cram-language-implementation

Source

failures (Lisp file)

Macro: with-named-policies POLICIES-AND-PARAMETERS-LIST &body BODY

The semantics of ‘with-named-policies’ are the same as for ‘with-policies’, except that instead of policy-objects, policy names are used:

> (with-named-policies
((’my-policy (3 1))
(’my-policy (100 4))
(’my-other-policy ("Test")))
(body-code))

Package

cram-language-implementation

Source

with-policy (Lisp file)

Macro: with-named-policy POLICY-NAME POLICY-PARAMETERS &body BODY

Performs the same as ‘with-policy’, but accepts a policy name
instead of the policy object itself. This calls an implicit
‘named-policy’ to acquire the policy object. Otherwise, it has the
same semantics as ‘with-policy’. Usage:

> (with-named-policy ’policy-name (param-value-1 param-value-2) (body-code))

Package

cram-language-implementation

Source

with-policy (Lisp file)

Macro: with-policies POLICIES-AND-PARAMETERS-LIST &body BODY

Allows for running a given ‘body’ code segment wrapped in a list of
policies (together with individual parameters for each of them). The ‘policies-and-parameters-list’ parameter describes a list of policy/parameter-list pairs.

The usage is as follows:

> (with-policies
((my-policy-object (3 1))
(my-policy-object (100 4))
(my-other-policy-object ("Test")))
(body-code))

Package

cram-language-implementation

Source

with-policy (Lisp file)

Macro: with-policy POLICY POLICY-PARAMETERS &body BODY

Wraps the code given as ‘body’ into a ‘pursue’ construct together
with monitoring code supplied by the policy ‘policy’, and given the
parameters ‘policy-parameters’. The ‘policy-parameters’ allow for
custom parameterization of policies. First, the policy is initialized
via the optional ‘:init’ code block. In case this block returns ‘nil’, execution of the ‘body’ code or other policy-related code blocks is
not started. An exception of type ‘policy-init-failed’ is
thrown. Otherwise, the ‘:check’ code block of the policy is executed
in a loop in parallel to the ‘body’ code. If the ‘:check’ code returns
‘t’, the policy condition is met and the ‘:recover’ code block is
executed. The execution of both, the policy, and the ‘body’ code is
the stopped, and the ‘:clean-up’ policy code is executed. If the
policy condition is never met, ‘body’ finishes and returns
normally.

To clarify the order of code execution here:

- Initialization of policy is executed (‘:init’)

- ‘pursue’ code form is started, with up to two forms inside:
- The policy ‘:check’ code block (if present)
- The ‘body’ code

- ‘:check’ is evaluated continuously, in parallel to the normal
execution of ‘body’. If it returns ‘nil’, nothing happens. In any
other case (i.e. return value is unequal to ‘nil’), the execution of
the ‘body’ code is interrupted, and ‘:check’ is not performed again
anymore. The policy code block given in ‘:recover’ is executed (if
present). This means (explicitly) that the ‘:recover’ code is
performed *after* the ‘body’ code got interrupted.

- If ‘:check’ always returns ‘nil’ until the ‘body’ code execution
finishes, ‘:recover’ is never executed.

- In either case (with or without ‘:recover’), the policy ‘:clean-up’
code is performed (if present).

In each of the phases, ‘policy-setf’ and ‘policy-get’ are
available. They can be used to store variables associated with given
symbols for the course of action of the current policy.

Example:

> (define-policy var-test-policy ()
"Variable Test Policy"
(:init (policy-setf ’some-var 10)
t)
(:check (policy-setf ’some-other-var
(+ (policy-get ’some-var) 2))
nil)
(:clean-up (format t "Variables: ~a ~a~%"
(policy-get ’some-var)
(policy-get ’some-other-var))))

Usage of ‘with-policy’:

> (with-policy policy-object (param-value-1 param-value-2)
(body-code))

Package

cram-language-implementation

Source

with-policy (Lisp file)

Macro: with-retry-counters COUNTER-DEFINITIONS &body BODY

Lexically binds all counters in ‘counter-definitions’ to the intial
values specified in ‘counter-definitions’. ‘counter-definitions’ is
similar to ‘let’ forms with the difference that the counters will
not be available under the specified names in the lexical
environment established by this macro. In addition, the macro
defines the local macro (DO-RETRY <counter> <body-form>*) to
decrement the counter and execute code when the maximal retry count
hasn’t been reached yet and the function ‘(RESET-COUNTER
<counter>).

Package

cram-language-implementation

Source

failures (Lisp file)

Macro: with-scheduling &body BODY

Enable scheduling again.

Package

cram-language-implementation

Source

task-interface (Lisp file)

Macro: with-tags &body BODY &environment LEXENV

Execute body with all tags bound to the corresponding lexically
bound variables.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: with-task-suspended (TASK &key REASON) &body BODY

Execute body with ’task’ being suspended.

Package

cram-language-implementation

Source

language (Lisp file)

Macro: with-task-tree-node (&key PATH-PART NAME SEXP LAMBDA-LIST PARAMETERS LOG-PARAMETERS LOG-PATTERN) &body BODY

Executes a body under a specific path. Sexp, lambda-list and parameters are optional.

Package

cram-language-implementation

Source

task-tree (Lisp file)

Macro: without-scheduling &body BODY

Execute ‘body’ without periodically entering into a task’s event
loop. This prevents all acting on messages (including suspension, evaporation, etc.) from other tasks.

Package

cram-language-implementation

Source

task-interface (Lisp file)

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)