The alexandria Reference Manual

This is the alexandria Reference Manual, version 1.0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed May 15 03:14:26 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 alexandria

Alexandria is a collection of portable public domain utilities.

Author

Nikodemus Siivola and others.

License

Public Domain / 0-clause MIT

Long Description

Alexandria is a project and a library.

As a project Alexandria’s goal is to reduce duplication of effort and improve portability of Common Lisp code according to its own idiosyncratic and rather conservative aesthetic.

As a library Alexandria is one of the means by which the project strives for its goals.

Alexandria is a collection of portable public domain utilities that meet the following constraints:

* Utilities, not extensions: Alexandria will not contain conceptual extensions to Common Lisp, instead limiting itself to tools and utilities that fit well within the framework of standard ANSI Common Lisp. Test-frameworks, system definitions, logging facilities, serialization layers, etc. are all outside the scope of Alexandria as a library, though well within the scope of Alexandria as a project.

* Conservative: Alexandria limits itself to what project members consider conservative utilities. Alexandria does not and will not include anaphoric constructs, loop-like binding macros, etc.
Also, its exported symbols are being imported by many other packages already, so each new export carries the danger of causing conflicts.

* Portable: Alexandria limits itself to portable parts of Common Lisp. Even apparently conservative and useful functions remain outside the scope of Alexandria if they cannot be implemented portably. Portability is here defined as portable within a conforming implementation: implementation bugs are not considered portability issues.

* Team player: Alexandria will not (initially, at least) subsume or provide functionality for which good-quality special-purpose packages exist, like split-sequence. Instead, third party packages such as that may be "blessed".

Version

1.0.1

Source

alexandria.asd.

Child Components

3 Modules

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


3.1 alexandria/alexandria-1

Source

alexandria.asd.

Parent Component

alexandria (system).

Child Components

3.2 alexandria/alexandria-2

Source

alexandria.asd.

Parent Component

alexandria (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 alexandria/alexandria.asd

Source

alexandria.asd.

Parent Component

alexandria (system).

ASDF Systems

alexandria.


4.1.2 alexandria/alexandria-1/package.lisp

Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Packages

alexandria.


4.1.3 alexandria/alexandria-1/definitions.lisp

Dependency

package.lisp (file).

Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface

define-constant (macro).

Internals

%reevaluate-constant (function).


4.1.4 alexandria/alexandria-1/binding.lisp

Dependency

package.lisp (file).

Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface

4.1.5 alexandria/alexandria-1/strings.lisp

Dependency

package.lisp (file).

Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface

string-designator (type).


4.1.6 alexandria/alexandria-1/conditions.lisp

Dependency

package.lisp (file).

Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface

4.1.7 alexandria/alexandria-1/io.lisp

Dependencies
Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface
Internals

4.1.8 alexandria/alexandria-1/macros.lisp

Dependencies
Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface
Internals

expand-destructuring-case (function).


4.1.9 alexandria/alexandria-1/hash-tables.lisp

Dependencies
Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface

4.1.10 alexandria/alexandria-1/control-flow.lisp

Dependencies
Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface
Internals

4.1.11 alexandria/alexandria-1/symbols.lisp

Dependency

package.lisp (file).

Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface
Internals

maybe-intern (function).


4.1.12 alexandria/alexandria-1/functions.lisp

Dependencies
Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface
Internals

ensure-functionf/1 (macro).


4.1.13 alexandria/alexandria-1/lists.lisp

Dependencies
Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface
Internals

4.1.14 alexandria/alexandria-1/types.lisp

Dependencies
Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface

4.1.15 alexandria/alexandria-1/arrays.lisp

Dependencies
Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface

copy-array (function).


4.1.16 alexandria/alexandria-1/sequences.lisp

Dependencies
Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface
Internals

4.1.17 alexandria/alexandria-1/numbers.lisp

Dependencies
Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface
Internals

4.1.18 alexandria/alexandria-1/features.lisp

Dependencies
Source

alexandria.asd.

Parent Component

alexandria-1 (module).

Public Interface

featurep (function).


4.1.19 alexandria/alexandria-2/package.lisp

Source

alexandria.asd.

Parent Component

alexandria-2 (module).

Packages

alexandria-2.


4.1.20 alexandria/alexandria-2/arrays.lisp

Dependency

package.lisp (file).

Source

alexandria.asd.

Parent Component

alexandria-2 (module).

Public Interface

4.1.21 alexandria/alexandria-2/control-flow.lisp

Dependency

package.lisp (file).

Source

alexandria.asd.

Parent Component

alexandria-2 (module).

Public Interface
Internals

line-up-iter (function).


4.1.22 alexandria/alexandria-2/sequences.lisp

Dependency

package.lisp (file).

Source

alexandria.asd.

Parent Component

alexandria-2 (module).

Public Interface

subseq* (function).


4.1.23 alexandria/alexandria-2/lists.lisp

Dependency

package.lisp (file).

Source

alexandria.asd.

Parent Component

alexandria-2 (module).

Public Interface

delete-from-plist* (function).


4.2 Static


4.2.1 alexandria/LICENCE

Source

alexandria.asd.

Parent Component

alexandria (system).


4.2.2 alexandria/alexandria-1/tests.lisp

Source

alexandria.asd.

Parent Component

alexandria-1 (module).


4.2.3 alexandria/alexandria-2/tests.lisp

Source

alexandria.asd.

Parent Component

alexandria-2 (module).


5 Packages

Packages are listed by definition order.


5.1 alexandria

Source

package.lisp.

Nicknames
  • alexandria.1.0.0
  • alexandria-1
Use List

common-lisp.

Used By List

alexandria-2.

Public Interface
Internals

5.2 alexandria-2

Source

package.lisp.

Nickname

alexandria.2

Use List
Public Interface
Internals

line-up-iter (function).


6 Definitions

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


6.1 Public Interface


6.1.1 Macros

Macro: appendf (place &rest lists)

Modify-macro for APPEND. Appends LISTS to the place designated by the first argument.

Package

alexandria.

Source

lists.lisp.

Macro: coercef (place type-spec)

Modify-macro for COERCE.

Package

alexandria.

Source

types.lisp.

Macro: cswitch ((object &key test key) &body clauses)

Like SWITCH, but signals a continuable error if no key matches.

Package

alexandria.

Source

control-flow.lisp.

Macro: define-constant (name initial-value &key test documentation)

Ensures that the global variable named by NAME is a constant with a value that is equal under TEST to the result of evaluating INITIAL-VALUE. TEST is a /function designator/ that defaults to EQL. If DOCUMENTATION is given, it becomes the documentation string of the constant.

Signals an error if NAME is already a bound non-constant variable.

Signals an error if NAME is already a constant variable whose value is not equal under TEST to result of evaluating INITIAL-VALUE.

Package

alexandria.

Source

definitions.lisp.

Macro: delete-from-plistf (place &rest keys)

Modify macro for DELETE-FROM-PLIST.

Package

alexandria.

Source

lists.lisp.

Macro: deletef (place item &rest keyword-arguments)

Modify-macro for DELETE. Sets place designated by the first argument to the result of calling DELETE with ITEM, place, and the KEYWORD-ARGUMENTS.

Package

alexandria.

Source

sequences.lisp.

Macro: destructuring-case (keyform &body clauses)

DESTRUCTURING-CASE, -CCASE, and -ECASE are a combination of CASE and DESTRUCTURING-BIND. KEYFORM must evaluate to a CONS.

Clauses are of the form:

((CASE-KEYS . DESTRUCTURING-LAMBDA-LIST) FORM*)

The clause whose CASE-KEYS matches CAR of KEY, as if by CASE, CCASE, or ECASE,
is selected, and FORMs are then executed with CDR of KEY is destructured and
bound by the DESTRUCTURING-LAMBDA-LIST.

Example:

(defun dcase (x)
(destructuring-case x
((:foo a b)
(format nil "foo: ~S, ~S" a b))
((:bar &key a b)
(format nil "bar: ~S, ~S" a b))
(((:alt1 :alt2) a)
(format nil "alt: ~S" a))
((t &rest rest)
(format nil "unknown: ~S" rest))))

(dcase (list :foo 1 2)) ; => "foo: 1, 2"
(dcase (list :bar :a 1 :b 2)) ; => "bar: 1, 2"
(dcase (list :alt1 1)) ; => "alt: 1"
(dcase (list :alt2 2)) ; => "alt: 2"
(dcase (list :quux 1 2 3)) ; => "unknown: 1, 2, 3"

(defun decase (x)
(destructuring-case x
((:foo a b)
(format nil "foo: ~S, ~S" a b))
((:bar &key a b)
(format nil "bar: ~S, ~S" a b))
(((:alt1 :alt2) a)
(format nil "alt: ~S" a))))

(decase (list :foo 1 2)) ; => "foo: 1, 2"
(decase (list :bar :a 1 :b 2)) ; => "bar: 1, 2"
(decase (list :alt1 1)) ; => "alt: 1"
(decase (list :alt2 2)) ; => "alt: 2"
(decase (list :quux 1 2 3)) ; =| error

Package

alexandria.

Source

macros.lisp.

Macro: destructuring-ccase (keyform &body clauses)

DESTRUCTURING-CASE, -CCASE, and -ECASE are a combination of CASE and DESTRUCTURING-BIND. KEYFORM must evaluate to a CONS.

Clauses are of the form:

((CASE-KEYS . DESTRUCTURING-LAMBDA-LIST) FORM*)

The clause whose CASE-KEYS matches CAR of KEY, as if by CASE, CCASE, or ECASE,
is selected, and FORMs are then executed with CDR of KEY is destructured and
bound by the DESTRUCTURING-LAMBDA-LIST.

Example:

(defun dcase (x)
(destructuring-case x
((:foo a b)
(format nil "foo: ~S, ~S" a b))
((:bar &key a b)
(format nil "bar: ~S, ~S" a b))
(((:alt1 :alt2) a)
(format nil "alt: ~S" a))
((t &rest rest)
(format nil "unknown: ~S" rest))))

(dcase (list :foo 1 2)) ; => "foo: 1, 2"
(dcase (list :bar :a 1 :b 2)) ; => "bar: 1, 2"
(dcase (list :alt1 1)) ; => "alt: 1"
(dcase (list :alt2 2)) ; => "alt: 2"
(dcase (list :quux 1 2 3)) ; => "unknown: 1, 2, 3"

(defun decase (x)
(destructuring-case x
((:foo a b)
(format nil "foo: ~S, ~S" a b))
((:bar &key a b)
(format nil "bar: ~S, ~S" a b))
(((:alt1 :alt2) a)
(format nil "alt: ~S" a))))

(decase (list :foo 1 2)) ; => "foo: 1, 2"
(decase (list :bar :a 1 :b 2)) ; => "bar: 1, 2"
(decase (list :alt1 1)) ; => "alt: 1"
(decase (list :alt2 2)) ; => "alt: 2"
(decase (list :quux 1 2 3)) ; =| error

Package

alexandria.

Source

macros.lisp.

Macro: destructuring-ecase (keyform &body clauses)

DESTRUCTURING-CASE, -CCASE, and -ECASE are a combination of CASE and DESTRUCTURING-BIND. KEYFORM must evaluate to a CONS.

Clauses are of the form:

((CASE-KEYS . DESTRUCTURING-LAMBDA-LIST) FORM*)

The clause whose CASE-KEYS matches CAR of KEY, as if by CASE, CCASE, or ECASE,
is selected, and FORMs are then executed with CDR of KEY is destructured and
bound by the DESTRUCTURING-LAMBDA-LIST.

Example:

(defun dcase (x)
(destructuring-case x
((:foo a b)
(format nil "foo: ~S, ~S" a b))
((:bar &key a b)
(format nil "bar: ~S, ~S" a b))
(((:alt1 :alt2) a)
(format nil "alt: ~S" a))
((t &rest rest)
(format nil "unknown: ~S" rest))))

(dcase (list :foo 1 2)) ; => "foo: 1, 2"
(dcase (list :bar :a 1 :b 2)) ; => "bar: 1, 2"
(dcase (list :alt1 1)) ; => "alt: 1"
(dcase (list :alt2 2)) ; => "alt: 2"
(dcase (list :quux 1 2 3)) ; => "unknown: 1, 2, 3"

(defun decase (x)
(destructuring-case x
((:foo a b)
(format nil "foo: ~S, ~S" a b))
((:bar &key a b)
(format nil "bar: ~S, ~S" a b))
(((:alt1 :alt2) a)
(format nil "alt: ~S" a))))

(decase (list :foo 1 2)) ; => "foo: 1, 2"
(decase (list :bar :a 1 :b 2)) ; => "bar: 1, 2"
(decase (list :alt1 1)) ; => "alt: 1"
(decase (list :alt2 2)) ; => "alt: 2"
(decase (list :quux 1 2 3)) ; =| error

Package

alexandria.

Source

macros.lisp.

Macro: doplist ((key val plist &optional values) &body body)

Iterates over elements of PLIST. BODY can be preceded by declarations, and is like a TAGBODY. RETURN may be used to terminate the iteration early. If RETURN is not used, returns VALUES.

Package

alexandria.

Source

lists.lisp.

Macro: ensure-functionf (&rest places)

Multiple-place modify macro for ENSURE-FUNCTION: ensures that each of PLACES contains a function.

Package

alexandria.

Source

functions.lisp.

Macro: ensure-gethash (key hash-table &optional default)

Like GETHASH, but if KEY is not found in the HASH-TABLE saves the DEFAULT under key before returning it. Secondary return value is true if key was already in the table.

Package

alexandria.

Source

hash-tables.lisp.

Macro: eswitch ((object &key test key) &body clauses)

Like SWITCH, but signals an error if no key matches.

Package

alexandria.

Source

control-flow.lisp.

Macro: if-let (bindings &body then-form)

Creates new variable bindings, and conditionally executes either
THEN-FORM or ELSE-FORM. ELSE-FORM defaults to NIL.

BINDINGS must be either single binding of the form:

(variable initial-form)

or a list of bindings of the form:

((variable-1 initial-form-1)
(variable-2 initial-form-2)
...
(variable-n initial-form-n))

All initial-forms are executed sequentially in the specified order. Then all the variables are bound to the corresponding values.

If all variables were bound to true values, the THEN-FORM is executed with the bindings in effect, otherwise the ELSE-FORM is executed with the bindings in effect.

Package

alexandria.

Source

binding.lisp.

Macro: ignore-some-conditions ((&rest conditions) &body body)

Similar to CL:IGNORE-ERRORS but the (unevaluated) CONDITIONS list determines which specific conditions are to be ignored.

Package

alexandria.

Source

conditions.lisp.

Macro: line-up-first (&rest forms)

Lines up FORMS elements as the first argument of their successor. Example:

(line-up-first
5
(+ 20)
/
(+ 40))

is equivalent to:

(+ (/ (+ 5 20)) 40)

Note how the single ’/ got converted into a list before threading.

Package

alexandria-2.

Source

control-flow.lisp.

Macro: line-up-last (&rest forms)

Lines up FORMS elements as the last argument of their successor. Example:

(line-up-last
5
(+ 20)
/
(+ 40))

is equivalent to:

(+ 40 (/ (+ 20 5)))

Note how the single ’/ got converted into a list before threading.

Package

alexandria-2.

Source

control-flow.lisp.

Macro: maxf (place &rest numbers)

Modify-macro for MAX. Sets place designated by the first argument to the maximum of its original value and NUMBERS.

Package

alexandria.

Source

numbers.lisp.

Macro: minf (place &rest numbers)

Modify-macro for MIN. Sets place designated by the first argument to the minimum of its original value and NUMBERS.

Package

alexandria.

Source

numbers.lisp.

Macro: multiple-value-prog2 (first-form second-form &body forms)

Evaluates FIRST-FORM, then SECOND-FORM, and then FORMS. Yields as its value all the value returned by SECOND-FORM.

Package

alexandria.

Source

control-flow.lisp.

Macro: named-lambda (name lambda-list &body body)

Expands into a lambda-expression within whose BODY NAME denotes the corresponding function.

Package

alexandria.

Source

functions.lisp.

Macro: nconcf (place &rest lists)

Modify-macro for NCONC. Concatenates LISTS to place designated by the first argument.

Package

alexandria.

Source

lists.lisp.

Macro: nreversef (place)

Modify-macro for NREVERSE. Reverses the list stored in the given place by destructively modifying it and saves back the result into the place.

Package

alexandria.

Source

lists.lisp.

Macro: nth-value-or (nth-value &body forms)

Evaluates FORM arguments one at a time, until the NTH-VALUE returned by one of the forms is true. It then returns all the values returned by evaluating that form. If none of the forms return a true nth value, this form returns NIL.

Package

alexandria.

Source

control-flow.lisp.

Macro: nunionf (place list &rest args)

Modify-macro for NUNION. Saves the union of LIST and the contents of the place designated by the first argument to the designated place. May modify either argument.

Package

alexandria.

Source

lists.lisp.

Macro: once-only (specs &body forms)

Constructs code whose primary goal is to help automate the handling of multiple evaluation within macros. Multiple evaluation is handled by introducing intermediate variables, in order to reuse the result of an expression.

The returned value is a list of the form

(let ((<gensym-1> <expr-1>)
...
(<gensym-n> <expr-n>))
<res>)

where GENSYM-1, ..., GENSYM-N are the intermediate variables introduced in order to evaluate EXPR-1, ..., EXPR-N once, only. RES is code that is the result of evaluating the implicit progn FORMS within a special context determined by SPECS. RES should make use of (reference) the intermediate variables.

Each element within SPECS is either a symbol SYMBOL or a pair (SYMBOL INITFORM). Bare symbols are equivalent to the pair (SYMBOL SYMBOL).

Each pair (SYMBOL INITFORM) specifies a single intermediate variable:

- INITFORM is an expression evaluated to produce EXPR-i

- SYMBOL is the name of the variable that will be bound around FORMS to the corresponding gensym GENSYM-i, in order for FORMS to generate RES that references the intermediate variable

The evaluation of INITFORMs and binding of SYMBOLs resembles LET. INITFORMs of all the pairs are evaluated before binding SYMBOLs and evaluating FORMS.

Example:

The following expression

(let ((x ’(incf y)))
(once-only (x)
‘(cons ,x ,x)))

;;; =>
;;; (let ((#1=#:X123 (incf y)))
;;; (cons #1# #1#))

could be used within a macro to avoid multiple evaluation like so

(defmacro cons1 (x)
(once-only (x)
‘(cons ,x ,x)))

(let ((y 0))
(cons1 (incf y)))

;;; => (1 . 1)

Example:

The following expression demonstrates the usage of the INITFORM field

(let ((expr ’(incf y)))
(once-only ((var ‘(1+ ,expr)))
‘(list ’,expr ,var ,var)))

;;; =>
;;; (let ((#1=#:VAR123 (1+ (incf y))))
;;; (list ’(incf y) #1# #1))

which could be used like so

(defmacro print-succ-twice (expr)
(once-only ((var ‘(1+ ,expr)))
‘(format t "Expr: ~s, Once: ~s, Twice: ~s~%" ’,expr ,var ,var)))

(let ((y 10))
(print-succ-twice (incf y)))

;;; >>
;;; Expr: (INCF Y), Once: 12, Twice: 12

Package

alexandria.

Source

macros.lisp.

Macro: remove-from-plistf (place &rest keys)

Modify macro for REMOVE-FROM-PLIST.

Package

alexandria.

Source

lists.lisp.

Macro: removef (place item &rest keyword-arguments)

Modify-macro for REMOVE. Sets place designated by the first argument to the result of calling REMOVE with ITEM, place, and the KEYWORD-ARGUMENTS.

Package

alexandria.

Source

sequences.lisp.

Macro: reversef (place)

Modify-macro for REVERSE. Copies and reverses the list stored in the given place and saves back the result into the place.

Package

alexandria.

Source

lists.lisp.

Macro: switch ((object &key test key) &body clauses)

Evaluates first matching clause, returning its values, or evaluates and returns the values of T or OTHERWISE if no keys match.

Package

alexandria.

Source

control-flow.lisp.

Macro: unionf (place list &rest args)

Modify-macro for UNION. Saves the union of LIST and the contents of the place designated by the first argument to the designated place.

Package

alexandria.

Source

lists.lisp.

Macro: unwind-protect-case ((&optional abort-flag) protected-form &body clauses)

Like CL:UNWIND-PROTECT, but you can specify the circumstances that
the cleanup CLAUSES are run.

clauses ::= (:NORMAL form*)* | (:ABORT form*)* | (:ALWAYS form*)*

Clauses can be given in any order, and more than one clause can be
given for each circumstance. The clauses whose denoted circumstance
occured, are executed in the order the clauses appear.

ABORT-FLAG is the name of a variable that will be bound to T in
CLAUSES if the PROTECTED-FORM aborted preemptively, and to NIL
otherwise.

Examples:

(unwind-protect-case ()
(protected-form)
(:normal (format t "This is only evaluated if PROTECTED-FORM executed normally.~%")) (:abort (format t "This is only evaluated if PROTECTED-FORM aborted preemptively.~%")) (:always (format t "This is evaluated in either case.~%")))

(unwind-protect-case (aborted-p)
(protected-form)
(:always (perform-cleanup-if aborted-p)))

Package

alexandria.

Source

conditions.lisp.

Macro: when-let (bindings &body forms)

Creates new variable bindings, and conditionally executes FORMS.

BINDINGS must be either single binding of the form:

(variable initial-form)

or a list of bindings of the form:

((variable-1 initial-form-1)
(variable-2 initial-form-2)
...
(variable-n initial-form-n))

All initial-forms are executed sequentially in the specified order. Then all the variables are bound to the corresponding values.

If all variables were bound to true values, then FORMS are executed as an implicit PROGN.

Package

alexandria.

Source

binding.lisp.

Macro: when-let* (bindings &body body)

Creates new variable bindings, and conditionally executes BODY.

BINDINGS must be either single binding of the form:

(variable initial-form)

or a list of bindings of the form:

((variable-1 initial-form-1)
(variable-2 initial-form-2)
...
(variable-n initial-form-n))

Each INITIAL-FORM is executed in turn, and the variable bound to the corresponding value. INITIAL-FORM expressions can refer to variables previously bound by the WHEN-LET*.

Execution of WHEN-LET* stops immediately if any INITIAL-FORM evaluates to NIL. If all INITIAL-FORMs evaluate to true, then BODY is executed as an implicit PROGN.

Package

alexandria.

Source

binding.lisp.

Macro: whichever (&rest possibilities)

Evaluates exactly one of POSSIBILITIES, chosen at random.

Package

alexandria.

Source

control-flow.lisp.

Macro: with-gensyms (names &body forms)

Binds a set of variables to gensyms and evaluates the implicit progn FORMS.

Each element within NAMES is either a symbol SYMBOL or a pair (SYMBOL STRING-DESIGNATOR). Bare symbols are equivalent to the pair (SYMBOL SYMBOL).

Each pair (SYMBOL STRING-DESIGNATOR) specifies that the variable named by SYMBOL should be bound to a symbol constructed using GENSYM with the string designated by STRING-DESIGNATOR being its first argument.

Package

alexandria.

Source

macros.lisp.

Macro: with-input-from-file ((stream-name file-name &rest args &key direction &allow-other-keys) &body body)

Evaluate BODY with STREAM-NAME to an input stream on the file FILE-NAME. ARGS is sent as is to the call to OPEN except EXTERNAL-FORMAT, which is only sent to WITH-OPEN-FILE when it’s not NIL.

Package

alexandria.

Source

io.lisp.

Macro: with-output-to-file ((stream-name file-name &rest args &key direction &allow-other-keys) &body body)

Evaluate BODY with STREAM-NAME to an output stream on the file FILE-NAME. ARGS is sent as is to the call to OPEN except EXTERNAL-FORMAT, which is only sent to WITH-OPEN-FILE when it’s not NIL.

Package

alexandria.

Source

io.lisp.

Macro: with-unique-names (names &body forms)

Alias for WITH-GENSYMS.

Package

alexandria.

Source

macros.lisp.

Macro: xor (&rest datums)

Evaluates its arguments one at a time, from left to right. If more than one argument evaluates to a true value no further DATUMS are evaluated, and NIL is returned as both primary and secondary value. If exactly one argument evaluates to true, its value is returned as the primary value after all the arguments have been evaluated, and T is returned as the secondary value. If no arguments evaluate to true NIL is returned as primary, and T as secondary value.

Package

alexandria.

Source

control-flow.lisp.


6.1.2 Compiler macros

Compiler Macro: compose (function &rest more-functions)
Package

alexandria.

Source

functions.lisp.

Compiler Macro: curry (function &rest arguments)
Package

alexandria.

Source

functions.lisp.

Compiler Macro: emptyp (sequence)
Package

alexandria.

Source

sequences.lisp.

Compiler Macro: length= (length &rest sequences)
Package

alexandria.

Source

sequences.lisp.

Compiler Macro: multiple-value-compose (function &rest more-functions)
Package

alexandria.

Source

functions.lisp.

Compiler Macro: of-type (type)
Package

alexandria.

Source

types.lisp.

Compiler Macro: rcurry (function &rest arguments)
Package

alexandria.

Source

functions.lisp.


6.1.3 Setf expanders

Setf Expander: (setf assoc-value) (place key &key test)
Package

alexandria.

Source

lists.lisp.

Reader

assoc-value (function).

Setf Expander: (setf rassoc-value) (place key &key test)
Package

alexandria.

Source

lists.lisp.

Reader

rassoc-value (function).


6.1.4 Ordinary functions

Function: alist-hash-table (alist &rest hash-table-initargs)

Returns a hash table containing the keys and values of the association list ALIST. Hash table is initialized using the HASH-TABLE-INITARGS.

Package

alexandria.

Source

hash-tables.lisp.

Function: alist-plist (alist)

Returns a property list containing the same keys and values as the association list ALIST in the same order.

Package

alexandria.

Source

lists.lisp.

Function: assoc-value (alist key &key test)

ASSOC-VALUE is an alist accessor very much like ASSOC, but it can be used with SETF.

Package

alexandria.

Source

lists.lisp.

Setf expander for this function

(setf assoc-value).

Function: binomial-coefficient (n k)

Binomial coefficient of N and K, also expressed as N choose K. This is the number of K element combinations given N choises. N must be equal to or greater then K.

Package

alexandria.

Source

numbers.lisp.

Function: circular-list (&rest elements)

Creates a circular list of ELEMENTS.

Package

alexandria.

Source

lists.lisp.

Function: circular-list-p (object)

Returns true if OBJECT is a circular list, NIL otherwise.

Package

alexandria.

Source

lists.lisp.

Function: circular-tree-p (object)

Returns true if OBJECT is a circular tree, NIL otherwise.

Package

alexandria.

Source

lists.lisp.

Function: clamp (number min max)

Clamps the NUMBER into [min, max] range. Returns MIN if NUMBER is lesser then MIN and MAX if NUMBER is greater then MAX, otherwise returns NUMBER.

Package

alexandria.

Source

numbers.lisp.

Function: compose (function &rest more-functions)

Returns a function composed of FUNCTION and MORE-FUNCTIONS that applies its arguments to to each in turn, starting from the rightmost of MORE-FUNCTIONS, and then calling the next one with the primary value of the last.

Package

alexandria.

Source

functions.lisp.

Function: conjoin (predicate &rest more-predicates)

Returns a function that applies each of PREDICATE and MORE-PREDICATE functions in turn to its arguments, returning NIL if any of the predicates returns false, without calling the remaining predicates. If none of the predicates returns false, returns the primary value of the last predicate.

Package

alexandria.

Source

functions.lisp.

Function: copy-array (array &key element-type fill-pointer adjustable)

Returns an undisplaced copy of ARRAY, with same fill-pointer and adjustability (if any) as the original, unless overridden by the keyword arguments.

Package

alexandria.

Source

arrays.lisp.

Function: copy-file (from to &key if-to-exists element-type finish-output)
Package

alexandria.

Source

io.lisp.

Function: copy-hash-table (table &key key test size rehash-size rehash-threshold)

Returns a copy of hash table TABLE, with the same keys and values as the TABLE. The copy has the same properties as the original, unless overridden by the keyword arguments.

Before each of the original values is set into the new hash-table, KEY is invoked on the value. As KEY defaults to CL:IDENTITY, a shallow copy is returned by default.

Package

alexandria.

Source

hash-tables.lisp.

Function: copy-sequence (type sequence)

Returns a fresh sequence of TYPE, which has the same elements as SEQUENCE.

Package

alexandria.

Source

sequences.lisp.

Function: copy-stream (input output &key element-type buffer-size buffer start end finish-output)

Reads data from INPUT and writes it to OUTPUT. Both INPUT and OUTPUT must
be streams, they will be passed to READ-SEQUENCE and WRITE-SEQUENCE and must have compatible element-types.

Package

alexandria.

Source

io.lisp.

Function: count-permutations (n &optional k)

Number of K element permutations for a sequence of N objects. K defaults to N

Package

alexandria.

Source

numbers.lisp.

Function: curry (function &rest arguments)

Returns a function that applies ARGUMENTS and the arguments it is called with to FUNCTION.

Package

alexandria.

Source

functions.lisp.

Function: delete-from-plist (plist &rest keys)

Just like REMOVE-FROM-PLIST, but this version may destructively modify the provided PLIST.

Package

alexandria.

Source

lists.lisp.

Function: delete-from-plist* (plist &rest keys)

Just like REMOVE-FROM-PLIST, but this version may destructively modify the provided PLIST.
The second return value is an alist of the removed items, in unspecified order.

Package

alexandria-2.

Source

lists.lisp.

Function: dim-in-bounds-p (dimensions &rest subscripts)

Mirrors cl:array-in-bounds-p, but takes dimensions (list of integers) as its first argument instead of an array.
(array-in-bounds-p arr ...) == (dim-in-bounds-p (array-dimensions arr) ...)

Package

alexandria-2.

Source

arrays.lisp.

Function: disjoin (predicate &rest more-predicates)

Returns a function that applies each of PREDICATE and MORE-PREDICATE functions in turn to its arguments, returning the primary value of the first predicate that returns true, without calling the remaining predicates. If none of the predicates returns true, NIL is returned.

Package

alexandria.

Source

functions.lisp.

Function: ends-with (object sequence &key test key)

Returns true if SEQUENCE is a sequence whose last element is EQL to OBJECT. Returns NIL if the SEQUENCE is not a sequence or is an empty sequence. Signals an error if SEQUENCE is an improper list.

Package

alexandria.

Source

sequences.lisp.

Function: ends-with-subseq (suffix sequence &key test)

Test whether SEQUENCE ends with SUFFIX. In other words: return true if the last (length SUFFIX) elements of SEQUENCE are equal to SUFFIX.

Package

alexandria.

Source

sequences.lisp.

Function: ensure-car (thing)

If THING is a CONS, its CAR is returned. Otherwise THING is returned.

Package

alexandria.

Source

lists.lisp.

Function: ensure-cons (cons)

If CONS is a cons, it is returned. Otherwise returns a fresh cons with CONS in the car, and NIL in the cdr.

Package

alexandria.

Source

lists.lisp.

Function: ensure-function (function-designator)

Returns the function designated by FUNCTION-DESIGNATOR:
if FUNCTION-DESIGNATOR is a function, it is returned, otherwise it must be a function name and its FDEFINITION is returned.

Package

alexandria.

Source

functions.lisp.

Function: ensure-list (list)

If LIST is a list, it is returned. Otherwise returns the list designated by LIST.

Package

alexandria.

Source

lists.lisp.

Function: ensure-symbol (name &optional package)

Returns a symbol with name designated by NAME, accessible in package designated by PACKAGE. If symbol is not already accessible in PACKAGE, it is interned there. Returns a secondary value reflecting the status of the symbol in the package, which matches the secondary return value of INTERN.

Example:

(ensure-symbol :cons :cl) => cl:cons, :external

Package

alexandria.

Source

symbols.lisp.

Function: extremum (sequence predicate &key key start end)

Returns the element of SEQUENCE that would appear first if the subsequence bounded by START and END was sorted using PREDICATE and KEY.

EXTREMUM determines the relationship between two elements of SEQUENCE by using the PREDICATE function. PREDICATE should return true if and only if the first argument is strictly less than the second one (in some appropriate sense). Two arguments X and Y are considered to be equal if (FUNCALL PREDICATE X Y) and (FUNCALL PREDICATE Y X) are both false.

The arguments to the PREDICATE function are computed from elements of SEQUENCE using the KEY function, if supplied. If KEY is not supplied or is NIL, the sequence element itself is used.

If SEQUENCE is empty, NIL is returned.

Package

alexandria.

Source

sequences.lisp.

Function: factorial (n)

Factorial of non-negative integer N.

Package

alexandria.

Source

numbers.lisp.

Function: featurep (feature-expression)

Returns T if the argument matches the state of the *FEATURES* list and NIL if it does not. FEATURE-EXPRESSION can be any atom or list acceptable to the reader macros #+ and #-.

Package

alexandria.

Source

features.lisp.

Function: first-elt (sequence)

Returns the first element of SEQUENCE. Signals a type-error if SEQUENCE is not a sequence, or is an empty sequence.

Package

alexandria.

Source

sequences.lisp.

Function: (setf first-elt) (sequence)

Sets the first element of SEQUENCE. Signals a type-error if SEQUENCE is
not a sequence, is an empty sequence, or if OBJECT cannot be stored in SEQUENCE.

Package

alexandria.

Source

sequences.lisp.

Function: flatten (tree)

Traverses the tree in order, collecting non-null leaves into a list.

Package

alexandria.

Source

lists.lisp.

Function: format-symbol (package control &rest arguments)

Constructs a string by applying ARGUMENTS to string designator CONTROL as if by FORMAT within WITH-STANDARD-IO-SYNTAX, and then creates a symbol named by that string.

If PACKAGE is NIL, returns an uninterned symbol, if package is T, returns a symbol interned in the current package, and otherwise returns a symbol interned in the package designated by PACKAGE.

Package

alexandria.

Source

symbols.lisp.

Function: gaussian-random (&optional min max)

Returns two gaussian random double floats as the primary and secondary value, optionally constrained by MIN and MAX. Gaussian random numbers form a standard normal distribution around 0.0d0.

Sufficiently positive MIN or negative MAX will cause the algorithm used to take a very long time. If MIN is positive it should be close to zero, and similarly if MAX is negative it should be close to zero.

Package

alexandria.

Source

numbers.lisp.

Function: hash-table-alist (table)

Returns an association list containing the keys and values of hash table TABLE.

Package

alexandria.

Source

hash-tables.lisp.

Function: hash-table-keys (table)

Returns a list containing the keys of hash table TABLE.

Package

alexandria.

Source

hash-tables.lisp.

Function: hash-table-plist (table)

Returns a property list containing the keys and values of hash table TABLE.

Package

alexandria.

Source

hash-tables.lisp.

Function: hash-table-values (table)

Returns a list containing the values of hash table TABLE.

Package

alexandria.

Source

hash-tables.lisp.

Function: iota (n &key start step)

Return a list of n numbers, starting from START (with numeric contagion from STEP applied), each consequtive number being the sum of the previous one and STEP. START defaults to 0 and STEP to 1.

Examples:

(iota 4) => (0 1 2 3)
(iota 3 :start 1 :step 1.0) => (1.0 2.0 3.0)
(iota 3 :start -1 :step -1/2) => (-1 -3/2 -2)

Package

alexandria.

Source

numbers.lisp.

Function: last-elt (sequence)

Returns the last element of SEQUENCE. Signals a type-error if SEQUENCE is not a proper sequence, or is an empty sequence.

Package

alexandria.

Source

sequences.lisp.

Function: (setf last-elt) (sequence)

Sets the last element of SEQUENCE. Signals a type-error if SEQUENCE is not a proper sequence, is an empty sequence, or if OBJECT cannot be stored in SEQUENCE.

Package

alexandria.

Source

sequences.lisp.

Function: lastcar (list)

Returns the last element of LIST. Signals a type-error if LIST is not a proper list.

Package

alexandria.

Source

lists.lisp.

Function: (setf lastcar) (list)

Sets the last element of LIST. Signals a type-error if LIST is not a proper list.

Package

alexandria.

Source

lists.lisp.

Function: length= (&rest sequences)

Takes any number of sequences or integers in any order. Returns true iff the length of all the sequences and the integers are equal. Hint: there’s a compiler macro that expands into more efficient code if the first argument is a literal integer.

Package

alexandria.

Source

sequences.lisp.

Function: lerp (v a b)

Returns the result of linear interpolation between A and B, using the interpolation coefficient V.

Package

alexandria.

Source

numbers.lisp.

Function: make-circular-list (length &key initial-element)

Creates a circular list of LENGTH with the given INITIAL-ELEMENT.

Package

alexandria.

Source

lists.lisp.

Function: make-gensym (name)

If NAME is a non-negative integer, calls GENSYM using it. Otherwise NAME must be a string designator, in which case calls GENSYM using the designated string as the argument.

Package

alexandria.

Source

symbols.lisp.

Function: make-gensym-list (length &optional x)

Returns a list of LENGTH gensyms, each generated as if with a call to MAKE-GENSYM, using the second (optional, defaulting to "G") argument.

Package

alexandria.

Source

symbols.lisp.

Function: make-keyword (name)

Interns the string designated by NAME in the KEYWORD package.

Package

alexandria.

Source

symbols.lisp.

Function: map-combinations (function sequence &key start end length copy)

Calls FUNCTION with each combination of LENGTH constructable from the elements of the subsequence of SEQUENCE delimited by START and END. START defaults to 0, END to length of SEQUENCE, and LENGTH to the length of the delimited subsequence. (So unless LENGTH is specified there is only a single combination, which has the same elements as the delimited subsequence.) If COPY is true (the default) each combination is freshly allocated. If COPY is false all combinations are EQ to each other, in which case consequences are unspecified if a combination is modified by FUNCTION.

Package

alexandria.

Source

sequences.lisp.

Function: map-derangements (function sequence &key start end copy)

Calls FUNCTION with each derangement of the subsequence of SEQUENCE denoted by the bounding index designators START and END. Derangement is a permutation of the sequence where no element remains in place. SEQUENCE is not modified, but individual derangements are EQ to each other. Consequences are unspecified if calling FUNCTION modifies either the derangement or SEQUENCE.

Package

alexandria.

Source

sequences.lisp.

Function: map-iota (function n &key start step)

Calls FUNCTION with N numbers, starting from START (with numeric contagion from STEP applied), each consequtive number being the sum of the previous one and STEP. START defaults to 0 and STEP to 1. Returns N.

Examples:

(map-iota #’print 3 :start 1 :step 1.0) => 3
;;; 1.0
;;; 2.0
;;; 3.0

Package

alexandria.

Source

numbers.lisp.

Function: map-permutations (function sequence &key start end length copy)

Calls function with each permutation of LENGTH constructable from the subsequence of SEQUENCE delimited by START and END. START defaults to 0, END to length of the sequence, and LENGTH to the length of the delimited subsequence.

Package

alexandria.

Source

sequences.lisp.

Function: map-product (function list &rest more-lists)

Returns a list containing the results of calling FUNCTION with one argument from LIST, and one from each of MORE-LISTS for each combination of arguments. In other words, returns the product of LIST and MORE-LISTS using FUNCTION.

Example:

(map-product ’list ’(1 2) ’(3 4) ’(5 6))
=> ((1 3 5) (1 3 6) (1 4 5) (1 4 6)
(2 3 5) (2 3 6) (2 4 5) (2 4 6))

Package

alexandria.

Source

lists.lisp.

Function: maphash-keys (function table)

Like MAPHASH, but calls FUNCTION with each key in the hash table TABLE.

Package

alexandria.

Source

hash-tables.lisp.

Function: maphash-values (function table)

Like MAPHASH, but calls FUNCTION with each value in the hash table TABLE.

Package

alexandria.

Source

hash-tables.lisp.

Function: mappend (function &rest lists)

Applies FUNCTION to respective element(s) of each LIST, appending all the all the result list to a single list. FUNCTION must return a list.

Package

alexandria.

Source

lists.lisp.

Function: mean (sample)

Returns the mean of SAMPLE. SAMPLE must be a sequence of numbers.

Package

alexandria.

Source

numbers.lisp.

Function: median (sample)

Returns median of SAMPLE. SAMPLE must be a sequence of real numbers.

Package

alexandria.

Source

numbers.lisp.

Function: multiple-value-compose (function &rest more-functions)

Returns a function composed of FUNCTION and MORE-FUNCTIONS that applies its arguments to each in turn, starting from the rightmost of MORE-FUNCTIONS, and then calling the next one with all the return values of the last.

Package

alexandria.

Source

functions.lisp.

Function: negative-double-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: negative-fixnum-p (n)
Package

alexandria.

Source

types.lisp.

Function: negative-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: negative-integer-p (n)
Package

alexandria.

Source

types.lisp.

Function: negative-long-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: negative-rational-p (n)
Package

alexandria.

Source

types.lisp.

Function: negative-real-p (n)
Package

alexandria.

Source

types.lisp.

Function: negative-short-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: negative-single-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-negative-double-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-negative-fixnum-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-negative-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-negative-integer-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-negative-long-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-negative-rational-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-negative-real-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-negative-short-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-negative-single-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-positive-double-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-positive-fixnum-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-positive-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-positive-integer-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-positive-long-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-positive-rational-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-positive-real-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-positive-short-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: non-positive-single-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: of-type (type)

Returns a function of one argument, which returns true when its argument is of TYPE.

Package

alexandria.

Source

types.lisp.

Function: parse-body (body &key documentation whole)

Parses BODY into (values remaining-forms declarations doc-string). Documentation strings are recognized only if DOCUMENTATION is true. Syntax errors in body are signalled and WHOLE is used in the signal arguments when given.

Package

alexandria.

Source

macros.lisp.

Function: parse-ordinary-lambda-list (lambda-list &key normalize allow-specializers normalize-optional normalize-keyword normalize-auxilary)

Parses an ordinary lambda-list, returning as multiple values:

1. Required parameters.

2. Optional parameter specifications, normalized into form:

(name init suppliedp)

3. Name of the rest parameter, or NIL.

4. Keyword parameter specifications, normalized into form:

((keyword-name name) init suppliedp)

5. Boolean indicating &ALLOW-OTHER-KEYS presence.

6. &AUX parameter specifications, normalized into form

(name init).

7. Existence of &KEY in the lambda-list.

Signals a PROGRAM-ERROR is the lambda-list is malformed.

Package

alexandria.

Source

macros.lisp.

Function: plist-alist (plist)

Returns an association list containing the same keys and values as the property list PLIST in the same order.

Package

alexandria.

Source

lists.lisp.

Function: plist-hash-table (plist &rest hash-table-initargs)

Returns a hash table containing the keys and values of the property list PLIST. Hash table is initialized using the HASH-TABLE-INITARGS.

Package

alexandria.

Source

hash-tables.lisp.

Function: positive-double-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: positive-fixnum-p (n)
Package

alexandria.

Source

types.lisp.

Function: positive-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: positive-integer-p (n)
Package

alexandria.

Source

types.lisp.

Function: positive-long-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: positive-rational-p (n)
Package

alexandria.

Source

types.lisp.

Function: positive-real-p (n)
Package

alexandria.

Source

types.lisp.

Function: positive-short-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: positive-single-float-p (n)
Package

alexandria.

Source

types.lisp.

Function: proper-list-length (list)

Returns length of LIST, signalling an error if it is not a proper list.

Package

alexandria.

Source

lists.lisp.

Function: proper-list-p (object)

Returns true if OBJECT is a proper list.

Package

alexandria.

Source

lists.lisp.

Function: random-elt (sequence &key start end)

Returns a random element from SEQUENCE bounded by START and END. Signals an error if the SEQUENCE is not a proper non-empty sequence, or if END and START are not proper bounding index designators for SEQUENCE.

Package

alexandria.

Source

sequences.lisp.

Function: rassoc-value (alist key &key test)

RASSOC-VALUE is an alist accessor very much like RASSOC, but it can be used with SETF.

Package

alexandria.

Source

lists.lisp.

Setf expander for this function

(setf rassoc-value).

Function: rcurry (function &rest arguments)

Returns a function that applies the arguments it is called with and ARGUMENTS to FUNCTION.

Package

alexandria.

Source

functions.lisp.

Function: read-file-into-byte-vector (pathname)

Read PATHNAME into a freshly allocated (unsigned-byte 8) vector.

Package

alexandria.

Source

io.lisp.

Function: read-file-into-string (pathname &key buffer-size external-format)

Return the contents of the file denoted by PATHNAME as a fresh string.

The EXTERNAL-FORMAT parameter will be passed directly to WITH-OPEN-FILE unless it’s NIL, which means the system default.

Package

alexandria.

Source

io.lisp.

Function: read-stream-content-into-byte-vector (stream &key %length initial-size)

Return "content" of STREAM as freshly allocated (unsigned-byte 8) vector.

Package

alexandria.

Source

io.lisp.

Function: read-stream-content-into-string (stream &key buffer-size)

Return the "content" of STREAM as a fresh string.

Package

alexandria.

Source

io.lisp.

Function: remove-from-plist (plist &rest keys)

Returns a property-list with same keys and values as PLIST, except that keys in the list designated by KEYS and values corresponding to them are removed. The returned property-list may share structure with the PLIST, but PLIST is not destructively modified. Keys are compared using EQ.

Package

alexandria.

Source

lists.lisp.

Function: required-argument (&optional name)

Signals an error for a missing argument of NAME. Intended for use as an initialization form for structure and class-slots, and a default value for required keyword arguments.

Package

alexandria.

Source

conditions.lisp.

Function: rmajor-to-indices (dimensions index)

The inverse function to row-major-index. Given a set of dimensions and a row-major index, produce the list of indices <subscripts> such that (row-major-index dimensions sucscripts) = index

Package

alexandria-2.

Source

arrays.lisp.

Function: rotate (sequence &optional n)

Returns a sequence of the same type as SEQUENCE, with the elements of SEQUENCE rotated by N: N elements are moved from the end of the sequence to the front if N is positive, and -N elements moved from the front to the end if N is negative. SEQUENCE must be a proper sequence. N must be an integer, defaulting to 1.

If absolute value of N is greater then the length of the sequence, the results are identical to calling ROTATE with

(* (signum n) (mod n (length sequence))).

Note: the original sequence may be destructively altered, and result sequence may share structure with it.

Package

alexandria.

Source

sequences.lisp.

Function: row-major-index (dimensions &rest subscripts)

Mirrors cl:array-row-major-index, but takes dimensions (list of integers)
as its first argument instead of an array.
Signals an error if lengths of dimensions and subscripts are not equal (array-row-major-index arr ...) == (row-major-index (array-dimensions arr) ...)

Package

alexandria-2.

Source

arrays.lisp.

Function: sequence-of-length-p (sequence length)

Return true if SEQUENCE is a sequence of length LENGTH. Signals an error if SEQUENCE is not a sequence. Returns FALSE for circular lists.

Package

alexandria.

Source

sequences.lisp.

Function: set-equal (list1 list2 &key test key)

Returns true if every element of LIST1 matches some element of LIST2 and every element of LIST2 matches some element of LIST1. Otherwise returns false.

Package

alexandria.

Source

lists.lisp.

Function: setp (object &key test key)

Returns true if OBJECT is a list that denotes a set, NIL otherwise. A list denotes a set if each element of the list is unique under KEY and TEST.

Package

alexandria.

Source

lists.lisp.

Function: shuffle (sequence &key start end)

Returns a random permutation of SEQUENCE bounded by START and END. Original sequence may be destructively modified.
Signals an error if SEQUENCE is not a proper sequence.

Package

alexandria.

Source

sequences.lisp.

Function: simple-parse-error (message &rest args)
Package

alexandria.

Source

conditions.lisp.

Function: simple-program-error (message &rest args)
Package

alexandria.

Source

conditions.lisp.

Function: simple-reader-error (stream message &rest args)
Package

alexandria.

Source

conditions.lisp.

Function: simple-style-warning (message &rest args)
Package

alexandria.

Source

conditions.lisp.

Function: standard-deviation (sample &key biased)

Standard deviation of SAMPLE. Returns the biased standard deviation if BIASED is true (the default), and the square root of the unbiased estimator for variance if BIASED is false (which is not the same as the unbiased estimator for standard deviation). SAMPLE must be a sequence of numbers.

Package

alexandria.

Source

numbers.lisp.

Function: starts-with (object sequence &key test key)

Returns true if SEQUENCE is a sequence whose first element is EQL to OBJECT. Returns NIL if the SEQUENCE is not a sequence or is an empty sequence.

Package

alexandria.

Source

sequences.lisp.

Function: starts-with-subseq (prefix sequence &rest args &key return-suffix &allow-other-keys)

Test whether the first elements of SEQUENCE are the same (as per TEST) as the elements of PREFIX.

If RETURN-SUFFIX is T the function returns, as a second value, a
sub-sequence or displaced array pointing to the sequence after PREFIX.

Package

alexandria.

Source

sequences.lisp.

Function: subfactorial (n)

Subfactorial of the non-negative integer N.

Package

alexandria.

Source

numbers.lisp.

Function: subseq* (sequence start &optional end)

Like SUBSEQ, but limits END to the length.

Package

alexandria-2.

Source

sequences.lisp.

Function: symbolicate (&rest things)

Concatenate together the names of some strings and symbols, producing a symbol in the current package.

Package

alexandria.

Source

symbols.lisp.

Function: type= (type1 type2)

Returns a primary value of T if TYPE1 and TYPE2 are the same type,
and a secondary value that is true is the type equality could be reliably determined: primary value of NIL and secondary value of T indicates that the types are not equivalent.

Package

alexandria.

Source

types.lisp.

Function: variance (sample &key biased)

Variance of SAMPLE. Returns the biased variance if BIASED is true (the default), and the unbiased estimator of variance if BIASED is false. SAMPLE must be a sequence of numbers.

Package

alexandria.

Source

numbers.lisp.

Function: write-byte-vector-into-file (bytes pathname &key if-exists if-does-not-exist)

Write BYTES to PATHNAME.

Package

alexandria.

Source

io.lisp.

Function: write-string-into-file (string pathname &key if-exists if-does-not-exist external-format)

Write STRING to PATHNAME.

The EXTERNAL-FORMAT parameter will be passed directly to WITH-OPEN-FILE unless it’s NIL, which means the system default.

Package

alexandria.

Source

io.lisp.


6.1.5 Generic functions

Generic Function: emptyp (sequence)

Returns T if SEQUENCE is an empty sequence and NIL otherwise. Signals an error if SEQUENCE is not a sequence.

Package

alexandria.

Alias for

emptyp.


6.1.6 Conditions

Condition: simple-parse-error
Package

alexandria.

Source

conditions.lisp.

Direct superclasses
  • parse-error.
  • simple-error.
Condition: simple-program-error
Package

alexandria.

Source

conditions.lisp.

Direct superclasses
  • program-error.
  • simple-error.
Condition: simple-reader-error
Package

alexandria.

Source

conditions.lisp.

Direct superclasses

simple-reader-error.

Condition: simple-style-warning
Package

alexandria.

Source

conditions.lisp.

Direct superclasses
  • simple-warning.
  • style-warning.

6.1.7 Types

Type: array-index (&optional length)

Type designator for an index into array of LENGTH: an integer between 0 (inclusive) and LENGTH (exclusive). LENGTH defaults to one less than ARRAY-DIMENSION-LIMIT.

Package

alexandria.

Source

types.lisp.

Type: array-length (&optional length)

Type designator for a dimension of an array of LENGTH: an integer between 0 (inclusive) and LENGTH (inclusive). LENGTH defaults to one less than ARRAY-DIMENSION-LIMIT.

Package

alexandria.

Source

types.lisp.

Type: circular-list ()

Type designator for circular lists. Implemented as a SATISFIES type, so not recommended for performance intensive use. Main usefullness as the expected-type designator of a TYPE-ERROR.

Package

alexandria.

Source

lists.lisp.

Type: negative-double-float ()

Type specifier denoting the double-float range from -inf to 0.0d0.

Package

alexandria.

Source

types.lisp.

Type: negative-fixnum ()

Type specifier denoting the fixnum range from MOST-NEGATIVE-FIXNUM to -1.

Package

alexandria.

Source

types.lisp.

Type: negative-float ()

Type specifier denoting the float range from -inf to 0.0.

Package

alexandria.

Source

types.lisp.

Type: negative-integer ()

Type specifier denoting the integer range from -inf to -1.

Package

alexandria.

Source

types.lisp.

Type: negative-long-float ()

Type specifier denoting the long-float range from -inf to 0.0d0.

Package

alexandria.

Source

types.lisp.

Type: negative-rational ()

Type specifier denoting the rational range from -inf to 0.

Package

alexandria.

Source

types.lisp.

Type: negative-real ()

Type specifier denoting the real range from -inf to 0.

Package

alexandria.

Source

types.lisp.

Type: negative-short-float ()

Type specifier denoting the short-float range from -inf to 0.0.

Package

alexandria.

Source

types.lisp.

Type: negative-single-float ()

Type specifier denoting the single-float range from -inf to 0.0.

Package

alexandria.

Source

types.lisp.

Type: non-negative-double-float ()

Type specifier denoting the double-float range from 0.0d0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: non-negative-fixnum ()

Type specifier denoting the fixnum range from 0 to MOST-POSITIVE-FIXNUM.

Package

alexandria.

Source

types.lisp.

Type: non-negative-float ()

Type specifier denoting the float range from 0.0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: non-negative-integer ()

Type specifier denoting the integer range from 0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: non-negative-long-float ()

Type specifier denoting the long-float range from 0.0d0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: non-negative-rational ()

Type specifier denoting the rational range from 0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: non-negative-real ()

Type specifier denoting the real range from 0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: non-negative-short-float ()

Type specifier denoting the short-float range from 0.0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: non-negative-single-float ()

Type specifier denoting the single-float range from 0.0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: non-positive-double-float ()

Type specifier denoting the double-float range from -inf to 0.0d0.

Package

alexandria.

Source

types.lisp.

Type: non-positive-fixnum ()

Type specifier denoting the fixnum range from MOST-NEGATIVE-FIXNUM to 0.

Package

alexandria.

Source

types.lisp.

Type: non-positive-float ()

Type specifier denoting the float range from -inf to 0.0.

Package

alexandria.

Source

types.lisp.

Type: non-positive-integer ()

Type specifier denoting the integer range from -inf to 0.

Package

alexandria.

Source

types.lisp.

Type: non-positive-long-float ()

Type specifier denoting the long-float range from -inf to 0.0d0.

Package

alexandria.

Source

types.lisp.

Type: non-positive-rational ()

Type specifier denoting the rational range from -inf to 0.

Package

alexandria.

Source

types.lisp.

Type: non-positive-real ()

Type specifier denoting the real range from -inf to 0.

Package

alexandria.

Source

types.lisp.

Type: non-positive-short-float ()

Type specifier denoting the short-float range from -inf to 0.0.

Package

alexandria.

Source

types.lisp.

Type: non-positive-single-float ()

Type specifier denoting the single-float range from -inf to 0.0.

Package

alexandria.

Source

types.lisp.

Type: positive-double-float ()

Type specifier denoting the double-float range from 0.0d0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: positive-fixnum ()

Type specifier denoting the fixnum range from 1 to MOST-POSITIVE-FIXNUM.

Package

alexandria.

Source

types.lisp.

Type: positive-float ()

Type specifier denoting the float range from 0.0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: positive-integer ()

Type specifier denoting the integer range from 1 to +inf.

Package

alexandria.

Source

types.lisp.

Type: positive-long-float ()

Type specifier denoting the long-float range from 0.0d0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: positive-rational ()

Type specifier denoting the rational range from 0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: positive-real ()

Type specifier denoting the real range from 0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: positive-short-float ()

Type specifier denoting the short-float range from 0.0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: positive-single-float ()

Type specifier denoting the single-float range from 0.0 to +inf.

Package

alexandria.

Source

types.lisp.

Type: proper-list ()

Type designator for proper lists. Implemented as a SATISFIES type, hence not recommended for performance intensive use. Main usefullness as a type designator of the expected type in a TYPE-ERROR.

Package

alexandria.

Source

lists.lisp.

Type: proper-sequence ()

Type designator for proper sequences, that is proper lists and sequences that are not lists.

Package

alexandria.

Source

sequences.lisp.

Type: string-designator ()

A string designator type. A string designator is either a string, a symbol, or a character.

Package

alexandria.

Source

strings.lisp.


6.2 Internals


6.2.1 Constants

Constant: +factorial-bisection-range-limit+
Package

alexandria.

Source

numbers.lisp.

Constant: +factorial-direct-multiplication-limit+
Package

alexandria.

Source

numbers.lisp.


6.2.2 Macros

Macro: ensure-functionf/1 (place)
Package

alexandria.

Source

functions.lisp.

Macro: with-open-file* ((stream filespec &key direction element-type if-exists if-does-not-exist external-format) &body body)

Just like WITH-OPEN-FILE, but NIL values in the keyword arguments mean to use the default value specified for OPEN.

Package

alexandria.

Source

io.lisp.


6.2.3 Ordinary functions

Function: %factorial (n)
Package

alexandria.

Source

numbers.lisp.

Function: %multiply-range (i j)
Package

alexandria.

Source

numbers.lisp.

Function: %reevaluate-constant (name value test)
Package

alexandria.

Source

definitions.lisp.

Function: circular-list-error (list)
Package

alexandria.

Source

lists.lisp.

Function: default-element-type ()
Package

alexandria.

Source

io.lisp.

Function: delete/swapped-arguments (sequence item &rest keyword-arguments)
Package

alexandria.

Source

sequences.lisp.

Function: expand-destructuring-case (key clauses case)
Package

alexandria.

Source

macros.lisp.

Function: extract-function-name (spec)

Useful for macros that want to mimic the functional interface for functions like #’eq and ’eq.

Package

alexandria.

Source

control-flow.lisp.

Function: generate-switch-body (whole object clauses test key &optional default)
Package

alexandria.

Source

control-flow.lisp.

Function: line-up-iter (thread-first-p acc forms)

Iterative implementation for ‘thread-iter’.

The THREAD-FIRST-P decides where to thread the FORMS, accumulating in ACC.

Package

alexandria-2.

Source

control-flow.lisp.

Function: malformed-plist (plist)
Package

alexandria.

Source

lists.lisp.

Function: maybe-intern (name package)
Package

alexandria.

Source

symbols.lisp.

Function: racons (key value ralist)
Package

alexandria.

Source

lists.lisp.

Function: remove/swapped-arguments (sequence item &rest keyword-arguments)
Package

alexandria.

Source

sequences.lisp.

Function: rotate-head-to-tail (sequence n)
Package

alexandria.

Source

sequences.lisp.

Function: rotate-tail-to-head (sequence n)
Package

alexandria.

Source

sequences.lisp.

Function: safe-endp (x)
Package

alexandria.

Source

lists.lisp.

Function: sans (plist &rest keys)

Alias of REMOVE-FROM-PLIST for backward compatibility.

Package

alexandria.

Source

lists.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

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

%
%factorial: Private ordinary functions
%multiply-range: Private ordinary functions
%reevaluate-constant: Private ordinary functions

(
(setf assoc-value): Public setf expanders
(setf first-elt): Public ordinary functions
(setf last-elt): Public ordinary functions
(setf lastcar): Public ordinary functions
(setf rassoc-value): Public setf expanders

A
alist-hash-table: Public ordinary functions
alist-plist: Public ordinary functions
appendf: Public macros
assoc-value: Public ordinary functions

B
binomial-coefficient: Public ordinary functions

C
circular-list: Public ordinary functions
circular-list-error: Private ordinary functions
circular-list-p: Public ordinary functions
circular-tree-p: Public ordinary functions
clamp: Public ordinary functions
coercef: Public macros
Compiler Macro, compose: Public compiler macros
Compiler Macro, curry: Public compiler macros
Compiler Macro, emptyp: Public compiler macros
Compiler Macro, length=: Public compiler macros
Compiler Macro, multiple-value-compose: Public compiler macros
Compiler Macro, of-type: Public compiler macros
Compiler Macro, rcurry: Public compiler macros
compose: Public compiler macros
compose: Public ordinary functions
conjoin: Public ordinary functions
copy-array: Public ordinary functions
copy-file: Public ordinary functions
copy-hash-table: Public ordinary functions
copy-sequence: Public ordinary functions
copy-stream: Public ordinary functions
count-permutations: Public ordinary functions
cswitch: Public macros
curry: Public compiler macros
curry: Public ordinary functions

D
default-element-type: Private ordinary functions
define-constant: Public macros
delete-from-plist: Public ordinary functions
delete-from-plist*: Public ordinary functions
delete-from-plistf: Public macros
delete/swapped-arguments: Private ordinary functions
deletef: Public macros
destructuring-case: Public macros
destructuring-ccase: Public macros
destructuring-ecase: Public macros
dim-in-bounds-p: Public ordinary functions
disjoin: Public ordinary functions
doplist: Public macros

E
emptyp: Public compiler macros
emptyp: Public generic functions
ends-with: Public ordinary functions
ends-with-subseq: Public ordinary functions
ensure-car: Public ordinary functions
ensure-cons: Public ordinary functions
ensure-function: Public ordinary functions
ensure-functionf: Public macros
ensure-functionf/1: Private macros
ensure-gethash: Public macros
ensure-list: Public ordinary functions
ensure-symbol: Public ordinary functions
eswitch: Public macros
expand-destructuring-case: Private ordinary functions
extract-function-name: Private ordinary functions
extremum: Public ordinary functions

F
factorial: Public ordinary functions
featurep: Public ordinary functions
first-elt: Public ordinary functions
flatten: Public ordinary functions
format-symbol: Public ordinary functions
Function, %factorial: Private ordinary functions
Function, %multiply-range: Private ordinary functions
Function, %reevaluate-constant: Private ordinary functions
Function, (setf first-elt): Public ordinary functions
Function, (setf last-elt): Public ordinary functions
Function, (setf lastcar): Public ordinary functions
Function, alist-hash-table: Public ordinary functions
Function, alist-plist: Public ordinary functions
Function, assoc-value: Public ordinary functions
Function, binomial-coefficient: Public ordinary functions
Function, circular-list: Public ordinary functions
Function, circular-list-error: Private ordinary functions
Function, circular-list-p: Public ordinary functions
Function, circular-tree-p: Public ordinary functions
Function, clamp: Public ordinary functions
Function, compose: Public ordinary functions
Function, conjoin: Public ordinary functions
Function, copy-array: Public ordinary functions
Function, copy-file: Public ordinary functions
Function, copy-hash-table: Public ordinary functions
Function, copy-sequence: Public ordinary functions
Function, copy-stream: Public ordinary functions
Function, count-permutations: Public ordinary functions
Function, curry: Public ordinary functions
Function, default-element-type: Private ordinary functions
Function, delete-from-plist: Public ordinary functions
Function, delete-from-plist*: Public ordinary functions
Function, delete/swapped-arguments: Private ordinary functions
Function, dim-in-bounds-p: Public ordinary functions
Function, disjoin: Public ordinary functions
Function, ends-with: Public ordinary functions
Function, ends-with-subseq: Public ordinary functions
Function, ensure-car: Public ordinary functions
Function, ensure-cons: Public ordinary functions
Function, ensure-function: Public ordinary functions
Function, ensure-list: Public ordinary functions
Function, ensure-symbol: Public ordinary functions
Function, expand-destructuring-case: Private ordinary functions
Function, extract-function-name: Private ordinary functions
Function, extremum: Public ordinary functions
Function, factorial: Public ordinary functions
Function, featurep: Public ordinary functions
Function, first-elt: Public ordinary functions
Function, flatten: Public ordinary functions
Function, format-symbol: Public ordinary functions
Function, gaussian-random: Public ordinary functions
Function, generate-switch-body: Private ordinary functions
Function, hash-table-alist: Public ordinary functions
Function, hash-table-keys: Public ordinary functions
Function, hash-table-plist: Public ordinary functions
Function, hash-table-values: Public ordinary functions
Function, iota: Public ordinary functions
Function, last-elt: Public ordinary functions
Function, lastcar: Public ordinary functions
Function, length=: Public ordinary functions
Function, lerp: Public ordinary functions
Function, line-up-iter: Private ordinary functions
Function, make-circular-list: Public ordinary functions
Function, make-gensym: Public ordinary functions
Function, make-gensym-list: Public ordinary functions
Function, make-keyword: Public ordinary functions
Function, malformed-plist: Private ordinary functions
Function, map-combinations: Public ordinary functions
Function, map-derangements: Public ordinary functions
Function, map-iota: Public ordinary functions
Function, map-permutations: Public ordinary functions
Function, map-product: Public ordinary functions
Function, maphash-keys: Public ordinary functions
Function, maphash-values: Public ordinary functions
Function, mappend: Public ordinary functions
Function, maybe-intern: Private ordinary functions
Function, mean: Public ordinary functions
Function, median: Public ordinary functions
Function, multiple-value-compose: Public ordinary functions
Function, negative-double-float-p: Public ordinary functions
Function, negative-fixnum-p: Public ordinary functions
Function, negative-float-p: Public ordinary functions
Function, negative-integer-p: Public ordinary functions
Function, negative-long-float-p: Public ordinary functions
Function, negative-rational-p: Public ordinary functions
Function, negative-real-p: Public ordinary functions
Function, negative-short-float-p: Public ordinary functions
Function, negative-single-float-p: Public ordinary functions
Function, non-negative-double-float-p: Public ordinary functions
Function, non-negative-fixnum-p: Public ordinary functions
Function, non-negative-float-p: Public ordinary functions
Function, non-negative-integer-p: Public ordinary functions
Function, non-negative-long-float-p: Public ordinary functions
Function, non-negative-rational-p: Public ordinary functions
Function, non-negative-real-p: Public ordinary functions
Function, non-negative-short-float-p: Public ordinary functions
Function, non-negative-single-float-p: Public ordinary functions
Function, non-positive-double-float-p: Public ordinary functions
Function, non-positive-fixnum-p: Public ordinary functions
Function, non-positive-float-p: Public ordinary functions
Function, non-positive-integer-p: Public ordinary functions
Function, non-positive-long-float-p: Public ordinary functions
Function, non-positive-rational-p: Public ordinary functions
Function, non-positive-real-p: Public ordinary functions
Function, non-positive-short-float-p: Public ordinary functions
Function, non-positive-single-float-p: Public ordinary functions
Function, of-type: Public ordinary functions
Function, parse-body: Public ordinary functions
Function, parse-ordinary-lambda-list: Public ordinary functions
Function, plist-alist: Public ordinary functions
Function, plist-hash-table: Public ordinary functions
Function, positive-double-float-p: Public ordinary functions
Function, positive-fixnum-p: Public ordinary functions
Function, positive-float-p: Public ordinary functions
Function, positive-integer-p: Public ordinary functions
Function, positive-long-float-p: Public ordinary functions
Function, positive-rational-p: Public ordinary functions
Function, positive-real-p: Public ordinary functions
Function, positive-short-float-p: Public ordinary functions
Function, positive-single-float-p: Public ordinary functions
Function, proper-list-length: Public ordinary functions
Function, proper-list-p: Public ordinary functions
Function, racons: Private ordinary functions
Function, random-elt: Public ordinary functions
Function, rassoc-value: Public ordinary functions
Function, rcurry: Public ordinary functions
Function, read-file-into-byte-vector: Public ordinary functions
Function, read-file-into-string: Public ordinary functions
Function, read-stream-content-into-byte-vector: Public ordinary functions
Function, read-stream-content-into-string: Public ordinary functions
Function, remove-from-plist: Public ordinary functions
Function, remove/swapped-arguments: Private ordinary functions
Function, required-argument: Public ordinary functions
Function, rmajor-to-indices: Public ordinary functions
Function, rotate: Public ordinary functions
Function, rotate-head-to-tail: Private ordinary functions
Function, rotate-tail-to-head: Private ordinary functions
Function, row-major-index: Public ordinary functions
Function, safe-endp: Private ordinary functions
Function, sans: Private ordinary functions
Function, sequence-of-length-p: Public ordinary functions
Function, set-equal: Public ordinary functions
Function, setp: Public ordinary functions
Function, shuffle: Public ordinary functions
Function, simple-parse-error: Public ordinary functions
Function, simple-program-error: Public ordinary functions
Function, simple-reader-error: Public ordinary functions
Function, simple-style-warning: Public ordinary functions
Function, standard-deviation: Public ordinary functions
Function, starts-with: Public ordinary functions
Function, starts-with-subseq: Public ordinary functions
Function, subfactorial: Public ordinary functions
Function, subseq*: Public ordinary functions
Function, symbolicate: Public ordinary functions
Function, type=: Public ordinary functions
Function, variance: Public ordinary functions
Function, write-byte-vector-into-file: Public ordinary functions
Function, write-string-into-file: Public ordinary functions

G
gaussian-random: Public ordinary functions
generate-switch-body: Private ordinary functions
Generic Function, emptyp: Public generic functions

H
hash-table-alist: Public ordinary functions
hash-table-keys: Public ordinary functions
hash-table-plist: Public ordinary functions
hash-table-values: Public ordinary functions

I
if-let: Public macros
ignore-some-conditions: Public macros
iota: Public ordinary functions

L
last-elt: Public ordinary functions
lastcar: Public ordinary functions
length=: Public compiler macros
length=: Public ordinary functions
lerp: Public ordinary functions
line-up-first: Public macros
line-up-iter: Private ordinary functions
line-up-last: Public macros

M
Macro, appendf: Public macros
Macro, coercef: Public macros
Macro, cswitch: Public macros
Macro, define-constant: Public macros
Macro, delete-from-plistf: Public macros
Macro, deletef: Public macros
Macro, destructuring-case: Public macros
Macro, destructuring-ccase: Public macros
Macro, destructuring-ecase: Public macros
Macro, doplist: Public macros
Macro, ensure-functionf: Public macros
Macro, ensure-functionf/1: Private macros
Macro, ensure-gethash: Public macros
Macro, eswitch: Public macros
Macro, if-let: Public macros
Macro, ignore-some-conditions: Public macros
Macro, line-up-first: Public macros
Macro, line-up-last: Public macros
Macro, maxf: Public macros
Macro, minf: Public macros
Macro, multiple-value-prog2: Public macros
Macro, named-lambda: Public macros
Macro, nconcf: Public macros
Macro, nreversef: Public macros
Macro, nth-value-or: Public macros
Macro, nunionf: Public macros
Macro, once-only: Public macros
Macro, remove-from-plistf: Public macros
Macro, removef: Public macros
Macro, reversef: Public macros
Macro, switch: Public macros
Macro, unionf: Public macros
Macro, unwind-protect-case: Public macros
Macro, when-let: Public macros
Macro, when-let*: Public macros
Macro, whichever: Public macros
Macro, with-gensyms: Public macros
Macro, with-input-from-file: Public macros
Macro, with-open-file*: Private macros
Macro, with-output-to-file: Public macros
Macro, with-unique-names: Public macros
Macro, xor: Public macros
make-circular-list: Public ordinary functions
make-gensym: Public ordinary functions
make-gensym-list: Public ordinary functions
make-keyword: Public ordinary functions
malformed-plist: Private ordinary functions
map-combinations: Public ordinary functions
map-derangements: Public ordinary functions
map-iota: Public ordinary functions
map-permutations: Public ordinary functions
map-product: Public ordinary functions
maphash-keys: Public ordinary functions
maphash-values: Public ordinary functions
mappend: Public ordinary functions
maxf: Public macros
maybe-intern: Private ordinary functions
mean: Public ordinary functions
median: Public ordinary functions
minf: Public macros
multiple-value-compose: Public compiler macros
multiple-value-compose: Public ordinary functions
multiple-value-prog2: Public macros

N
named-lambda: Public macros
nconcf: Public macros
negative-double-float-p: Public ordinary functions
negative-fixnum-p: Public ordinary functions
negative-float-p: Public ordinary functions
negative-integer-p: Public ordinary functions
negative-long-float-p: Public ordinary functions
negative-rational-p: Public ordinary functions
negative-real-p: Public ordinary functions
negative-short-float-p: Public ordinary functions
negative-single-float-p: Public ordinary functions
non-negative-double-float-p: Public ordinary functions
non-negative-fixnum-p: Public ordinary functions
non-negative-float-p: Public ordinary functions
non-negative-integer-p: Public ordinary functions
non-negative-long-float-p: Public ordinary functions
non-negative-rational-p: Public ordinary functions
non-negative-real-p: Public ordinary functions
non-negative-short-float-p: Public ordinary functions
non-negative-single-float-p: Public ordinary functions
non-positive-double-float-p: Public ordinary functions
non-positive-fixnum-p: Public ordinary functions
non-positive-float-p: Public ordinary functions
non-positive-integer-p: Public ordinary functions
non-positive-long-float-p: Public ordinary functions
non-positive-rational-p: Public ordinary functions
non-positive-real-p: Public ordinary functions
non-positive-short-float-p: Public ordinary functions
non-positive-single-float-p: Public ordinary functions
nreversef: Public macros
nth-value-or: Public macros
nunionf: Public macros

O
of-type: Public compiler macros
of-type: Public ordinary functions
once-only: Public macros

P
parse-body: Public ordinary functions
parse-ordinary-lambda-list: Public ordinary functions
plist-alist: Public ordinary functions
plist-hash-table: Public ordinary functions
positive-double-float-p: Public ordinary functions
positive-fixnum-p: Public ordinary functions
positive-float-p: Public ordinary functions
positive-integer-p: Public ordinary functions
positive-long-float-p: Public ordinary functions
positive-rational-p: Public ordinary functions
positive-real-p: Public ordinary functions
positive-short-float-p: Public ordinary functions
positive-single-float-p: Public ordinary functions
proper-list-length: Public ordinary functions
proper-list-p: Public ordinary functions

R
racons: Private ordinary functions
random-elt: Public ordinary functions
rassoc-value: Public ordinary functions
rcurry: Public compiler macros
rcurry: Public ordinary functions
read-file-into-byte-vector: Public ordinary functions
read-file-into-string: Public ordinary functions
read-stream-content-into-byte-vector: Public ordinary functions
read-stream-content-into-string: Public ordinary functions
remove-from-plist: Public ordinary functions
remove-from-plistf: Public macros
remove/swapped-arguments: Private ordinary functions
removef: Public macros
required-argument: Public ordinary functions
reversef: Public macros
rmajor-to-indices: Public ordinary functions
rotate: Public ordinary functions
rotate-head-to-tail: Private ordinary functions
rotate-tail-to-head: Private ordinary functions
row-major-index: Public ordinary functions

S
safe-endp: Private ordinary functions
sans: Private ordinary functions
sequence-of-length-p: Public ordinary functions
set-equal: Public ordinary functions
Setf Expander, (setf assoc-value): Public setf expanders
Setf Expander, (setf rassoc-value): Public setf expanders
setp: Public ordinary functions
shuffle: Public ordinary functions
simple-parse-error: Public ordinary functions
simple-program-error: Public ordinary functions
simple-reader-error: Public ordinary functions
simple-style-warning: Public ordinary functions
standard-deviation: Public ordinary functions
starts-with: Public ordinary functions
starts-with-subseq: Public ordinary functions
subfactorial: Public ordinary functions
subseq*: Public ordinary functions
switch: Public macros
symbolicate: Public ordinary functions

T
type=: Public ordinary functions

U
unionf: Public macros
unwind-protect-case: Public macros

V
variance: Public ordinary functions

W
when-let: Public macros
when-let*: Public macros
whichever: Public macros
with-gensyms: Public macros
with-input-from-file: Public macros
with-open-file*: Private macros
with-output-to-file: Public macros
with-unique-names: Public macros
write-byte-vector-into-file: Public ordinary functions
write-string-into-file: Public ordinary functions

X
xor: Public macros


A.4 Data types

Jump to:   A   B   C   D   F   H   I   L   M   N   P   S   T  
Index Entry  Section

A
alexandria: The alexandria system
alexandria: The alexandria package
alexandria-1: The alexandria/alexandria-1 module
alexandria-2: The alexandria/alexandria-2 module
alexandria-2: The alexandria-2 package
alexandria.asd: The alexandria/alexandria․asd file
array-index: Public types
array-length: Public types
arrays.lisp: The alexandria/alexandria-1/arrays․lisp file
arrays.lisp: The alexandria/alexandria-2/arrays․lisp file

B
binding.lisp: The alexandria/alexandria-1/binding․lisp file

C
circular-list: Public types
Condition, simple-parse-error: Public conditions
Condition, simple-program-error: Public conditions
Condition, simple-reader-error: Public conditions
Condition, simple-style-warning: Public conditions
conditions.lisp: The alexandria/alexandria-1/conditions․lisp file
control-flow.lisp: The alexandria/alexandria-1/control-flow․lisp file
control-flow.lisp: The alexandria/alexandria-2/control-flow․lisp file

D
definitions.lisp: The alexandria/alexandria-1/definitions․lisp file

F
features.lisp: The alexandria/alexandria-1/features․lisp file
File, alexandria.asd: The alexandria/alexandria․asd file
File, arrays.lisp: The alexandria/alexandria-1/arrays․lisp file
File, arrays.lisp: The alexandria/alexandria-2/arrays․lisp file
File, binding.lisp: The alexandria/alexandria-1/binding․lisp file
File, conditions.lisp: The alexandria/alexandria-1/conditions․lisp file
File, control-flow.lisp: The alexandria/alexandria-1/control-flow․lisp file
File, control-flow.lisp: The alexandria/alexandria-2/control-flow․lisp file
File, definitions.lisp: The alexandria/alexandria-1/definitions․lisp file
File, features.lisp: The alexandria/alexandria-1/features․lisp file
File, functions.lisp: The alexandria/alexandria-1/functions․lisp file
File, hash-tables.lisp: The alexandria/alexandria-1/hash-tables․lisp file
File, io.lisp: The alexandria/alexandria-1/io․lisp file
File, licence: The alexandria/licence file
File, lists.lisp: The alexandria/alexandria-1/lists․lisp file
File, lists.lisp: The alexandria/alexandria-2/lists․lisp file
File, macros.lisp: The alexandria/alexandria-1/macros․lisp file
File, numbers.lisp: The alexandria/alexandria-1/numbers․lisp file
File, package.lisp: The alexandria/alexandria-1/package․lisp file
File, package.lisp: The alexandria/alexandria-2/package․lisp file
File, sequences.lisp: The alexandria/alexandria-1/sequences․lisp file
File, sequences.lisp: The alexandria/alexandria-2/sequences․lisp file
File, strings.lisp: The alexandria/alexandria-1/strings․lisp file
File, symbols.lisp: The alexandria/alexandria-1/symbols․lisp file
File, tests.lisp: The alexandria/alexandria-1/tests․lisp file
File, tests.lisp: The alexandria/alexandria-2/tests․lisp file
File, types.lisp: The alexandria/alexandria-1/types․lisp file
functions.lisp: The alexandria/alexandria-1/functions․lisp file

H
hash-tables.lisp: The alexandria/alexandria-1/hash-tables․lisp file

I
io.lisp: The alexandria/alexandria-1/io․lisp file

L
licence: The alexandria/licence file
lists.lisp: The alexandria/alexandria-1/lists․lisp file
lists.lisp: The alexandria/alexandria-2/lists․lisp file

M
macros.lisp: The alexandria/alexandria-1/macros․lisp file
Module, alexandria-1: The alexandria/alexandria-1 module
Module, alexandria-2: The alexandria/alexandria-2 module

N
negative-double-float: Public types
negative-fixnum: Public types
negative-float: Public types
negative-integer: Public types
negative-long-float: Public types
negative-rational: Public types
negative-real: Public types
negative-short-float: Public types
negative-single-float: Public types
non-negative-double-float: Public types
non-negative-fixnum: Public types
non-negative-float: Public types
non-negative-integer: Public types
non-negative-long-float: Public types
non-negative-rational: Public types
non-negative-real: Public types
non-negative-short-float: Public types
non-negative-single-float: Public types
non-positive-double-float: Public types
non-positive-fixnum: Public types
non-positive-float: Public types
non-positive-integer: Public types
non-positive-long-float: Public types
non-positive-rational: Public types
non-positive-real: Public types
non-positive-short-float: Public types
non-positive-single-float: Public types
numbers.lisp: The alexandria/alexandria-1/numbers․lisp file

P
Package, alexandria: The alexandria package
Package, alexandria-2: The alexandria-2 package
package.lisp: The alexandria/alexandria-1/package․lisp file
package.lisp: The alexandria/alexandria-2/package․lisp file
positive-double-float: Public types
positive-fixnum: Public types
positive-float: Public types
positive-integer: Public types
positive-long-float: Public types
positive-rational: Public types
positive-real: Public types
positive-short-float: Public types
positive-single-float: Public types
proper-list: Public types
proper-sequence: Public types

S
sequences.lisp: The alexandria/alexandria-1/sequences․lisp file
sequences.lisp: The alexandria/alexandria-2/sequences․lisp file
simple-parse-error: Public conditions
simple-program-error: Public conditions
simple-reader-error: Public conditions
simple-style-warning: Public conditions
string-designator: Public types
strings.lisp: The alexandria/alexandria-1/strings․lisp file
symbols.lisp: The alexandria/alexandria-1/symbols․lisp file
System, alexandria: The alexandria system

T
tests.lisp: The alexandria/alexandria-1/tests․lisp file
tests.lisp: The alexandria/alexandria-2/tests․lisp file
Type, array-index: Public types
Type, array-length: Public types
Type, circular-list: Public types
Type, negative-double-float: Public types
Type, negative-fixnum: Public types
Type, negative-float: Public types
Type, negative-integer: Public types
Type, negative-long-float: Public types
Type, negative-rational: Public types
Type, negative-real: Public types
Type, negative-short-float: Public types
Type, negative-single-float: Public types
Type, non-negative-double-float: Public types
Type, non-negative-fixnum: Public types
Type, non-negative-float: Public types
Type, non-negative-integer: Public types
Type, non-negative-long-float: Public types
Type, non-negative-rational: Public types
Type, non-negative-real: Public types
Type, non-negative-short-float: Public types
Type, non-negative-single-float: Public types
Type, non-positive-double-float: Public types
Type, non-positive-fixnum: Public types
Type, non-positive-float: Public types
Type, non-positive-integer: Public types
Type, non-positive-long-float: Public types
Type, non-positive-rational: Public types
Type, non-positive-real: Public types
Type, non-positive-short-float: Public types
Type, non-positive-single-float: Public types
Type, positive-double-float: Public types
Type, positive-fixnum: Public types
Type, positive-float: Public types
Type, positive-integer: Public types
Type, positive-long-float: Public types
Type, positive-rational: Public types
Type, positive-real: Public types
Type, positive-short-float: Public types
Type, positive-single-float: Public types
Type, proper-list: Public types
Type, proper-sequence: Public types
Type, string-designator: Public types
types.lisp: The alexandria/alexandria-1/types․lisp file