The cl-jpl-util Reference Manual

Table of Contents

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

The cl-jpl-util Reference Manual

This is the cl-jpl-util Reference Manual, version 0.4, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 03:22:27 2018 GMT+0.


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

1 Systems

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


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

1.1 jpl-util

Maintainer

J.P. Larocque

Author

J.P. Larocque

License

ISC-style permissive

Description

Sundry utilities for J.P. Larocque.

Version

0.4

Source

jpl-util.asd (file)

Components

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

2 Files

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


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

2.1 Lisp


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

2.1.1 jpl-util.asd

Location

jpl-util.asd

Systems

jpl-util (system)


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

2.1.2 jpl-util/jpl-util.lisp

Dependencies
Parent

jpl-util (system)

Location

jpl-util.lisp

Exported Definitions
Internal Definitions

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

2.1.3 jpl-util/vector-delete.lisp

Dependencies
Parent

jpl-util (system)

Location

vector-delete.lisp

Exported Definitions
Internal Definitions

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

2.1.4 jpl-util/gensyms.lisp

Dependency

package.lisp (file)

Parent

jpl-util (system)

Location

gensyms.lisp

Exported Definitions

with-gensyms (macro)


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

2.1.5 jpl-util/types.lisp

Dependency

package.lisp (file)

Parent

jpl-util (system)

Location

types.lisp

Exported Definitions

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

2.1.6 jpl-util/accumulators.lisp

Dependencies
Parent

jpl-util (system)

Location

accumulators.lisp

Exported Definitions

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

2.1.7 jpl-util/iterators.lisp

Dependencies
Parent

jpl-util (system)

Location

iterators.lisp

Exported Definitions

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

2.1.8 jpl-util/subtypecase.lisp

Dependencies
Parent

jpl-util (system)

Location

subtypecase.lisp

Exported Definitions

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

2.1.9 jpl-util/option-clause.lisp

Dependencies
Parent

jpl-util (system)

Location

option-clause.lisp

Exported Definitions

option-clause-bind (macro)

Internal Definitions

option-clause-list->plist (function)


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

2.1.10 jpl-util/alists-and-plists.lisp

Dependencies
Parent

jpl-util (system)

Location

alists-and-plists.lisp

Exported Definitions

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

2.1.11 jpl-util/defclass-star.lisp

Dependencies
Parent

jpl-util (system)

Location

defclass-star.lisp

Exported Definitions

defclass* (macro)


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

2.1.12 jpl-util/order.lisp

Dependencies
Parent

jpl-util (system)

Location

order.lisp

Exported Definitions

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

2.1.13 jpl-util/package.lisp

Parent

jpl-util (system)

Location

package.lisp

Packages

jpl-util


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

3 Packages

Packages are listed by definition order.


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

3.1 jpl-util

Source

package.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

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

4 Definitions

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


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

4.1 Exported definitions


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

4.1.1 Special variables

Special Variable: *verbose*

Whether to be verbose when evaluating forms expressed in VERBOSELY.

Package

jpl-util

Source

jpl-util.lisp (file)


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

4.1.2 Macros

Macro: 1or &rest FORMS

Returns true if and only if exactly one of the given forms returns true. The single true value returned by one of the forms is returned. Each form is evaluated at most once, and the forms are evaluated in an unspecified order. If no forms are given, NIL is returned.

Package

jpl-util

Source

jpl-util.lisp (file)

Macro: accumulate-to-dynamic-vector (SET-ELEMENT-TYPE ACCUMULATE) &body BODY

Evaluates BODY, accumulating elements to a fresh vector, resulting in the vector (which will be adjustable and have a fill-pointer). The number of elements to be accumulated does not have to be determined before accumulation begins. The order of the elements of the resulting vector is the order in which they are accumulated.

The symbols given by SET-ELEMENT-TYPE and ACCUMULATE name lexically-defined macros:

(SET-ELEMENT-TYPE &optional ELEMENT-TYPE)
Must be evaluated once, before ACCUMULATE is evaluated for the first time.

ELEMENT-TYPE (evaluated) specifies the array element type of the resulting vector. The default is T. The result of accumulating an element not of type ELEMENT-TYPE is undefined.

(ACCUMULATE ELEMENT)
Accumulates ELEMENT (evaluated) to the vector. ACCUMULATE may be evaluated any number of times.

Package

jpl-util

Source

accumulators.lisp (file)

Macro: accumulate-to-hash-table (SET-TEST/SIZE ACCUMULATE) &body BODY

Evaluates BODY, accumulating key and value pairs to a fresh hash-table, resulting in the hash-table.

The symbols given by SET-TEST/SIZE and ACCUMULATE name lexically-defined macros:

(SET-TEST/SIZE TEST &optional SIZE)
Must be evaluated once, before ACCUMULATE is evaluated for the first time.

TEST (evaluated) must be a designator for one of the test functions acceptable to MAKE-HASH-TABLE.

If SIZE is specified and non-NIL, it is evaluated to produce a non-negative integer which specifies the expected number of unique entries to accumulate. The actual number of entries may vary, but accumulation may be slower or use more memory than if the size had been correctly predicted.

(ACCUMULATE KEY VALUE)
Accumulates an entry of KEY and VALUE (both evaluated) to the hash-table, replacing any previous entry with the same KEY. ACCUMULATE may be evaluated any number of times.

Package

jpl-util

Source

accumulators.lisp (file)

Macro: accumulate-to-list (ACCUMULATE) &body BODY

Evaluates BODY, accumulating elements to a fresh list, resulting in the list. The order of the elements of the resulting list is the order in which they are accumulated.

The symbol given by ACCUMULATE names a lexically-defined macro:

(ACCUMULATE ELEMENT)
Accumulates ELEMENT (evaluated) to the list. ACCUMULATE may be evaluated any number of times.

Package

jpl-util

Source

accumulators.lisp (file)

Macro: accumulate-to-vector (SET-SIZE/ELEMENT-TYPE ACCUMULATE) &body BODY

Evaluates BODY, accumulating elements to a fresh vector, resulting in the vector. The number of elements to be accumulated must be determined before accumulation begins. The order of the elements of the resulting vector is the order in which they are accumulated.

The symbols given by SET-SIZE/ELEMENT-TYPE and ACCUMULATE name lexically-defined macros:

(SET-SIZE/ELEMENT-TYPE SIZE &optional ELEMENT-TYPE)
Must be evaluated once, before ACCUMULATE is evaluated for the first time.

SIZE (evaluated) specifies the length of the resulting vector.
ELEMENT-TYPE (evaluated) specifies the array element type of the resulting vector. The default is T. The result of accumulating an element not of type ELEMENT-TYPE is undefined.

(ACCUMULATE ELEMENT)
Accumulates ELEMENT (evaluated) to the vector.

ACCUMULATE must never be evaluated more times than the size of the vector. At the time BODY returns normally, ACCUMULATE must have been called exactly the number of times as the size of the vector. ACCUMULATE may be evaluated fewer times when BODY makes a non-local exit.

Package

jpl-util

Source

accumulators.lisp (file)

Macro: check-type* EXPRESSION TYPESPEC &optional STRING

Like CHECK-TYPE, with two differences: this tests any expression, not just a place. If an error is signalled, it won’t be correctable.

Package

jpl-util

Source

jpl-util.lisp (file)

Macro: composite-lesser? &body CLAUSES

Returns a generalized boolean indicating whether one thing is less than another thing according to the rules defined by CLAUSES.

Each thing (neither of which is explicitly expressed as an argument) should conceptually be deconstructable to an equal number of comparable parts. Each part of both things is compared in parallel, beginning with the first part of the things, followed by the next part of the things, and so on. One thing is less than another thing when it has a part which is less than the other thing’s corresponding part, and all part pairs prior to the differing part pair compare as equal.

Each clause represents a part to test. A clause is of the form:

(TEST OBJ1 OBJ2)

OBJ1 and OBJ2 are expressions which produce parts of the first and second thing, respectively. TEST is evaluated to produce a function of two arguments, which is applied to the two objects (in both orders) to determine which one is lesser than the other, if any.

Additionally, the final clause may take the form:

(:OTHERWISE &body OTHERWISE-BODY)

When this is so, and no differences are found by testing each pair of parts, then the result–rather than NIL–is the evaluation of OTHERWISE-BODY as an implicit progn. This facilitates the comparison of two things which have a variable number of parts; OTHERWISE-BODY would test the tails of the parts which occur after the parts tested for with ordinary clauses.

TEST, OBJ1, and OBJ2 for any given clause, and OTHERWISE-BODY, will be evaluated at most once, but evaluation (and hence calling the function expressed by TEST) may be short-circuited if testing an earlier part proves that later part comparisons are irrelevant.

Package

jpl-util

Source

order.lisp (file)

Macro: csubtypecase KEY-PLACE &body CLAUSES

As with SUBTYPECASE, but signals a correctable error of type SUBTYPE-ERROR if no clause matches. The STORE-VALUE restart can be used to correct the error. No otherwise clause is allowed. Analogous to CTYPECASE.

Package

jpl-util

Source

subtypecase.lisp (file)

Macro: defclass* CLASS-NAME (&rest SUPERCLASS-NAMES) (&rest SLOT-SPECIFIERS) &rest CLASS-OPTIONS

Defines a class just like DEFCLASS does, but adds reasonable default options to each slot.

:INITARG is defined, with the slot name as a keyword.

:INITFORM is defined, with an ERROR form that signals a SIMPLE-ERROR with a generic message, "Must supply [INITARG]."

A reader, writer, or accessor is defined, with the same name as the slot. By default, a reader is defined; you may override the selection with the special slot option JPL-UTIL:ACCESSOR-TYPE, with a value of :READER, :WRITER, or :ACCESSOR. The name of the reader, writer, or accessor may be overridden with the special slot option JPL-UTIL:ACCESSOR-NAME. If either value of JPL-UTIL:ACCESSOR-TYPE or JPL-UTIL:ACCESSOR-NAME are NIL, then no reader, writer, or accessor is defined.

Any default slot option may be overridden by explicitly specifying a value for that slot option. For example, if you don’t like the default value for :INITFORM, you may specify :INITFORM NIL.

Default slot option may be omitted by giving the special slot option JPL-UTIL:OMIT-OPTIONS with a list of default slot option indicators to suppress. For example, if you don’t want an :INITFORM option, you may specify JPL-UTIL:OMIT-OPTIONS (:INITFORM).

Package

jpl-util

Source

defclass-star.lisp (file)

Macro: defvar-unbound NAME &optional DOC-STRING

Convenience macro to declare unbound special variables with a documentation string.

Package

jpl-util

Source

jpl-util.lisp (file)

Macro: doseq (VAR SEQUENCE-FORM &optional RESULT-FORM) &body BODY

Iterates over the elements of the sequence produced by evaluating SEQUENCE-FORM similarly to DOLIST.

BODY may be included in the expansion more than once, for specialization on the different types of sequences without the overhead of function calls.

Package

jpl-util

Source

jpl-util.lisp (file)

Macro: esubtypecase KEY-FORM &body CLAUSES

As with SUBTYPECASE, but signals SUBTYPE-ERROR if no clause matches. No otherwise clause is allowed. Analogous to ETYPECASE.

Package

jpl-util

Source

subtypecase.lisp (file)

Macro: lambda* ARGS &body BODY

Creates a function. Takes an extended, rather than an ordinary, lambda list.

Package

jpl-util

Source

jpl-util.lisp (file)

Macro: lesser? (VALUE1 VALUE2 LEAST-POSSIBLE-VALUE) &body BODY

Evaluates to whether VALUE1 is less than VALUE2 when there is the possibility that either are EQ to LEAST-POSSIBLE-VALUE. One value is always less than the other when it is EQ to LEAST-POSSIBLE-VALUE and the other is not. If the answer cannot be determined by comparing VALUE1 and VALUE2 with LEAST-POSSIBLE-VALUE, then BODY is evaluated.

VALUE1, VALUE2, and LEAST-POSSIBLE-VALUE may or may not be evaluated, and in any order. BODY is evaluated only when neither values are EQ to LEAST-POSSIBLE-VALUE.

Package

jpl-util

Source

order.lisp (file)

Macro: list-extract! LIST PREDICATE &key MAPPING-P

Returns those items in list that pass the predicate, removing them destructively from the input. When mapping-p is true, returns the result of the predicate function for each element, rather than the elements themselves.

Package

jpl-util

Source

jpl-util.lisp (file)

Macro: option-clause-bind LAMBDA-LIST EXPRESSION &body BODY

Evaluates EXPRESSION to produce a list of "option clauses," then evaluates BODY with the variables of LAMBDA-LIST bound to the values of the option clauses.

An option clause is a cons of the form (NAME . VALUE), where each NAME is unique. A list of option clauses looks a lot like an association list, with the difference being that no value is allowed to be the NAME of more than one option clause.

Although the term "option clause" is not used in the Common Lisp HyperSpec, the syntax of some Common Lisp macros call for expressing options in this style. DEFCLASS and DEFGENERIC are among these macros.

LAMBDA-LIST is just like a sequence of variable specifications in the &KEY section of a destructuring lambda list. Each member of LAMBDA-LIST designates one value of NAME to match from the list of option clauses, and must take one of the following forms:

VAR

If the keyword name appears as the name of an option clause, VAR is bound to the value of that option clause. Otherwise, VAR is bound to NIL.

The keyword name is a keyword with the same name as VAR.

VAR must be a symbol which is not a lambda list keyword.

({VAR | (KEYWORD-NAME VAR)} [INIT-FORM [SUPPLIED-P-PARAMETER]])
If the keyword name appears as the name of an option clause, VAR is bound to the value of that option clause. Otherwise, if INIT-FORM is supplied, VAR is bound to the result of evaluating INIT-FORM. Otherwise, VAR is bound to NIL.

SUPPLIED-P-PARAMETER, when supplied, is bound to a boolean value indicating whether a matching option clause was found. When the bound value is true, INIT-FORM will not have been evaluated. When the value is false, INIT-FORM (if supplied) will have been evaluated.

When KEYWORD-NAME is supplied, it is used as the keyword name; otherwise, a keyword with the same name as VAR is used.

When supplied, VAR and SUPPLIED-P-PARAMETER must be symbols, INIT-FORM must be a form, and KEYWORD-NAME may be any value.

For example:

(option-clause-bind (foo bar) ’((:foo 1 2) (:bar 3)) . BODY) == (destructuring-bind (&key foo bar) ’(:foo (1 2) :bar (3)) . BODY)

Due to the constraint that NAMEs must be unique, note that:

(option-clause-bind VARS EXPRESSION . BODY) NOT== (destructuring-bind (&key . VARS) (alist->plist EXPRESSION) . BODY)

Package

jpl-util

Source

option-clause.lisp (file)

Macro: push-append LIST PLACE

Prepends the contents of LIST onto the list stored in PLACE. The resulting list is stored in PLACE and then returned.

Package

jpl-util

Source

jpl-util.lisp (file)

Macro: push-nconc LIST PLACE

Destructively prepends the contents of LIST onto the list stored in PLACE. The resulting list is stored in PLACE and then returned.

Package

jpl-util

Source

jpl-util.lisp (file)

Macro: subtypecase KEY-FORM &body CLAUSES

Evaluates the code associated with the first clause which lists a type which KEY-FORM (which is evaluated) a recognizable subtype of. If there is no match, NIL is returned. SUBTYPECASE is to SUBTYPEP as TYPECASE is to TYPEP.

The syntax of clauses, including the syntax of an optional trailing otherwise-clause, is the same as in TYPECASE.

Package

jpl-util

Source

subtypecase.lisp (file)

Macro: verbosely (CONTROL-STRING &rest FORMAT-ARGUMENTS) &body BODY
Package

jpl-util

Source

jpl-util.lisp (file)

Macro: with-accessors* (&rest ACCESSORS) INSTANCE-FORM &body BODY

Like WITH-ACCESSORS, except that instead of giving (VARIABLE-NAME ACCESSOR-NAME) for each accessor, you may give VARIABLE-NAME, in which case ACCESSOR-NAME is derived from it.

Package

jpl-util

Source

jpl-util.lisp (file)

Macro: with-extent-hooks (ENTER RETURN NON-LOCAL-EXIT) &body BODY

Evaluates BODY, and evaluates the given forms upon certain situations relating to the dynamic extent of the evaluation of BODY.

ENTER must be a form. Just before dynamic extent enters BODY, ENTER is evaluated. The return values of ENTER are discarded.

RETURN must be a list of the form (LAMBDA-LIST &BODY RETURN-BODY), or NIL. If BODY returns and RETURN is not NIL, RETURN-BODY (an implicit progn) is evaluated with the variables of LAMBDA-LIST (an ordinary lambda list) bound to the return values of BODY. The return values of RETURN-BODY are discarded. The return values of BODY are returned by WITH-EXTENT-HOOKS.

NON-LOCAL-EXIT must be a form. If dynamic extent leaves BODY due to a non-local exit (including due to a signalled condition), NON-LOCAL-EXIT is evaluated. The return values of NON-LOCAL-EXIT are discarded.

Package

jpl-util

Source

jpl-util.lisp (file)

Macro: with-gensyms (&rest NAMES) &body BODY

Evaluates BODY with each variable name of NAMES bound to a unique, fresh, uninterned symbol.

Package

jpl-util

Source

gensyms.lisp (file)

Macro: with-list-iterator (NEXT SIZE EXHAUSTED? LIST-FORM) &body BODY

Evaluates BODY with an iterator on a list.

LIST-FORM is evaluated once to produce the list to iterate upon. The resulting list is never modified (unless from within BODY–the consequences of which are undefined).

The symbols given by NEXT, SIZE, and EXHAUSTED? name lexically-defined macros:

(NEXT)
Yields the next successive element of the list. The consequences of evaluating (NEXT) more times than the length of the list is undefined.

(SIZE)
Evaluates to the length of the list. The list is only traversed for only the first evaluation; the length is memoized.

(EXHAUSTED?)
Evaluates to a generalized boolean indicating whether the list has been exhausted by evaluations of (NEXT).

Package

jpl-util

Source

iterators.lisp (file)

Macro: with-range-iterator (NEXT SIZE EXHAUSTED? LOWER-FORM UPPER-FORM) &body BODY

Evaluates BODY with an iterator on a range of integers.

LOWER-FORM and UPPER-FORM are evaluated once to produce the range of integers, [LOWER,UPPER), to iterate upon.

The symbols given by NEXT, SIZE, and EXHAUSTED? name lexically-defined macros:

(NEXT)
Yields the next successive element of the range. The consequences of evaluating (NEXT) more times than the length of the range is undefined.

(SIZE)
Evaluates to the length of the range.

(EXHAUSTED?)
Evaluates to a generalized boolean indicating whether the range has been exhausted by evaluations of (NEXT).

Package

jpl-util

Source

iterators.lisp (file)

Macro: with-safe-alloc (VAR ALLOC FREE) &rest BODY

Binds VAR to NIL, then sets it to the result of evaluating ALLOC. Upon exit of dynamic extent, as long as the value of VAR is not NIL (such as by a condition signalled by evaluating ALLOC), FREE is evaluated.

Package

jpl-util

Source

jpl-util.lisp (file)

Macro: with-sequence-iterator (NEXT SIZE EXHAUSTED? SEQUENCE-FORM) &body BODY

Evaluates BODY with an iterator on a SEQUENCE.

SEQUENCE-FORM is evaluated once to produce the sequence to iterate upon. The resulting sequence is never modified (unless from within BODY–the consequences of which are undefined). If the sequence is a vector with a fill-pointer, the fill-pointer is respected.

The symbols given by NEXT, SIZE, and EXHAUSTED? name lexically-defined macros:

(NEXT)
Yields the next successive element of the sequence. The consequences of evaluating (NEXT) more times than the length of the sequence is undefined.

(SIZE)
Evaluates to the length of the sequence.

(EXHAUSTED?)
Evaluates to a generalized boolean indicating whether the sequence has been exhausted by evaluations of (NEXT).

Package

jpl-util

Source

iterators.lisp (file)

Macro: with-trace (&optional ID) &body BODY

Like TRACE, but for the given body of code. Specify an ID (a number or symbol) to avoid the conceptually-same code from clogging up the output of LIST-TRACES as this code gets redefined several times.

Package

jpl-util

Source

jpl-util.lisp (file)

Macro: with-vector-iterator (NEXT SIZE EXHAUSTED? VECTOR-FORM) &body BODY

Evaluates BODY with an iterator on a vector.

VECTOR-FORM is evaluated once to produce the vector to iterate upon. The resulting vector is never modified (unless from within BODY–the consequences of which are undefined). If the vector has a fill-pointer, it is respected.

The symbols given by NEXT, SIZE, and EXHAUSTED? name lexically-defined macros:

(NEXT)
Yields the next successive element of the vector. The consequences of evaluating (NEXT) more times than the length of the vector is undefined.

(SIZE)
Evaluates to the length of the vector.

(EXHAUSTED?)
Evaluates to a generalized boolean indicating whether the vector has been exhausted by evaluations of (NEXT).

Package

jpl-util

Source

iterators.lisp (file)

Macro: with-verbosity (&optional VERBOSE) &body BODY
Package

jpl-util

Source

jpl-util.lisp (file)

Macro: xor &rest FORMS

Returns the logical exclusive-or of the generalized boolean value of each form: true if and only if there are an even number of forms that return true. Each form is evaluated once, and the forms are evaluated in an unspecified order. If no forms are given, NIL is returned.

Package

jpl-util

Source

jpl-util.lisp (file)


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

4.1.3 Compiler macros

Compiler Macro: compose &rest FUNCTION-EXPRS
Package

jpl-util

Source

jpl-util.lisp (file)

Compiler Macro: compose-1v &rest FUNCTION-EXPRS
Package

jpl-util

Source

jpl-util.lisp (file)


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

4.1.4 Functions

Function: a/an-number N

Given a non-negative integer that will be expressed as a cardinal or ordinal number in English–either by FORMAT-ORDINAL or the ~R or ~:R format directives–returns either "a" or "an", whichever is appropriate to precede the number.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: adjacent-pairs SEQUENCE

For each two adjacent pairs of elements in the given SEQUENCE, return them as a list.

If SEQUENCE has less than 2 elements, returns the empty list. Otherwise, returns (1- (LENGTH SEQUENCE)) pairs.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: alist->hash-table ALIST &key TEST
Package

jpl-util

Source

alists-and-plists.lisp (file)

Function: alist->plist ALIST &key KEY TEST

Converts the given association list to a fresh property list.

KEY and TEST are applied to the CARs of the entries of ALIST for uniqueness-checking; see ITERATE-ALIST.

Package

jpl-util

Source

alists-and-plists.lisp (file)

Function: all SEQUENCE &key KEY

Returns the logical-and of all the generalized booleans in the given sequence.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: any SEQUENCE &key KEY

Returns the logical-or of all the generalized booleans in the given sequence.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: assoc* ITEM ALIST &key KEY TEST DEFAULT

Like ASSOC, but returns the CDR of the matching entry, or DEFAULT if there was no match. (ASSOC* ...) is a SETF-able place.

e.g.
(defparameter *test-alist* ’())
=> *TEST-ALIST*
(assoc* ’a *test-alist*)
=> NIL
(push 1 (assoc* ’a *test-alist*))
=> (1)
(push 2 (assoc* ’a *test-alist*))
=> (2 1)
(assoc* ’a *test-alist*)
=> (2 1)
*test-alist*
=> ((A 2 1))
(setf (assoc* ’b *test-alist*) ’notalist)
=> NOTALIST
(setf (assoc* ’a *test-alist*) ’notalist)
=> NOTALIST
(assoc* ’a *test-alist*)
=> NOTALIST
*test-alist*
=> ((B . NOTALIST) (A . NOTALIST))

Package

jpl-util

Source

alists-and-plists.lisp (file)

Setf Expander

(setf assoc*) (setf expander)

Setf Expander: (setf assoc*) ITEM ALIST &key KEY TEST DEFAULT
Package

jpl-util

Source

alists-and-plists.lisp (file)

Reader

assoc* (function)

Function: best SET PREDICATE &key KEY ALLOW-EMPTY

Finds the best element in the given SET of elements (a SEQUENCE). The given PREDICATE function of two arguments must return whether the first "applicable value" represents a better item than the item represented by the second applicable value.

Elements are their own applicable value unless KEY is supplied.

When ALLOW-EMPTY, SET may be empty, in which case NIL is returned. Otherwise, an error is signalled.

This is more efficient than sorting and taking the first item from the result, and it is more general than MIN and MAX.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: check-bounding-indices START-REQ END-REQ START-ACTUAL END-ACTUAL LENGTH &key SEQUENCE-DESC
Package

jpl-util

Source

jpl-util.lisp (file)

Function: circular-list LIST

Returns a fresh circular list that cycles through the contents of LIST indefinitely. If LIST is empty, the result will be empty (and hence not actually circular). LIST must be a proper list; if LIST is circular, this function may not return.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: clear-traces! ()

Because we can’t tell whether code being traced with WITH-TRACE is still active in the system, or it’s been redefined to something else with a new trace-ID, *expr-traces-by-id* always grows. It grows only when WITH-TRACE is macroexpanded, so you should not normally need this function.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: coerce-boolean B

Normalizes the given generalized boolean to a boolean–that is, non-NIL maps to T, and NIL maps to NIL.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: combine-elements SEQUENCE PREDICATE COMBINATION-FN

Conditionally combines the elements of sequence to form a new list. When two adjacent elements each individually pass the predicate, the combination-fn is called on both of them, in the order that they appear in the sequence, to form a new replacement item. That replacement item is subject to further combination.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: compose &rest FUNCTIONS

Returns the composition of a sequence of functions (designated by FUNCTIONS), yielding a new function. The new function passes all its arguments to the last given function. Each other given function gets called, from last to first, with the values of the call of its successive function. The new function returns all the values returned by the first given function.

For single-argument functions a and b, and single-value functions b and c:
(FUNCALL (COMPOSE a b c) x y z) == (a (b (c x y z)))
For any function f:
(COMPOSE f) == f
For any values x, y, and z:
COMPOSE == VALUES
(FUNCALL (COMPOSE)) => ; no value
(FUNCALL (COMPOSE) x) => x
(FUNCALL (COMPOSE) x y z) => x y z

Package

jpl-util

Source

jpl-util.lisp (file)

Function: compose-1v &rest FUNCTIONS

Like COMPOSE, but restricted to (and optimized for) functions that accept only one argument. The resulting function accepts only one argument, and only the primary return value of each of the latter given functions is given to their preceding functions. The resulting function returns all the values returned by the first given function.

For single-argument functions a and b, and single-value functions b and c:
(FUNCALL (COMPOSE-1V a b c) x) == (a (b (c x)))
For any function f of one argument:
(COMPOSE f) == f
For any value x:
COMPOSE == IDENTITY
(FUNCALL (COMPOSE) x) => x

Package

jpl-util

Source

jpl-util.lisp (file)

Function: cond-replace SEQUENCE1 TEST-SEQUENCE NEW-SEQUENCE &key TEST KEY SEQUENCE1-START SEQUENCE1-END TEST-SEQUENCE-START TEST-SEQUENCE-END NEW-SEQUENCE-START NEW-SEQUENCE-END

Tests whether SEQUENCE1 is equal to TEST-SEQUENCE according to TEST and KEY. When they are equal, destructively replaces SEQUENCE1 with the contents of NEW-SEQUENCE, and returns the modified SEQUENCE1 and T. Otherwise, returns SEQUENCE1 (unmodified) and NIL.

If SEQUENCE1 and TEST-SEQUENCE match, and if the lengths of TEST-SEQUENCE and NEW-SEQUENCE differ, SEQUENCE1 will be resized accordingly.

When SEQUENCE1 is a vector and doesn’t need to be adjusted to a different size, or is actually adjustable, or has a fill pointer which either needs to be decreased or needs to be increased within the dimensions of the vector, then the resulting sequence is guaranteed to be identical to SEQUENCE1. Otherwise, the resulting sequence may differ from SEQUENCE1 and should replace it.

SEQUENCE1, TEST-SEQUENCE, and NEW-SEQUENCE are bounded by SEQUENCE1-START and SEQUENCE1-END, by TEST-SEQUENCE-START and TEST-SEQUENCE-END, and by NEW-SEQUENCE-START and NEW-SEQUENCE-END, respectively.

Only guaranteed to be efficient on vectors.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: curry-left FUNCTION &rest LEFT-ARGS

Partially applies each of LEFT-ARGS to FUNCTION, yielding a new function of the rest of the arguments accepted by FUNCTION.

(CURRY-LEFT f) == f ; Equivalent, but not identical. (FUNCALL (CURRY-LEFT f a)) == (FUNCALL f a)
(FUNCALL (CURRY-LEFT f a b c) d e f) == (FUNCALL f a b c d e f)

Package

jpl-util

Source

jpl-util.lisp (file)

Function: curry-right FUNCTION &rest RIGHT-ARGS

Partially applies each of RIGHT-ARGS as the last arguments to function, in left-to-right order, yielding a new function of the rest of the arguments accepted by FUNCTION.

(CURRY-RIGHT f) == f ; Equivalent, but not identical. (FUNCALL (CURRY-RIGHT f a)) == (FUNCALL f a)
(FUNCALL (CURRY-RIGHT f a b)) == (FUNCALL f a b)
(FUNCALL (CURRY-RIGHT f d e f) a b c) == (FUNCALL f a b c d e f)

Package

jpl-util

Source

jpl-util.lisp (file)

Function: decode-time-duration DURATION &key SUBSECOND-DIGITS ROUNDING

Breaks down a duration of time (as a non-negative REAL number of seconds), returning days, hours, minutes, seconds, and subseconds.

The days, hours, and minutes values will be integers, while the seconds value may be fractional (the same type as DURATION) if DURATION is fractional and SUBSECOND-DIGITS is NIL; otherwise, the seconds value will be an integer.

When SUBSECOND-DIGITS is NIL, the subseconds value will be NIL and the seconds value will be of the same type as DURATION. Otherwise, SUBSECOND-DIGITS must be a non-negative integer that indicates to how many decimal places subsecond precision will be kept, and the subseconds value will be the true amount of subseconds (in [0,1), rounded according to ROUNDING and SUBSECOND-DIGITS, and expressed as a non-negative integer below (EXPT 10 SUBSECOND-DIGITS).

ROUNDING is a symbol that controls how subseconds values are rounded, and may be FLOOR, CEILING, ROUND, or TRUNCATE.

Days in which no leap seconds occur are assumed. (That is, the returned number of days assumes 24 hours in one day, which does not hold true on leap seconds days.)

Package

jpl-util

Source

jpl-util.lisp (file)

Function: delete-nth! N LIST
Package

jpl-util

Source

jpl-util.lisp (file)

Function: designated-class CLASS-DESIGNATOR
Package

jpl-util

Source

types.lisp (file)

Function: designated-function EXTENDED-DESIGNATOR
Package

jpl-util

Source

types.lisp (file)

Function: duplicates-p SEQUENCE &key TEST START END KEY

Returns whether there are duplicates in the given sequence.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: empty? SEQ

Returns a generalized boolean indicating whether SEQ (a SEQUENCE) is empty.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: english-list-format-control &optional ELEMENT-FORMAT RELATION

Creates a format control to format its operands as a list in English. Expects at least one operand.

Each operand will be formatted with ELEMENT-FORMAT, a format control that consumes one argument. ELEMENT-FORMAT defaults to "~A".

RELATION is a string which describes the relation between each element, such as "and" (the default for RELATION) or "or."

Package

jpl-util

Source

jpl-util.lisp (file)

Function: ensure-type VALUE TYPESPEC &optional STRING

A functional variant of CHECK-TYPE. When VALUE is of the type specified by TYPESPEC, returns VALUE. Otherwise, signals a correctable error of type TYPE-ERROR. In this case, this function will return only if the STORE-VALUE restart is invoked with a new value that matches TYPESPEC; the new value will be returned. If STORE-VALUE is invoked with a new value that doesn’t match TYPESPEC, the process continues by raising another TYPE-ERROR.

As with CHECK-TYPE, "STRING should be an English description of the type, starting with an indefinite article (’a’ or ’an’)."

Package

jpl-util

Source

jpl-util.lisp (file)

Function: eof-p STREAM
Package

jpl-util

Source

jpl-util.lisp (file)

Function: equivalent-hash-table-test TEST

Given a designator of a test function (one that returns a generalized boolean indicating whether its two arguments are equal), tries to find an alternative function that can be used as a hash-table test, returning two values: a semantically-equivalent function of two arguments, and a generalized boolean indicating whether the returned function is a valid hash-table test function.

The returned function will behave the same as the given designated function whenever it is given arguments which would be valid for the original function. If the returned function is given invalid arguments, it might not signal an error in situations that the original function would have.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: find-duplicates SEQUENCE &key TEST KEY

Returns all duplicates in SEQUENCE, according to the TEST and KEY. Each item that appears anywhere else in the sequence is counted.

If TEST is a standard Common Lisp function that only applies to certain types (such as numbers, strings, or characters), a substitute test may be used in order to enable fast linear-time duplicate search with a hash-table. In this case, if any element of SEQUENCE is not appropriate for TEST, and TEST would normally signal an error, the result of this function is undefined.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: format-ordinal N

Formats n to a short-hand ordinal: 1st, 2nd, etc.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: format-time-duration SECONDS &key SUBSECOND-DIGITS ROUNDING

Breaks down the given number of seconds into day, hour, minute, and seconds components, formatting it as a string. The number of seconds may be negative.

FRAC-DIGITS is the number of digits to show after the decimal point of the seconds component (with the decimal point elided if 0). ROUNDING is a symbol that controls how subsecond precision is handled: it may be either FLOOR, CEILING, ROUND, or TRUNCATE.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: fractional INPUT DENOMINATORS

Finds the closest approximation of INPUT of the form (+ I (/ N D)), where I is an integer with the same sign as INPUT, N is a numerator of the same sign as INPUT, and D is a denominator from the non-empty list of positive integers DENOMINATORS. Returns the values I, N, and D.

For example, with DENOMINATORS equal to (2 3 4), here are
some results from example values of INPUT:

0.5 => 0 1 2
3.667 => 3 2 3
365.2425 => 365 1 4

It is conventional to express U.S. customary units with fractions, rather than decimal numbers. You can use FRACTIONAL to do this:

(defun format-inches (stream inches)
(multiple-value-bind (i n d)
(jpl-util:fractional inches ’(2 4 8 16))
;; If you’re really clever, I’m sure you can squeeze this into ;; one big FORMAT control.

;; Explicitly print minus sign, rather than use the sign of i, ;; in-case i is zero but n is negative.
(when (minusp inches)
(princ #- stream))
(princ (abs i) stream)
(unless (zerop n)
(format stream " ~D/~D" (abs n) d))
(princ " in" stream))
(values))

(format-inches t -0.07) => -0 1/16 in
(format-inches t 3.882) => 3 7/8 in
(format-inches t 11.997) => 12 in

Package

jpl-util

Source

jpl-util.lisp (file)

Function: get-reasonable-real-time ()

Returns the current real time in seconds, possibly with sub-second precision. Not guaranteed to be CL universal time.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: get-reasonable-run-time ()

Returns the current CPU time in seconds, possibly with sub-second precision. Not guaranteed to be CL universal time.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: group-by-n LIST N

Groups elements in the given LIST into lists that are N elements in length. The number of elements in list must be a multiple of N.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: hash-table->alist HT
Package

jpl-util

Source

alists-and-plists.lisp (file)

Function: insert-at LIST N ITEM

Returns a new list with the given ITEM inserted into the LIST at position N.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: integer->twos-complement N &optional SIZE-MULTIPLE

Returns the representation of N in two’s complement, as a bit-array. If SIZE-MULTIPLE is given, the length of the result will be a multiple of SIZE-MULTIPLE.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: integer-digit-count N &optional RADIX

Returns the number of digits required to represent the given non-negative integer in RADIX.

(integer-digit-count N RADIX) == (length (integer-digits N RADIX))

Package

jpl-util

Source

jpl-util.lisp (file)

Function: integer-digits INT &optional RADIX

Expresses the given non-negative integer as a fresh list of digits in the given radix. The list of digits is ordered most-significant first. When INT is 0, a list with just 0 is returned.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: iterate-alist VISIT ALIST &key KEY TEST

Iterates the entries of given association list, calling VISIT with the CAR and CDR of each entry. To match the semantics of ASSOC, only the first entry that matches (according to TEST) any given CAR (after applying KEY) is visited.

Package

jpl-util

Source

alists-and-plists.lisp (file)

Function: iterate-plist VISIT PLIST

Iterates the properties of the given property list, calling VISIT with the indicator and value of each property. As Common Lisp property list semantics prescribe, only the first property that matches any given property indicator is visited.

Package

jpl-util

Source

alists-and-plists.lisp (file)

Function: list-traces &key STREAM PACKAGES
Package

jpl-util

Source

jpl-util.lisp (file)

Function: map-adjacent-pairs RESULT-TYPE FUNCTION SEQUENCE

Applies FUNCTION to every adjacent pair of elements in SEQUENCE (in sequence). Returns NIL if RESULT-TYPE is NIL, otherwise returns a sequence of the values obtained by each call of FUNCTION. The type of SEQUENCE is as in MAP.

If SEQUENCE has less than 2 elements, FUNCTION is never called. Otherwise, it is called (1- (LENGTH SEQUENCE)) times.

The consequence of FUNCTION modifying SEQUENCE is undefined.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: map-lines FUNC STREAM
Package

jpl-util

Source

jpl-util.lisp (file)

Function: mean SEQUENCE

Returns the arithmetic mean of SEQUENCE. Each element of SEQUENCE must be a number.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: merge-alists ALISTS &key TEST TEST-NOT MERGE FROM-END INITIAL-VALUE

Merges the given list of association lists.

All unique keys are collected and represented in the returned alist. For each key, the associated value will be the reduction of all of the values (in sequence) for that key found in the input alists. Values are reduced using REDUCE with the function MERGE (defaulting to #’APPEND), the list of collected values matching a key, and the values of FROM-END (defaulting to T) and INITIAL-VALUE (unspecified by default).

The order of the keys in the resulting alist is undefined.

Package

jpl-util

Source

alists-and-plists.lisp (file)

Function: nsort SEQUENCE PREDICATE &key KEY
Package

jpl-util

Source

jpl-util.lisp (file)

Function: nstable-sort SEQUENCE PREDICATE &key KEY
Package

jpl-util

Source

jpl-util.lisp (file)

Function: nth-arg N

Returns a function which returns its Nth argument. Useful when composing a function with a function that returns multiple values.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: package< PACKAGE1 PACKAGE2

Returns a boolean indicating whether PACKAGE1 is lesser than PACKAGE2 (each are either PACKAGEs or NIL) according to the order specified below.

The order of packages is: NIL, then any PACKAGE with no name, then the KEYWORD package, then the sequence of all other packages ordered by STRING< on their names.

Package

jpl-util

Source

order.lisp (file)

Function: parse-progn BODY &key ALLOW-DOCSTRING-P

Given an implicit progn that may begin with an optional documentation string and any number of declarations (in any order), returns three values: the documentation string (or NIL if there isn’t any), a list of DECLARE expressions, and the rest of the list after the initial docstring and declarations. DECLARE expressions and a documentation string are only recognized within the initial segment; documentation strings may appear there only once.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: parse-sequence-type TYPE

Given a type specifier which is a subtype of SEQUENCE, returns the primary sequence type (LIST or VECTOR), the element type, and the sequence length (or * for unbounded length).

If either of the latter two parameters cannot be determined, the least restricting value is used: T for element type, and * for length.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: parse-vector-type TYPE

Given a type specifier which is a recognizable subtype of VECTOR, returns the element type and the sequence length (or * for unbounded length).

If either of these parameters cannot be determined, the least restricting value is used: T for element type, and * for length.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: partition-list LIST &key TEST KEY

Partitions LIST into a list of sublists according to whether adjacent elements pass the test. Adjacent elements which pass the test are placed into the same sublist.

Two adjacent elements A and B (in that order) pass the test when applying TEST to the key of A and the key of B results in a true generalized boolean value. The key of an element is produced by applying KEY to the element.

The result is a list of sublists. Every adjacent pair of elements A and B in a resulting sublist pass the test:

(... (... A B ...) ...) (funcall TEST A* B*) returns true

Every pair of elements A and B, where A ends a resulting sublist and B begins the subsequent sublist, do not pass the test:

(... (... A) (B ...) ...) (funcall TEST A* B*) returns false

The first element of the first resulting sublist is the first element of LIST. The last element of the last resulting sublist is the last element of LIST. If LIST is empty, then the resulting list of sublists is also empty.

The returned list of sublists, as well as each of its sublists, is freshly-allocated.

For set partitioning, see PARTITION-SET.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: partition-set SET &key TEST KEY ORDERED-P

Groups elements in SET (a list) according to whether they are equal according to TEST. The result is a set of sets, represented as a fresh list of fresh lists: each contained set contains a member of SET, and every member of each such set will be equal to every other member of that same set (according to TEST).

When ORDERED-P is true, the order of the returned list of sets is the order in which the first element of each set is seen in SET. Furthermore, the order of each element in each returned set is the order in which that element was seen in SET. Preserving the order with ORDERED-P incurs a small constant-factor speed penalty.

TEST must be consistent. For any elements x y and z in SET, when x and y are equal according to TEST, and y and z are equal according to TEST, x and z must also be equal according to TEST.

The result of applying KEY each element is used for TEST.

For pairwise partitioning, see PARTITION-LIST.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: plist->alist PLIST

Converts the given property list to a fresh asssociation list.

Package

jpl-util

Source

alists-and-plists.lisp (file)

Function: proper-list? X

Returns a generalized boolean indicating whether the given object (of any actual type) is a proper list. When it is, the true value returned is the length of the list.

The differences between this and LIST-LENGTH are that this function will accept objects of any type, and this function will return false for dotted lists.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: read-lines STREAM
Package

jpl-util

Source

jpl-util.lisp (file)

Function: read-new-value ()

Prompts the user on *QUERY-IO* for a value. The value is expressed by the user as a single form, which is evaluated. The first resulting value, or NIL if there was no value, is returned as a list of one element.

Intended for :INTERACTIVE options to RESTART-CASE clauses.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: remove-duplicate-properties PLIST

Removes properties from the given property list that are superceded by properties with the same indicator occurring earlier in the property list.

Package

jpl-util

Source

alists-and-plists.lisp (file)

Function: remove-ordered-duplicates SEQUENCE SORT-PREDICATE &key TEST START END KEY SORT-KEY COMPARISON-KEY
Package

jpl-util

Source

jpl-util.lisp (file)

Function: set-equal LIST1 LIST2 &key KEY TEST

Returns a generalized boolean indicating whether LIST1 and LIST2, when taken as unordered sets, contain exactly the same set of items (according to TEST). Duplicates either in LIST1 or in LIST2 are ignored.

KEY, when not NIL, is a function of one argument, an element from either LIST1 or LIST2. KEY is used to produce an object representative of the input element, to pass to TEST. If KEY is NIL, the elements from LIST1 and LIST2 are used directly (as if KEY is #’IDENTITY).

TEST is a function of two arguments, the KEY of an element from LIST1 and the KEY of an element from LIST2 (or vice versa), which returns a generalized boolean indicating whether the two objects should be considered to be the same.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: shuffle SEQUENCE
Package

jpl-util

Source

jpl-util.lisp (file)

Function: shuffle! SEQUENCE

Shuffles the given sequence in-place.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: sort SEQUENCE PREDICATE &key KEY
Package

jpl-util

Source

jpl-util.lisp (file)

Function: split-list! POS LIST

Destructively splits LIST into two parts: the part before position POS and the part after it. Returns the two resulting parts.

POS must be at least 0 and no greater than the length of LIST.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: square X
Package

jpl-util

Source

jpl-util.lisp (file)

Function: stable-sort SEQUENCE PREDICATE &key KEY
Package

jpl-util

Source

jpl-util.lisp (file)

Function: standard-deviation SEQUENCE

Returns the standard deviation of SEQUENCE. Each element of SEQUENCE must be a number.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: string-begin-equal STRING SUBSTRING &key START1 END1 START2 END2
Package

jpl-util

Source

jpl-util.lisp (file)

Function: string-begin= STRING SUBSTRING &key START1 END1 START2 END2
Package

jpl-util

Source

jpl-util.lisp (file)

Function: string-end-equal STRING SUBSTRING &key START1 END1 START2 END2
Package

jpl-util

Source

jpl-util.lisp (file)

Function: string-end= STRING SUBSTRING &key START1 END1 START2 END2
Package

jpl-util

Source

jpl-util.lisp (file)

Function: subseq* SEQUENCE START &optional END

Like subseq, but shares structure with the input sequence (where possible).

Package

jpl-util

Source

jpl-util.lisp (file)

Function: subseq-displace VECTOR START &optional END

Like subseq, but for vectors, returning a displaced vector which shares structure with the given vector.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: symbol< SYMBOL1 SYMBOL2

Returns a boolean indicating whether SYMBOL1 is lesser than SYMBOL2 (each are symbols) according to the order specified below.

A symbol is considered as the pair of its home package (or NIL if the symbol is "apparently uninterned") and its name. The two symbols are compared as their two pairs.

When the package of SYMBOL1 is less than that of SYMBOL2, SYMBOL1 is considered less than SYMBOL2, regardless of the symbol names–and vice-versa.

When the packages of SYMBOL1 and SYMBOL2 are considered equal, SYMBOL1 is less than SYMBOL2 iff the name of SYMBOL1 is STRING< that of SYMBOL2.

Packages are compared with PACKAGE<.

Package

jpl-util

Source

order.lisp (file)

Function: test-order-pred PREDICATE ELEMENTS

Tests PREDICATE, an order predicate, with the given sequence of elements. Signals an error if an inconsistency is found. Otherwise, returns a vector of the items sorted in ascending order.

An order predicate is a function of two arguments which returns a generalized boolean indicating whether the first argument is less than the second. It’s the kind of function you would give to SORT.

Package

jpl-util

Source

order.lisp (file)

Function: twos-complement->integer BIT-VECTOR

Returns the integer represented in two’s complement within BIT-VECTOR.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: unique-pairs LIST &optional PREDICATE

Returns the set of each possible ordered pair of elements in LIST. Each ordered pair is represented as a list. The returned set is represented as a list.

When PREDICATE is given and not NIL, it must be function. PREDICATE is applied to each pair of elements to filter them from the result set; pairs for which PREDICATE returns false are omitted.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: vector-delete VECTOR INDEX &optional NIL-P

Destructively removes the element specified at INDEX from VECTOR in constant time. VECTOR must have a fill pointer; it is updated. INDEX must be less than the length of VECTOR (according to its fill pointer).

When NIL-P is true or not given, elements made to be
unreferenced (outside the active region denoted by the fill-pointer) are overwritten with NIL, to prevent holding onto potentially big objects, which would keep them from garbage collection indefinitely. When NIL-P is false, the set of elements within VECTOR will remain the same–only reordering and fill-pointer manipulation will occur. Generally, NIL-P should be false only when VECTOR shares structure with another vector (via displacement) or its fill-pointer will later be artificially manipulated in order to recover deleted objects.

The order of elements within VECTOR should be mostly insignificant, such as when VECTOR represents a set of objects, because elements are reordered. Specifically, the last element of VECTOR and the element at INDEX are swapped. Therefore, after returning, the positions of the element at INDEX and the element just past the fill-pointer may be different (with the exception that the element just past the fill-pointer will be NIL when NIL-P is true); other elements will retain their position. (This apparent implementation detail is explicitly specified to allow for specific algorithms and bookkeeping that depends on the indices of VECTOR.)

Package

jpl-util

Source

vector-delete.lisp (file)

Function: vector-delete-range VECTOR &key START END

Destructively removes a subsequence of elements, specified by START and END, from VECTOR, in time linear proportional to the length of the subsequence. VECTOR must have a fill pointer; it is updated. START and END must be bounding indices with the length of VECTOR (according to its fill pointer).

The order of elements within VECTOR may be changed starting with START and up to the end of the VECTOR. Therefore, this function is best used for situations where a vector is considered to be a set, and the order of its elements doesn’t matter.

Package

jpl-util

Source

vector-delete.lisp (file)

Function: with-extent-hooks% ENTER-FN RETURN-FN NON-LOCAL-EXIT-FN MAIN-FN

Function-based variant of WITH-EXTENT-HOOKS; see its documentation.

ENTER-FN must be a function of no arguments. RETURN-FN must be a function that can accept one argument for each value returned by MAIN-FN. NON-LOCAL-EXIT-FN must be a function of no arguments. MAIN-FN must be a function of no arguments.

Package

jpl-util

Source

jpl-util.lisp (file)

Function: zip &rest LISTS
Package

jpl-util

Source

jpl-util.lisp (file)

Function: zip* LISTS &key PAD

Combines the elements of each list of LISTS, returning a fresh list where the element at position n is a fresh list of corresponding elements from the input lists, each at position n. To put it another way, if you think of the input lists as a matrix, this returns the transpose of the matrix.

If PAD is specified and the lengths of the input lists are not equal, then the lists will be implicitly padded with PAD at the end, as if all the lists were of the same length as the longest list.

Package

jpl-util

Source

jpl-util.lisp (file)


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

4.1.5 Generic functions

Generic Function: copy-object OBJ

Recursively copies an object. The output is
guaranteed to not share structure with the input. Patterns of shared structure may not be replicated in the output. If the input has reference cycles, this function may not return or signal a condition.

Package

jpl-util

Source

jpl-util.lisp (file)

Methods
Method: copy-object (OBJ character)
Method: copy-object (OBJ symbol)
Method: copy-object (OBJ null)
Method: copy-object (OBJ number)
Method: copy-object (SEQ sequence)
Method: copy-object (CONS-OBJ cons)
Generic Function: subtype-error-expected-supertype CONDITION
Package

jpl-util

Methods
Method: subtype-error-expected-supertype (CONDITION subtype-error)
Source

subtypecase.lisp (file)

Generic Function: subtype-error-type CONDITION
Package

jpl-util

Methods
Method: subtype-error-type (CONDITION subtype-error)
Source

subtypecase.lisp (file)


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

4.1.6 Conditions

Condition: subtype-error ()

TYPE is not a subtype of EXPECTED-SUPERTYPE.

Package

jpl-util

Source

subtypecase.lisp (file)

Direct superclasses

error (condition)

Direct methods
Direct slots
Slot: type
Initargs

:type

Initform

(quote (error "must supply :type."))

Readers

subtype-error-type (generic function)

Slot: expected-supertype
Initargs

:expected-supertype

Initform

(quote (error "must supply :expected-supertype."))

Readers

subtype-error-expected-supertype (generic function)


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

4.1.7 Types

Type: array-dimension ()
Package

jpl-util

Source

types.lisp (file)

Type: array-index ()
Package

jpl-util

Source

types.lisp (file)

Type: class-designator ()
Package

jpl-util

Source

types.lisp (file)

Type: extended-function-designator ()
Package

jpl-util

Source

types.lisp (file)

Type: format-control ()
Package

jpl-util

Source

types.lisp (file)

Type: function-designator ()
Package

jpl-util

Source

types.lisp (file)

Type: function-name ()
Package

jpl-util

Source

types.lisp (file)

Type: pathname-designator ()
Package

jpl-util

Source

types.lisp (file)

Type: subsecond-universal-time ()
Package

jpl-util

Source

types.lisp (file)

Type: universal-time ()
Package

jpl-util

Source

types.lisp (file)


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

4.2 Internal definitions


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

4.2.1 Special variables

Special Variable: *expr-traces-by-expr*
Package

jpl-util

Source

jpl-util.lisp (file)

Special Variable: *expr-traces-by-id*
Package

jpl-util

Source

jpl-util.lisp (file)

Special Variable: *verbosity-depth*

The number of containing WITH-VERBOSITY forms that specify verbosity to be enabled.

Package

jpl-util

Source

jpl-util.lisp (file)


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

4.2.2 Macros

Macro: handler-case/no-unwind FORM &rest CLAUSES

Like HANDLER-CASE, but does not unwind the stack before executing an error-handling clause.

Package

jpl-util

Source

jpl-util.lisp (file)

Macro: push-append% PLACE LIST
Package

jpl-util

Source

jpl-util.lisp (file)

Macro: push-nconc% PLACE LIST
Package

jpl-util

Source

jpl-util.lisp (file)


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

4.2.3 Functions

Function: expr-trace-expression-format EXPR-TRACE
Package

jpl-util

Source

jpl-util.lisp (file)

Function: find-duplicates-in-list LIST TEST KEY
Package

jpl-util

Source

jpl-util.lisp (file)

Function: find-duplicates-in-vector VECTOR TEST KEY
Package

jpl-util

Source

jpl-util.lisp (file)

Function: find-duplicates-with-hash-table SEQUENCE TEST KEY
Package

jpl-util

Source

jpl-util.lisp (file)

Function: list-extract!-helper LIST PREDICATE MAPPING-P
Package

jpl-util

Source

jpl-util.lisp (file)

Function: option-clause-list->plist CLAUSES
Package

jpl-util

Source

option-clause.lisp (file)

Function: register-trace EXPRESSION &optional ID
Package

jpl-util

Source

jpl-util.lisp (file)

Function: swapped-append L2 L1
Package

jpl-util

Source

jpl-util.lisp (file)

Function: swapped-nconc L2 L1
Package

jpl-util

Source

jpl-util.lisp (file)

Function: test-vector-delete VECTOR SUB-START SUB-END EXPECTED
Package

jpl-util

Source

vector-delete.lisp (file)

Function: test-vector-delete-functions &key COUNT LENGTH
Package

jpl-util

Source

vector-delete.lisp (file)

Function: test-vector-delete-range VECTOR SUB-START SUB-END EXPECTED
Package

jpl-util

Source

vector-delete.lisp (file)

Function: vector-equal V1 V2
Package

jpl-util

Source

vector-delete.lisp (file)

Function: verbosely% FUNCTION CONTROL-STRING &rest FORMAT-ARGUMENTS
Package

jpl-util

Source

jpl-util.lisp (file)

Function: with-verbosity% FUNCTION &optional VERBOSE
Package

jpl-util

Source

jpl-util.lisp (file)


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

4.2.4 Generic functions

Generic Function: expression OBJECT
Generic Function: (setf expression) NEW-VALUE OBJECT
Package

jpl-util

Methods
Method: expression (EXPR-TRACE expr-trace)

automatically generated reader method

Source

jpl-util.lisp (file)

Method: (setf expression) NEW-VALUE (EXPR-TRACE expr-trace)

automatically generated writer method

Source

jpl-util.lisp (file)

Generic Function: home-package OBJECT
Package

jpl-util

Methods
Method: home-package (EXPR-TRACE expr-trace)

automatically generated reader method

Source

jpl-util.lisp (file)

Generic Function: id OBJECT
Package

jpl-util

Methods
Method: id (EXPR-TRACE expr-trace)

automatically generated reader method

Source

jpl-util.lisp (file)


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

4.2.5 Classes

Class: expr-trace ()
Package

jpl-util

Source

jpl-util.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: id
Type

integer

Initargs

:id

Initform

(error "must supply id.")

Readers

id (generic function)

Slot: expression
Initargs

:expression

Initform

(error "must supply expression.")

Readers

expression (generic function)

Writers

(setf expression) (generic function)

Slot: home-package
Type

package

Initargs

:home-package

Initform

(error "must supply home-package")

Readers

home-package (generic function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   J   L  
Index Entry  Section

F
File, Lisp, jpl-util.asd: The jpl-util<dot>asd file
File, Lisp, jpl-util/accumulators.lisp: The jpl-util/accumulators<dot>lisp file
File, Lisp, jpl-util/alists-and-plists.lisp: The jpl-util/alists-and-plists<dot>lisp file
File, Lisp, jpl-util/defclass-star.lisp: The jpl-util/defclass-star<dot>lisp file
File, Lisp, jpl-util/gensyms.lisp: The jpl-util/gensyms<dot>lisp file
File, Lisp, jpl-util/iterators.lisp: The jpl-util/iterators<dot>lisp file
File, Lisp, jpl-util/jpl-util.lisp: The jpl-util/jpl-util<dot>lisp file
File, Lisp, jpl-util/option-clause.lisp: The jpl-util/option-clause<dot>lisp file
File, Lisp, jpl-util/order.lisp: The jpl-util/order<dot>lisp file
File, Lisp, jpl-util/package.lisp: The jpl-util/package<dot>lisp file
File, Lisp, jpl-util/subtypecase.lisp: The jpl-util/subtypecase<dot>lisp file
File, Lisp, jpl-util/types.lisp: The jpl-util/types<dot>lisp file
File, Lisp, jpl-util/vector-delete.lisp: The jpl-util/vector-delete<dot>lisp file

J
jpl-util.asd: The jpl-util<dot>asd file
jpl-util/accumulators.lisp: The jpl-util/accumulators<dot>lisp file
jpl-util/alists-and-plists.lisp: The jpl-util/alists-and-plists<dot>lisp file
jpl-util/defclass-star.lisp: The jpl-util/defclass-star<dot>lisp file
jpl-util/gensyms.lisp: The jpl-util/gensyms<dot>lisp file
jpl-util/iterators.lisp: The jpl-util/iterators<dot>lisp file
jpl-util/jpl-util.lisp: The jpl-util/jpl-util<dot>lisp file
jpl-util/option-clause.lisp: The jpl-util/option-clause<dot>lisp file
jpl-util/order.lisp: The jpl-util/order<dot>lisp file
jpl-util/package.lisp: The jpl-util/package<dot>lisp file
jpl-util/subtypecase.lisp: The jpl-util/subtypecase<dot>lisp file
jpl-util/types.lisp: The jpl-util/types<dot>lisp file
jpl-util/vector-delete.lisp: The jpl-util/vector-delete<dot>lisp file

L
Lisp File, jpl-util.asd: The jpl-util<dot>asd file
Lisp File, jpl-util/accumulators.lisp: The jpl-util/accumulators<dot>lisp file
Lisp File, jpl-util/alists-and-plists.lisp: The jpl-util/alists-and-plists<dot>lisp file
Lisp File, jpl-util/defclass-star.lisp: The jpl-util/defclass-star<dot>lisp file
Lisp File, jpl-util/gensyms.lisp: The jpl-util/gensyms<dot>lisp file
Lisp File, jpl-util/iterators.lisp: The jpl-util/iterators<dot>lisp file
Lisp File, jpl-util/jpl-util.lisp: The jpl-util/jpl-util<dot>lisp file
Lisp File, jpl-util/option-clause.lisp: The jpl-util/option-clause<dot>lisp file
Lisp File, jpl-util/order.lisp: The jpl-util/order<dot>lisp file
Lisp File, jpl-util/package.lisp: The jpl-util/package<dot>lisp file
Lisp File, jpl-util/subtypecase.lisp: The jpl-util/subtypecase<dot>lisp file
Lisp File, jpl-util/types.lisp: The jpl-util/types<dot>lisp file
Lisp File, jpl-util/vector-delete.lisp: The jpl-util/vector-delete<dot>lisp file

Jump to:   F   J   L  

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

A.2 Functions

Jump to:   (   1  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   T   U   V   W   X   Z  
Index Entry  Section

(
(setf assoc*): Exported functions
(setf expression): Internal generic functions
(setf expression): Internal generic functions

1
1or: Exported macros

A
a/an-number: Exported functions
accumulate-to-dynamic-vector: Exported macros
accumulate-to-hash-table: Exported macros
accumulate-to-list: Exported macros
accumulate-to-vector: Exported macros
adjacent-pairs: Exported functions
alist->hash-table: Exported functions
alist->plist: Exported functions
all: Exported functions
any: Exported functions
assoc*: Exported functions

B
best: Exported functions

C
check-bounding-indices: Exported functions
check-type*: Exported macros
circular-list: Exported functions
clear-traces!: Exported functions
coerce-boolean: Exported functions
combine-elements: Exported functions
Compiler Macro, compose: Exported compiler macros
Compiler Macro, compose-1v: Exported compiler macros
compose: Exported compiler macros
compose: Exported functions
compose-1v: Exported compiler macros
compose-1v: Exported functions
composite-lesser?: Exported macros
cond-replace: Exported functions
copy-object: Exported generic functions
copy-object: Exported generic functions
copy-object: Exported generic functions
copy-object: Exported generic functions
copy-object: Exported generic functions
copy-object: Exported generic functions
copy-object: Exported generic functions
csubtypecase: Exported macros
curry-left: Exported functions
curry-right: Exported functions

D
decode-time-duration: Exported functions
defclass*: Exported macros
defvar-unbound: Exported macros
delete-nth!: Exported functions
designated-class: Exported functions
designated-function: Exported functions
doseq: Exported macros
duplicates-p: Exported functions

E
empty?: Exported functions
english-list-format-control: Exported functions
ensure-type: Exported functions
eof-p: Exported functions
equivalent-hash-table-test: Exported functions
esubtypecase: Exported macros
expr-trace-expression-format: Internal functions
expression: Internal generic functions
expression: Internal generic functions

F
find-duplicates: Exported functions
find-duplicates-in-list: Internal functions
find-duplicates-in-vector: Internal functions
find-duplicates-with-hash-table: Internal functions
format-ordinal: Exported functions
format-time-duration: Exported functions
fractional: Exported functions
Function, a/an-number: Exported functions
Function, adjacent-pairs: Exported functions
Function, alist->hash-table: Exported functions
Function, alist->plist: Exported functions
Function, all: Exported functions
Function, any: Exported functions
Function, assoc*: Exported functions
Function, best: Exported functions
Function, check-bounding-indices: Exported functions
Function, circular-list: Exported functions
Function, clear-traces!: Exported functions
Function, coerce-boolean: Exported functions
Function, combine-elements: Exported functions
Function, compose: Exported functions
Function, compose-1v: Exported functions
Function, cond-replace: Exported functions
Function, curry-left: Exported functions
Function, curry-right: Exported functions
Function, decode-time-duration: Exported functions
Function, delete-nth!: Exported functions
Function, designated-class: Exported functions
Function, designated-function: Exported functions
Function, duplicates-p: Exported functions
Function, empty?: Exported functions
Function, english-list-format-control: Exported functions
Function, ensure-type: Exported functions
Function, eof-p: Exported functions
Function, equivalent-hash-table-test: Exported functions
Function, expr-trace-expression-format: Internal functions
Function, find-duplicates: Exported functions
Function, find-duplicates-in-list: Internal functions
Function, find-duplicates-in-vector: Internal functions
Function, find-duplicates-with-hash-table: Internal functions
Function, format-ordinal: Exported functions
Function, format-time-duration: Exported functions
Function, fractional: Exported functions
Function, get-reasonable-real-time: Exported functions
Function, get-reasonable-run-time: Exported functions
Function, group-by-n: Exported functions
Function, hash-table->alist: Exported functions
Function, insert-at: Exported functions
Function, integer->twos-complement: Exported functions
Function, integer-digit-count: Exported functions
Function, integer-digits: Exported functions
Function, iterate-alist: Exported functions
Function, iterate-plist: Exported functions
Function, list-extract!-helper: Internal functions
Function, list-traces: Exported functions
Function, map-adjacent-pairs: Exported functions
Function, map-lines: Exported functions
Function, mean: Exported functions
Function, merge-alists: Exported functions
Function, nsort: Exported functions
Function, nstable-sort: Exported functions
Function, nth-arg: Exported functions
Function, option-clause-list->plist: Internal functions
Function, package<: Exported functions
Function, parse-progn: Exported functions
Function, parse-sequence-type: Exported functions
Function, parse-vector-type: Exported functions
Function, partition-list: Exported functions
Function, partition-set: Exported functions
Function, plist->alist: Exported functions
Function, proper-list?: Exported functions
Function, read-lines: Exported functions
Function, read-new-value: Exported functions
Function, register-trace: Internal functions
Function, remove-duplicate-properties: Exported functions
Function, remove-ordered-duplicates: Exported functions
Function, set-equal: Exported functions
Function, shuffle: Exported functions
Function, shuffle!: Exported functions
Function, sort: Exported functions
Function, split-list!: Exported functions
Function, square: Exported functions
Function, stable-sort: Exported functions
Function, standard-deviation: Exported functions
Function, string-begin-equal: Exported functions
Function, string-begin=: Exported functions
Function, string-end-equal: Exported functions
Function, string-end=: Exported functions
Function, subseq*: Exported functions
Function, subseq-displace: Exported functions
Function, swapped-append: Internal functions
Function, swapped-nconc: Internal functions
Function, symbol<: Exported functions
Function, test-order-pred: Exported functions
Function, test-vector-delete: Internal functions
Function, test-vector-delete-functions: Internal functions
Function, test-vector-delete-range: Internal functions
Function, twos-complement->integer: Exported functions
Function, unique-pairs: Exported functions
Function, vector-delete: Exported functions
Function, vector-delete-range: Exported functions
Function, vector-equal: Internal functions
Function, verbosely%: Internal functions
Function, with-extent-hooks%: Exported functions
Function, with-verbosity%: Internal functions
Function, zip: Exported functions
Function, zip*: Exported functions

G
Generic Function, (setf expression): Internal generic functions
Generic Function, copy-object: Exported generic functions
Generic Function, expression: Internal generic functions
Generic Function, home-package: Internal generic functions
Generic Function, id: Internal generic functions
Generic Function, subtype-error-expected-supertype: Exported generic functions
Generic Function, subtype-error-type: Exported generic functions
get-reasonable-real-time: Exported functions
get-reasonable-run-time: Exported functions
group-by-n: Exported functions

H
handler-case/no-unwind: Internal macros
hash-table->alist: Exported functions
home-package: Internal generic functions
home-package: Internal generic functions

I
id: Internal generic functions
id: Internal generic functions
insert-at: Exported functions
integer->twos-complement: Exported functions
integer-digit-count: Exported functions
integer-digits: Exported functions
iterate-alist: Exported functions
iterate-plist: Exported functions

L
lambda*: Exported macros
lesser?: Exported macros
list-extract!: Exported macros
list-extract!-helper: Internal functions
list-traces: Exported functions

M
Macro, 1or: Exported macros
Macro, accumulate-to-dynamic-vector: Exported macros
Macro, accumulate-to-hash-table: Exported macros
Macro, accumulate-to-list: Exported macros
Macro, accumulate-to-vector: Exported macros
Macro, check-type*: Exported macros
Macro, composite-lesser?: Exported macros
Macro, csubtypecase: Exported macros
Macro, defclass*: Exported macros
Macro, defvar-unbound: Exported macros
Macro, doseq: Exported macros
Macro, esubtypecase: Exported macros
Macro, handler-case/no-unwind: Internal macros
Macro, lambda*: Exported macros
Macro, lesser?: Exported macros
Macro, list-extract!: Exported macros
Macro, option-clause-bind: Exported macros
Macro, push-append: Exported macros
Macro, push-append%: Internal macros
Macro, push-nconc: Exported macros
Macro, push-nconc%: Internal macros
Macro, subtypecase: Exported macros
Macro, verbosely: Exported macros
Macro, with-accessors*: Exported macros
Macro, with-extent-hooks: Exported macros
Macro, with-gensyms: Exported macros
Macro, with-list-iterator: Exported macros
Macro, with-range-iterator: Exported macros
Macro, with-safe-alloc: Exported macros
Macro, with-sequence-iterator: Exported macros
Macro, with-trace: Exported macros
Macro, with-vector-iterator: Exported macros
Macro, with-verbosity: Exported macros
Macro, xor: Exported macros
map-adjacent-pairs: Exported functions
map-lines: Exported functions
mean: Exported functions
merge-alists: Exported functions
Method, (setf expression): Internal generic functions
Method, copy-object: Exported generic functions
Method, copy-object: Exported generic functions
Method, copy-object: Exported generic functions
Method, copy-object: Exported generic functions
Method, copy-object: Exported generic functions
Method, copy-object: Exported generic functions
Method, expression: Internal generic functions
Method, home-package: Internal generic functions
Method, id: Internal generic functions
Method, subtype-error-expected-supertype: Exported generic functions
Method, subtype-error-type: Exported generic functions

N
nsort: Exported functions
nstable-sort: Exported functions
nth-arg: Exported functions

O
option-clause-bind: Exported macros
option-clause-list->plist: Internal functions

P
package<: Exported functions
parse-progn: Exported functions
parse-sequence-type: Exported functions
parse-vector-type: Exported functions
partition-list: Exported functions
partition-set: Exported functions
plist->alist: Exported functions
proper-list?: Exported functions
push-append: Exported macros
push-append%: Internal macros
push-nconc: Exported macros
push-nconc%: Internal macros

R
read-lines: Exported functions
read-new-value: Exported functions
register-trace: Internal functions
remove-duplicate-properties: Exported functions
remove-ordered-duplicates: Exported functions

S
set-equal: Exported functions
Setf Expander, (setf assoc*): Exported functions
shuffle: Exported functions
shuffle!: Exported functions
sort: Exported functions
split-list!: Exported functions
square: Exported functions
stable-sort: Exported functions
standard-deviation: Exported functions
string-begin-equal: Exported functions
string-begin=: Exported functions
string-end-equal: Exported functions
string-end=: Exported functions
subseq*: Exported functions
subseq-displace: Exported functions
subtype-error-expected-supertype: Exported generic functions
subtype-error-expected-supertype: Exported generic functions
subtype-error-type: Exported generic functions
subtype-error-type: Exported generic functions
subtypecase: Exported macros
swapped-append: Internal functions
swapped-nconc: Internal functions
symbol<: Exported functions

T
test-order-pred: Exported functions
test-vector-delete: Internal functions
test-vector-delete-functions: Internal functions
test-vector-delete-range: Internal functions
twos-complement->integer: Exported functions

U
unique-pairs: Exported functions

V
vector-delete: Exported functions
vector-delete-range: Exported functions
vector-equal: Internal functions
verbosely: Exported macros
verbosely%: Internal functions

W
with-accessors*: Exported macros
with-extent-hooks: Exported macros
with-extent-hooks%: Exported functions
with-gensyms: Exported macros
with-list-iterator: Exported macros
with-range-iterator: Exported macros
with-safe-alloc: Exported macros
with-sequence-iterator: Exported macros
with-trace: Exported macros
with-vector-iterator: Exported macros
with-verbosity: Exported macros
with-verbosity%: Internal functions

X
xor: Exported macros

Z
zip: Exported functions
zip*: Exported functions

Jump to:   (   1  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   T   U   V   W   X   Z  

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

A.3 Variables

Jump to:   *  
E   H   I   S   T  
Index Entry  Section

*
*expr-traces-by-expr*: Internal special variables
*expr-traces-by-id*: Internal special variables
*verbose*: Exported special variables
*verbosity-depth*: Internal special variables

E
expected-supertype: Exported conditions
expression: Internal classes

H
home-package: Internal classes

I
id: Internal classes

S
Slot, expected-supertype: Exported conditions
Slot, expression: Internal classes
Slot, home-package: Internal classes
Slot, id: Internal classes
Slot, type: Exported conditions
Special Variable, *expr-traces-by-expr*: Internal special variables
Special Variable, *expr-traces-by-id*: Internal special variables
Special Variable, *verbose*: Exported special variables
Special Variable, *verbosity-depth*: Internal special variables

T
type: Exported conditions

Jump to:   *  
E   H   I   S   T  

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

A.4 Data types

Jump to:   A   C   E   F   J   P   S   T   U  
Index Entry  Section

A
array-dimension: Exported types
array-index: Exported types

C
Class, expr-trace: Internal classes
class-designator: Exported types
Condition, subtype-error: Exported conditions

E
expr-trace: Internal classes
extended-function-designator: Exported types

F
format-control: Exported types
function-designator: Exported types
function-name: Exported types

J
jpl-util: The jpl-util system
jpl-util: The jpl-util package

P
Package, jpl-util: The jpl-util package
pathname-designator: Exported types

S
subsecond-universal-time: Exported types
subtype-error: Exported conditions
System, jpl-util: The jpl-util system

T
Type, array-dimension: Exported types
Type, array-index: Exported types
Type, class-designator: Exported types
Type, extended-function-designator: Exported types
Type, format-control: Exported types
Type, function-designator: Exported types
Type, function-name: Exported types
Type, pathname-designator: Exported types
Type, subsecond-universal-time: Exported types
Type, universal-time: Exported types

U
universal-time: Exported types

Jump to:   A   C   E   F   J   P   S   T   U