The adopt Reference Manual

This is the adopt Reference Manual, version 1.2.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Dec 08 16:16:56 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 adopt

Simple, flexible, UNIX-style option parsing.

Author

Steve Losh <>

Home Page

https://docs.stevelosh.com/adopt/

License

MIT

Version

1.2.0

Dependencies
  • bobbin (system).
  • split-sequence (system).
Source

adopt.asd.

Child Component

src (module).


3 Modules

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


3.1 adopt/src

Source

adopt.asd.

Parent Component

adopt (system).

Child Components

4 Files

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


4.1 Lisp


4.1.1 adopt/adopt.asd

Source

adopt.asd.

Parent Component

adopt (system).

ASDF Systems

adopt.


4.1.2 adopt/src/package.lisp

Source

adopt.asd.

Parent Component

src (module).

Packages

adopt.


4.1.3 adopt/src/main.lisp

Dependency

package.lisp (file).

Source

adopt.asd.

Parent Component

src (module).

Public Interface
Internals

5 Packages

Packages are listed by definition order.


5.1 adopt

Source

package.lisp.

Use List

common-lisp.

Public Interface
Internals

6 Definitions

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


6.1 Public Interface


6.1.1 Macros

Macro: define-string (var string &rest args)

Convenience macro for ‘(defparameter ,var (format nil ,string ,@args))‘.

Package

adopt.

Source

main.lisp.

Macro: defparameters (parameters values-form)

Convenience macro for ‘defparameter‘ing multiple variables at once.

‘parameters‘ must be a list of special variable names suitable for giving to ‘defparameter‘.

‘values-form‘ must be an expression that returns as many values as parameters in the parameter list. Each parameter will be set to the corresponding value.

This can be handy when using ‘make-boolean-options‘ to create two ‘option‘s at once and assign them to special variables.

Examples:

(defparameters (*a* *b*) (truncate 100 3))
(list *a* *b*)
; =>
; (33 1)

(defparameters (*option-foo* *option-no-foo*)
(make-boolean-options ’foo
:help "Foo the widgets during the run."
:help-no "Do not foo the widgets during the run (the default)." :long "foo"
:short #f))

Package

adopt.

Source

main.lisp.


6.1.2 Ordinary functions

Function: argv ()

Return a list of the program name and command line arguments.

This is not implemented for every Common Lisp implementation. You can pass your own values to ‘parse-options‘ and ‘print-help‘ if it’s not implemented for your particular Lisp.

Package

adopt.

Source

main.lisp.

Function: collect (list el)

Append element ‘el‘ to the end of ‘list‘.

It is useful as a ‘:reduce‘ function when you want to collect all values given for an option.

This is implemented as ‘(append list (list el))‘. It is not particularly fast. If you can live with reversed output consider ‘(flip #’cons)‘ instead.

Package

adopt.

Source

main.lisp.

Function: discard-option (condition)

Invoke the ‘discard-option‘ restart properly.

Example:

(handler-bind ((unrecognized-option ’discard-option)) (multiple-value-bind (arguments options) (parse-options *ui*) (run arguments options)))

Package

adopt.

Source

main.lisp.

Function: exit (&optional code)

Exit the program with status ‘code‘.

This is not implemented for every Common Lisp implementation. You can write your own version of it and pass it to ‘print-help-and-exit‘ and ‘print-error-and-exit‘ if it’s not implemented for your particular Lisp.

Package

adopt.

Source

main.lisp.

Function: first (old new)

Return ‘new‘ if ‘old‘ is ‘nil‘, otherwise return ‘old‘.

It is useful as a ‘:reduce‘ function when you want to just keep the first-given value for an option.

Package

adopt.

Source

main.lisp.

Function: flip (function)

Return a function of two arguments X and Y that calls ‘function‘ with Y and X.

Useful for wrapping existing functions that expect their arguments in the opposite order.

Examples:

(funcall #’cons 1 2) ; => (1 . 2)
(funcall (flip #’cons) 1 2) ; => (2 . 1)
(reduce (flip #’cons) ’(1 2 3) :initial-value nil)
; => (3 2 1)

Package

adopt.

Source

main.lisp.

Function: last (old new)

Return ‘new‘.

It is useful as a ‘:reduce‘ function when you want to just keep the last-given value for an option.

Package

adopt.

Source

main.lisp.

Function: make-boolean-options (name &key name-no long long-no short short-no result-key help help-no manual manual-no initial-value)

Create and return a pair of boolean options, suitable for use in an interface.

This function reduces some of the boilerplate when creating two ‘option‘s for boolean values, e.g. ‘–foo‘ and ‘–no-foo‘. It will try to guess at an appropriate name, long option, short option, and result key, but you can override them with the ‘…-no‘ keyword options as needed.

The two options will be returned as two separate values — you can use ‘defparameters‘ to conveniently bind them to two separate variables if desired.

Example:

(defparameters (*option-debug* *option-no-debug*)
(make-boolean-options ’debug
:long "debug"
:short #d
:help "Enable the Lisp debugger."
:help-no "Disable the Lisp debugger (the default)."))

;; is roughly equivalent to:

(defparameter *option-debug*
(make-option ’debug
:long "debug"
:short #d
:help "Enable the Lisp debugger."
:initial-value nil
:reduce (constantly t))

(defparameter *option-no-debug*
(make-option ’no-debug
:long "no-debug"
:short #D
:help "Disable the Lisp debugger (the default)."
:reduce (constantly nil))

Package

adopt.

Source

main.lisp.

Function: make-group (name &key title help manual options)

Create and return an option group, suitable for use in an interface.

This function takes a number of arguments that define how the group is
presented to the user:

* ‘name‘ (**required**): a symbol naming the group.
* ‘title‘ (optional): a title for the group for use in the help text.
* ‘help‘ (optional): a short summary of this group of options for use in the help text. * ‘manual‘ (optional): used in place of ‘help‘ when rendering a man page.
* ‘options‘ (**required**): the options to include in the group.

See the full documentation for more information.

Package

adopt.

Source

main.lisp.

Function: make-interface (&key name summary usage help manual examples contents)

Create and return a command line interface.

This function takes a number of arguments that define how the interface is
presented to the user:

* ‘name‘ (**required**): a symbol naming the interface.
* ‘summary‘ (**required**): a string of a concise, one-line summary of what the program does.
* ‘usage‘ (**required**): a string of a UNIX-style usage summary, e.g. ‘"[OPTIONS] PATTERN [FILE...]"‘.
* ‘help‘ (**required**): a string of a longer description of the program.
* ‘manual‘ (optional): a string to use in place of ‘help‘ when rendering a man page.
* ‘examples‘ (optional): an alist of ‘(prose . command)‘ conses to render as a list of examples.
* ‘contents‘ (optional): a list of options and groups. Ungrouped options will be collected into a single top-level group.

See the full documentation for more information.

Package

adopt.

Source

main.lisp.

Function: make-option (name &key long short help manual parameter reduce initial-value result-key key finally)

Create and return an option, suitable for use in an interface.

This function takes a number of arguments, some required, that define how the
option interacts with the user.

* ‘name‘ (**required**): a symbol naming the option.
* ‘help‘ (**required**): a short string describing what the option does.
* ‘result-key‘ (optional): a symbol to use as the key for this option in the hash table of results.
* ‘long‘ (optional): a string for the long form of the option (e.g. ‘–foo‘).
* ‘short‘ (optional): a character for the short form of the option (e.g. ‘-f‘). At least one of ‘short‘ and ‘long‘ must be given.
* ‘manual‘ (optional): a string to use in place of ‘help‘ when rendering a man page.
* ‘parameter‘ (optional): a string. If given, it will turn this option into a parameter-taking option (e.g. ‘–foo=bar‘) and will be used as a placeholder
in the help text.
* ‘reduce‘ (**required**): a function designator that will be called every time the option is specified by the user.
* ‘initial-value‘ (optional): a value to use as the initial value of the option.
* ‘key‘ (optional): a function designator, only allowed for parameter-taking options, to be called on the values given by the user before they are passed along to the reducing function. It will not be called on the initial value. * ‘finally‘ (optional): a function designator to be called on the final result after all parsing is complete.

The manner in which the reducer is called depends on whether the option takes a parameter:

* For options that don’t take parameters, it will be called with the old value.
* For options that take parameters, it will be called with the old value and the value given by the user.

See the full documentation for more information.

Package

adopt.

Source

main.lisp.

Function: parse-options (interface &optional arguments)

Parse ‘arguments‘ according to ‘interface‘.

Two values are returned:

1. A fresh list of top-level, unaccounted-for arguments that don’t correspond to any options defined in ‘interface‘.
2. An ‘EQL‘ hash table of option keys to values.

See the full documentation for more information.

Package

adopt.

Source

main.lisp.

Function: parse-options-or-exit (interface &optional arguments)

Parse ‘arguments‘ according to ‘interface‘, exiting if any error occurs.

Two values are returned:

1. A fresh list of top-level, unaccounted-for arguments that don’t correspond to any options defined in ‘interface‘.
2. An ‘EQL‘ hash table of option keys to values.

If an error occurs while parsing the arguments, exits immediately as if with ‘adopt:print-error-and-exit‘.

See the full documentation for more information.

Package

adopt.

Source

main.lisp.

Function: print-error-and-exit (error &key stream exit-function exit-code prefix)

Print ‘prefix‘ and ‘error‘ to ‘stream‘ and exit.

Example:

(handler-case
(multiple-value-bind (arguments options) (parse-options *ui*) (run arguments options))
(unrecognized-option (c)
(print-error-and-exit c)))

Package

adopt.

Source

main.lisp.

Function: print-help (interface &key stream program-name width option-width include-examples)

Print a pretty help document for ‘interface‘ to ‘stream‘.

‘width‘ should be the total width (in characters) for line-wrapping purposes. Care will be taken to ensure lines are no longer than this, though some edge cases (extremely long short/long option names and parameters) may slip through.

‘option-width‘ should be the width of the column of short/long options (in characters). If the short/long option help is shorter than this, the option’s help string will start on the same line. Otherwise the option’s help string will start on the next line.

The result will look something like:

(print-help *program-interface* :width 60 :option-width 15)
; =>
; foo - do some things and meow
;
; USAGE: /bin/foo [options] FILES
;
; Foo is a program to frobulate some files, meowing as it
; happens.
;
; Options:
; -v, –verbose Output extra information.
; -q, –quiet Shut up.
; –ignore FILE Ignore FILE. May be specified multiple
; times.
; -n NAME, –name NAME
; Your name. May be specified many times,
; last one wins.
; -m, –meow Meow.
; 0.........1.... option-width
; 0........1.........2.........3.........4.........5.........6

Package

adopt.

Source

main.lisp.

Function: print-help-and-exit (interface &key stream program-name width option-width include-examples exit-function exit-code)

Print a pretty help document for ‘interface‘ to ‘stream‘ and exit.

Handy for easily providing –help:

(multiple-value-bind (arguments options) (parse-options *ui*) (when (gethash ’help options)
(print-help-and-exit *ui*))
(run arguments options))

Package

adopt.

Source

main.lisp.

Function: print-manual (interface &key stream manual-section)

Print a troff-formatted man page for ‘interface‘ to ‘stream‘.

Example:

(with-open-file (manual "man/man1/foo.1"
:direction :output
:if-exists :supersede) (print-manual *ui* manual))

Package

adopt.

Source

main.lisp.

Function: supply-new-value (condition value)

Invoke the ‘supply-new-value‘ restart properly.

Example:

(handler-bind
((unrecognized-option (alexandria:rcurry ’supply-new-value "–foo")) (multiple-value-bind (arguments options) (parse-options *ui*)
(run arguments options)))

Package

adopt.

Source

main.lisp.

Function: treat-as-argument (condition)

Invoke the ‘treat-as-argument‘ restart properly.

Example:

(handler-bind ((unrecognized-option ’treat-as-argument)) (multiple-value-bind (arguments options) (parse-options *ui*) (run arguments options)))

Package

adopt.

Source

main.lisp.


6.1.3 Generic functions

Generic Reader: problematic-option (condition)
Generic Writer: (setf problematic-option) (condition)
Package

adopt.

Methods
Reader Method: problematic-option ((condition unrecognized-option))
Writer Method: (setf problematic-option) ((condition unrecognized-option))
Source

main.lisp.

Target Slot

problematic-option.


6.1.4 Standalone methods

Method: print-object ((o option) stream)
Source

main.lisp.

Method: print-object ((i interface) stream)
Source

main.lisp.

Method: print-object ((g group) stream)
Source

main.lisp.


6.1.5 Conditions

Condition: unrecognized-option
Package

adopt.

Source

main.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: problematic-option
Initargs

:problematic-option

Readers

problematic-option.

Writers

(setf problematic-option).


6.2 Internals


6.2.1 Macros

Macro: check-types (&rest place-type-pairs)
Package

adopt.

Source

main.lisp.

Macro: defclass* (name &rest slots)
Package

adopt.

Source

main.lisp.

Macro: funcallf (place function)
Package

adopt.

Source

main.lisp.

Macro: quit-on-ctrl-c ((&key code) &body body)
Package

adopt.

Source

main.lisp.


6.2.2 Ordinary functions

Function: escape (string)
Package

adopt.

Source

main.lisp.

Function: finalize-results (interface results)
Package

adopt.

Source

main.lisp.

Function: funcall% (value function)
Package

adopt.

Source

main.lisp.

Function: groupp (object)
Package

adopt.

Source

main.lisp.

Function: initialize-results (interface results)
Package

adopt.

Source

main.lisp.

Function: longp (arg)
Package

adopt.

Source

main.lisp.

Function: make-default-group (options)
Package

adopt.

Source

main.lisp.

Function: option-string (option)
Package

adopt.

Source

main.lisp.

Function: option-troff (option)
Package

adopt.

Source

main.lisp.

Function: optionp (object)
Package

adopt.

Source

main.lisp.

Function: parse-long (interface results arg remaining)
Package

adopt.

Source

main.lisp.

Function: parse-short (interface results arg remaining)
Package

adopt.

Source

main.lisp.

Function: print-option-help (stream option option-column doc-column doc-width)

Print ‘option‘’s help to ‘stream‘, indented/wrapped properly.

Assumes the last thing printed to ‘stream‘ was a newline.

The option string will start at ‘option-column‘. The help will start at ‘doc-column‘ and be line-wrapped to ‘doc-width‘.

Package

adopt.

Source

main.lisp.

Function: shortp (arg)
Package

adopt.

Source

main.lisp.

Function: split-paragraphs (string &key delimiter escape)
Package

adopt.

Source

main.lisp.

Function: terminatorp (arg)
Package

adopt.

Source

main.lisp.

Function: unrecognized-option-p (value)
Package

adopt.

Source

main.lisp.


6.2.3 Generic functions

Generic Reader: examples (object)
Package

adopt.

Methods
Reader Method: examples ((interface interface))

automatically generated reader method

Source

main.lisp.

Target Slot

examples.

Generic Writer: (setf examples) (object)
Package

adopt.

Methods
Writer Method: (setf examples) ((interface interface))

automatically generated writer method

Source

main.lisp.

Target Slot

examples.

Generic Reader: finally (object)
Package

adopt.

Methods
Reader Method: finally ((option option))

automatically generated reader method

Source

main.lisp.

Target Slot

finally.

Generic Writer: (setf finally) (object)
Package

adopt.

Methods
Writer Method: (setf finally) ((option option))

automatically generated writer method

Source

main.lisp.

Target Slot

finally.

Generic Reader: groups (object)
Package

adopt.

Methods
Reader Method: groups ((interface interface))

automatically generated reader method

Source

main.lisp.

Target Slot

groups.

Generic Writer: (setf groups) (object)
Package

adopt.

Methods
Writer Method: (setf groups) ((interface interface))

automatically generated writer method

Source

main.lisp.

Target Slot

groups.

Generic Reader: help (object)
Package

adopt.

Methods
Reader Method: help ((interface interface))

automatically generated reader method

Source

main.lisp.

Target Slot

help.

Reader Method: help ((group group))

automatically generated reader method

Source

main.lisp.

Target Slot

help.

Reader Method: help ((option option))

automatically generated reader method

Source

main.lisp.

Target Slot

help.

Generic Writer: (setf help) (object)
Package

adopt.

Methods
Writer Method: (setf help) ((interface interface))

automatically generated writer method

Source

main.lisp.

Target Slot

help.

Writer Method: (setf help) ((group group))

automatically generated writer method

Source

main.lisp.

Target Slot

help.

Writer Method: (setf help) ((option option))

automatically generated writer method

Source

main.lisp.

Target Slot

help.

Generic Reader: initial-value (object)
Package

adopt.

Methods
Reader Method: initial-value ((option option))

automatically generated reader method

Source

main.lisp.

Target Slot

initial-value.

Generic Writer: (setf initial-value) (object)
Package

adopt.

Methods
Writer Method: (setf initial-value) ((option option))

automatically generated writer method

Source

main.lisp.

Target Slot

initial-value.

Generic Reader: key (object)
Package

adopt.

Methods
Reader Method: key ((option option))

automatically generated reader method

Source

main.lisp.

Target Slot

key.

Generic Writer: (setf key) (object)
Package

adopt.

Methods
Writer Method: (setf key) ((option option))

automatically generated writer method

Source

main.lisp.

Target Slot

key.

Generic Reader: long (object)
Package

adopt.

Methods
Reader Method: long ((option option))

automatically generated reader method

Source

main.lisp.

Target Slot

long.

Generic Writer: (setf long) (object)
Package

adopt.

Methods
Writer Method: (setf long) ((option option))

automatically generated writer method

Source

main.lisp.

Target Slot

long.

Generic Reader: long-options (object)
Package

adopt.

Methods
Reader Method: long-options ((interface interface))

automatically generated reader method

Source

main.lisp.

Target Slot

long-options.

Generic Writer: (setf long-options) (object)
Package

adopt.

Methods
Writer Method: (setf long-options) ((interface interface))

automatically generated writer method

Source

main.lisp.

Target Slot

long-options.

Generic Reader: manual (object)
Package

adopt.

Methods
Reader Method: manual ((interface interface))

automatically generated reader method

Source

main.lisp.

Target Slot

manual.

Reader Method: manual ((group group))

automatically generated reader method

Source

main.lisp.

Target Slot

manual.

Reader Method: manual ((option option))

automatically generated reader method

Source

main.lisp.

Target Slot

manual.

Generic Writer: (setf manual) (object)
Package

adopt.

Methods
Writer Method: (setf manual) ((interface interface))

automatically generated writer method

Source

main.lisp.

Target Slot

manual.

Writer Method: (setf manual) ((group group))

automatically generated writer method

Source

main.lisp.

Target Slot

manual.

Writer Method: (setf manual) ((option option))

automatically generated writer method

Source

main.lisp.

Target Slot

manual.

Generic Reader: name (object)
Package

adopt.

Methods
Reader Method: name ((interface interface))

automatically generated reader method

Source

main.lisp.

Target Slot

name.

Reader Method: name ((group group))

automatically generated reader method

Source

main.lisp.

Target Slot

name.

Reader Method: name ((option option))

automatically generated reader method

Source

main.lisp.

Target Slot

name.

Generic Writer: (setf name) (object)
Package

adopt.

Methods
Writer Method: (setf name) ((interface interface))

automatically generated writer method

Source

main.lisp.

Target Slot

name.

Writer Method: (setf name) ((group group))

automatically generated writer method

Source

main.lisp.

Target Slot

name.

Writer Method: (setf name) ((option option))

automatically generated writer method

Source

main.lisp.

Target Slot

name.

Generic Reader: options (object)
Package

adopt.

Methods
Reader Method: options ((interface interface))

automatically generated reader method

Source

main.lisp.

Target Slot

options.

Reader Method: options ((group group))

automatically generated reader method

Source

main.lisp.

Target Slot

options.

Generic Writer: (setf options) (object)
Package

adopt.

Methods
Writer Method: (setf options) ((interface interface))

automatically generated writer method

Source

main.lisp.

Target Slot

options.

Writer Method: (setf options) ((group group))

automatically generated writer method

Source

main.lisp.

Target Slot

options.

Generic Reader: parameter (object)
Package

adopt.

Methods
Reader Method: parameter ((option option))

automatically generated reader method

Source

main.lisp.

Target Slot

parameter.

Generic Writer: (setf parameter) (object)
Package

adopt.

Methods
Writer Method: (setf parameter) ((option option))

automatically generated writer method

Source

main.lisp.

Target Slot

parameter.

Generic Reader: reduce (object)
Package

adopt.

Methods
Reader Method: reduce ((option option))

automatically generated reader method

Source

main.lisp.

Target Slot

reduce.

Generic Writer: (setf reduce) (object)
Package

adopt.

Methods
Writer Method: (setf reduce) ((option option))

automatically generated writer method

Source

main.lisp.

Target Slot

reduce.

Generic Reader: result-key (object)
Package

adopt.

Methods
Reader Method: result-key ((option option))

automatically generated reader method

Source

main.lisp.

Target Slot

result-key.

Generic Writer: (setf result-key) (object)
Package

adopt.

Methods
Writer Method: (setf result-key) ((option option))

automatically generated writer method

Source

main.lisp.

Target Slot

result-key.

Generic Reader: short (object)
Package

adopt.

Methods
Reader Method: short ((option option))

automatically generated reader method

Source

main.lisp.

Target Slot

short.

Generic Writer: (setf short) (object)
Package

adopt.

Methods
Writer Method: (setf short) ((option option))

automatically generated writer method

Source

main.lisp.

Target Slot

short.

Generic Reader: short-options (object)
Package

adopt.

Methods
Reader Method: short-options ((interface interface))

automatically generated reader method

Source

main.lisp.

Target Slot

short-options.

Generic Writer: (setf short-options) (object)
Package

adopt.

Methods
Writer Method: (setf short-options) ((interface interface))

automatically generated writer method

Source

main.lisp.

Target Slot

short-options.

Generic Reader: summary (object)
Package

adopt.

Methods
Reader Method: summary ((interface interface))

automatically generated reader method

Source

main.lisp.

Target Slot

summary.

Generic Writer: (setf summary) (object)
Package

adopt.

Methods
Writer Method: (setf summary) ((interface interface))

automatically generated writer method

Source

main.lisp.

Target Slot

summary.

Generic Reader: title (object)
Package

adopt.

Methods
Reader Method: title ((group group))

automatically generated reader method

Source

main.lisp.

Target Slot

title.

Generic Writer: (setf title) (object)
Package

adopt.

Methods
Writer Method: (setf title) ((group group))

automatically generated writer method

Source

main.lisp.

Target Slot

title.

Generic Reader: usage (object)
Package

adopt.

Methods
Reader Method: usage ((interface interface))

automatically generated reader method

Source

main.lisp.

Target Slot

usage.

Generic Writer: (setf usage) (object)
Package

adopt.

Methods
Writer Method: (setf usage) ((interface interface))

automatically generated writer method

Source

main.lisp.

Target Slot

usage.


6.2.4 Classes

Class: group
Package

adopt.

Source

main.lisp.

Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name.

Writers

(setf name).

Slot: title
Initargs

:title

Readers

title.

Writers

(setf title).

Slot: help
Initargs

:help

Readers

help.

Writers

(setf help).

Slot: manual
Initargs

:manual

Readers

manual.

Writers

(setf manual).

Slot: options
Initargs

:options

Readers

options.

Writers

(setf options).

Class: interface
Package

adopt.

Source

main.lisp.

Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name.

Writers

(setf name).

Slot: summary
Initargs

:summary

Readers

summary.

Writers

(setf summary).

Slot: examples
Initargs

:examples

Readers

examples.

Writers

(setf examples).

Slot: options
Initargs

:options

Readers

options.

Writers

(setf options).

Slot: groups
Initargs

:groups

Readers

groups.

Writers

(setf groups).

Slot: short-options
Initargs

:short-options

Readers

short-options.

Writers

(setf short-options).

Slot: long-options
Initargs

:long-options

Readers

long-options.

Writers

(setf long-options).

Slot: usage
Initargs

:usage

Readers

usage.

Writers

(setf usage).

Slot: help
Initargs

:help

Readers

help.

Writers

(setf help).

Slot: manual
Initargs

:manual

Readers

manual.

Writers

(setf manual).

Class: option
Package

adopt.

Source

main.lisp.

Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name.

Writers

(setf name).

Slot: result-key
Initargs

:result-key

Readers

result-key.

Writers

(setf result-key).

Slot: help
Initargs

:help

Readers

help.

Writers

(setf help).

Slot: manual
Initargs

:manual

Readers

manual.

Writers

(setf manual).

Slot: short
Initargs

:short

Readers

short.

Writers

(setf short).

Slot: long
Initargs

:long

Readers

long.

Writers

(setf long).

Slot: parameter
Initargs

:parameter

Readers

parameter.

Writers

(setf parameter).

Slot: initial-value
Initargs

:initial-value

Readers

initial-value.

Writers

(setf initial-value).

Slot: key
Initargs

:key

Readers

key.

Writers

(setf key).

Slot: finally
Initargs

:finally

Readers

finally.

Writers

(setf finally).

Slot: reduce
Initargs

:reduce

Readers

reduce.

Writers

(setf reduce).


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   (  
A   C   D   E   F   G   H   I   K   L   M   N   O   P   Q   R   S   T   U  
Index Entry  Section

(
(setf examples): Private generic functions
(setf examples): Private generic functions
(setf finally): Private generic functions
(setf finally): Private generic functions
(setf groups): Private generic functions
(setf groups): Private generic functions
(setf help): Private generic functions
(setf help): Private generic functions
(setf help): Private generic functions
(setf help): Private generic functions
(setf initial-value): Private generic functions
(setf initial-value): Private generic functions
(setf key): Private generic functions
(setf key): Private generic functions
(setf long): Private generic functions
(setf long): Private generic functions
(setf long-options): Private generic functions
(setf long-options): Private generic functions
(setf manual): Private generic functions
(setf manual): Private generic functions
(setf manual): Private generic functions
(setf manual): Private generic functions
(setf name): Private generic functions
(setf name): Private generic functions
(setf name): Private generic functions
(setf name): Private generic functions
(setf options): Private generic functions
(setf options): Private generic functions
(setf options): Private generic functions
(setf parameter): Private generic functions
(setf parameter): Private generic functions
(setf problematic-option): Public generic functions
(setf problematic-option): Public generic functions
(setf reduce): Private generic functions
(setf reduce): Private generic functions
(setf result-key): Private generic functions
(setf result-key): Private generic functions
(setf short): Private generic functions
(setf short): Private generic functions
(setf short-options): Private generic functions
(setf short-options): Private generic functions
(setf summary): Private generic functions
(setf summary): Private generic functions
(setf title): Private generic functions
(setf title): Private generic functions
(setf usage): Private generic functions
(setf usage): Private generic functions

A
argv: Public ordinary functions

C
check-types: Private macros
collect: Public ordinary functions

D
defclass*: Private macros
define-string: Public macros
defparameters: Public macros
discard-option: Public ordinary functions

E
escape: Private ordinary functions
examples: Private generic functions
examples: Private generic functions
exit: Public ordinary functions

F
finalize-results: Private ordinary functions
finally: Private generic functions
finally: Private generic functions
first: Public ordinary functions
flip: Public ordinary functions
funcall%: Private ordinary functions
funcallf: Private macros
Function, argv: Public ordinary functions
Function, collect: Public ordinary functions
Function, discard-option: Public ordinary functions
Function, escape: Private ordinary functions
Function, exit: Public ordinary functions
Function, finalize-results: Private ordinary functions
Function, first: Public ordinary functions
Function, flip: Public ordinary functions
Function, funcall%: Private ordinary functions
Function, groupp: Private ordinary functions
Function, initialize-results: Private ordinary functions
Function, last: Public ordinary functions
Function, longp: Private ordinary functions
Function, make-boolean-options: Public ordinary functions
Function, make-default-group: Private ordinary functions
Function, make-group: Public ordinary functions
Function, make-interface: Public ordinary functions
Function, make-option: Public ordinary functions
Function, option-string: Private ordinary functions
Function, option-troff: Private ordinary functions
Function, optionp: Private ordinary functions
Function, parse-long: Private ordinary functions
Function, parse-options: Public ordinary functions
Function, parse-options-or-exit: Public ordinary functions
Function, parse-short: Private ordinary functions
Function, print-error-and-exit: Public ordinary functions
Function, print-help: Public ordinary functions
Function, print-help-and-exit: Public ordinary functions
Function, print-manual: Public ordinary functions
Function, print-option-help: Private ordinary functions
Function, shortp: Private ordinary functions
Function, split-paragraphs: Private ordinary functions
Function, supply-new-value: Public ordinary functions
Function, terminatorp: Private ordinary functions
Function, treat-as-argument: Public ordinary functions
Function, unrecognized-option-p: Private ordinary functions

G
Generic Function, (setf examples): Private generic functions
Generic Function, (setf finally): Private generic functions
Generic Function, (setf groups): Private generic functions
Generic Function, (setf help): Private generic functions
Generic Function, (setf initial-value): Private generic functions
Generic Function, (setf key): Private generic functions
Generic Function, (setf long): Private generic functions
Generic Function, (setf long-options): Private generic functions
Generic Function, (setf manual): Private generic functions
Generic Function, (setf name): Private generic functions
Generic Function, (setf options): Private generic functions
Generic Function, (setf parameter): Private generic functions
Generic Function, (setf problematic-option): Public generic functions
Generic Function, (setf reduce): Private generic functions
Generic Function, (setf result-key): Private generic functions
Generic Function, (setf short): Private generic functions
Generic Function, (setf short-options): Private generic functions
Generic Function, (setf summary): Private generic functions
Generic Function, (setf title): Private generic functions
Generic Function, (setf usage): Private generic functions
Generic Function, examples: Private generic functions
Generic Function, finally: Private generic functions
Generic Function, groups: Private generic functions
Generic Function, help: Private generic functions
Generic Function, initial-value: Private generic functions
Generic Function, key: Private generic functions
Generic Function, long: Private generic functions
Generic Function, long-options: Private generic functions
Generic Function, manual: Private generic functions
Generic Function, name: Private generic functions
Generic Function, options: Private generic functions
Generic Function, parameter: Private generic functions
Generic Function, problematic-option: Public generic functions
Generic Function, reduce: Private generic functions
Generic Function, result-key: Private generic functions
Generic Function, short: Private generic functions
Generic Function, short-options: Private generic functions
Generic Function, summary: Private generic functions
Generic Function, title: Private generic functions
Generic Function, usage: Private generic functions
groupp: Private ordinary functions
groups: Private generic functions
groups: Private generic functions

H
help: Private generic functions
help: Private generic functions
help: Private generic functions
help: Private generic functions

I
initial-value: Private generic functions
initial-value: Private generic functions
initialize-results: Private ordinary functions

K
key: Private generic functions
key: Private generic functions

L
last: Public ordinary functions
long: Private generic functions
long: Private generic functions
long-options: Private generic functions
long-options: Private generic functions
longp: Private ordinary functions

M
Macro, check-types: Private macros
Macro, defclass*: Private macros
Macro, define-string: Public macros
Macro, defparameters: Public macros
Macro, funcallf: Private macros
Macro, quit-on-ctrl-c: Private macros
make-boolean-options: Public ordinary functions
make-default-group: Private ordinary functions
make-group: Public ordinary functions
make-interface: Public ordinary functions
make-option: Public ordinary functions
manual: Private generic functions
manual: Private generic functions
manual: Private generic functions
manual: Private generic functions
Method, (setf examples): Private generic functions
Method, (setf finally): Private generic functions
Method, (setf groups): Private generic functions
Method, (setf help): Private generic functions
Method, (setf help): Private generic functions
Method, (setf help): Private generic functions
Method, (setf initial-value): Private generic functions
Method, (setf key): Private generic functions
Method, (setf long): Private generic functions
Method, (setf long-options): Private generic functions
Method, (setf manual): Private generic functions
Method, (setf manual): Private generic functions
Method, (setf manual): Private generic functions
Method, (setf name): Private generic functions
Method, (setf name): Private generic functions
Method, (setf name): Private generic functions
Method, (setf options): Private generic functions
Method, (setf options): Private generic functions
Method, (setf parameter): Private generic functions
Method, (setf problematic-option): Public generic functions
Method, (setf reduce): Private generic functions
Method, (setf result-key): Private generic functions
Method, (setf short): Private generic functions
Method, (setf short-options): Private generic functions
Method, (setf summary): Private generic functions
Method, (setf title): Private generic functions
Method, (setf usage): Private generic functions
Method, examples: Private generic functions
Method, finally: Private generic functions
Method, groups: Private generic functions
Method, help: Private generic functions
Method, help: Private generic functions
Method, help: Private generic functions
Method, initial-value: Private generic functions
Method, key: Private generic functions
Method, long: Private generic functions
Method, long-options: Private generic functions
Method, manual: Private generic functions
Method, manual: Private generic functions
Method, manual: Private generic functions
Method, name: Private generic functions
Method, name: Private generic functions
Method, name: Private generic functions
Method, options: Private generic functions
Method, options: Private generic functions
Method, parameter: Private generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, problematic-option: Public generic functions
Method, reduce: Private generic functions
Method, result-key: Private generic functions
Method, short: Private generic functions
Method, short-options: Private generic functions
Method, summary: Private generic functions
Method, title: Private generic functions
Method, usage: Private generic functions

N
name: Private generic functions
name: Private generic functions
name: Private generic functions
name: Private generic functions

O
option-string: Private ordinary functions
option-troff: Private ordinary functions
optionp: Private ordinary functions
options: Private generic functions
options: Private generic functions
options: Private generic functions

P
parameter: Private generic functions
parameter: Private generic functions
parse-long: Private ordinary functions
parse-options: Public ordinary functions
parse-options-or-exit: Public ordinary functions
parse-short: Private ordinary functions
print-error-and-exit: Public ordinary functions
print-help: Public ordinary functions
print-help-and-exit: Public ordinary functions
print-manual: Public ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-option-help: Private ordinary functions
problematic-option: Public generic functions
problematic-option: Public generic functions

Q
quit-on-ctrl-c: Private macros

R
reduce: Private generic functions
reduce: Private generic functions
result-key: Private generic functions
result-key: Private generic functions

S
short: Private generic functions
short: Private generic functions
short-options: Private generic functions
short-options: Private generic functions
shortp: Private ordinary functions
split-paragraphs: Private ordinary functions
summary: Private generic functions
summary: Private generic functions
supply-new-value: Public ordinary functions

T
terminatorp: Private ordinary functions
title: Private generic functions
title: Private generic functions
treat-as-argument: Public ordinary functions

U
unrecognized-option-p: Private ordinary functions
usage: Private generic functions
usage: Private generic functions


A.3 Variables

Jump to:   E   F   G   H   I   K   L   M   N   O   P   R   S   T   U  
Index Entry  Section

E
examples: Private classes

F
finally: Private classes

G
groups: Private classes

H
help: Private classes
help: Private classes
help: Private classes

I
initial-value: Private classes

K
key: Private classes

L
long: Private classes
long-options: Private classes

M
manual: Private classes
manual: Private classes
manual: Private classes

N
name: Private classes
name: Private classes
name: Private classes

O
options: Private classes
options: Private classes

P
parameter: Private classes
problematic-option: Public conditions

R
reduce: Private classes
result-key: Private classes

S
short: Private classes
short-options: Private classes
Slot, examples: Private classes
Slot, finally: Private classes
Slot, groups: Private classes
Slot, help: Private classes
Slot, help: Private classes
Slot, help: Private classes
Slot, initial-value: Private classes
Slot, key: Private classes
Slot, long: Private classes
Slot, long-options: Private classes
Slot, manual: Private classes
Slot, manual: Private classes
Slot, manual: Private classes
Slot, name: Private classes
Slot, name: Private classes
Slot, name: Private classes
Slot, options: Private classes
Slot, options: Private classes
Slot, parameter: Private classes
Slot, problematic-option: Public conditions
Slot, reduce: Private classes
Slot, result-key: Private classes
Slot, short: Private classes
Slot, short-options: Private classes
Slot, summary: Private classes
Slot, title: Private classes
Slot, usage: Private classes
summary: Private classes

T
title: Private classes

U
usage: Private classes