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

The abstract-arrays Reference Manual

This is the abstract-arrays Reference Manual, version 0.2.4, generated automatically by Declt version 4.0 beta 2 "William Riker" on Fri Sep 15 03:13:03 2023 GMT+0.

1 Introduction
2 Systems
- 2.1 abstract-arrays
3 Files
- 3.1 Lisp
4 Packages
- 4.1 abstract-arrays
- 4.2 abstract-arrays/defpackage
5 Definitions
- 5.1 Public Interface
- 5.2 Internals
Appendix A Indexes

Next: Systems, Previous: The abstract-arrays Reference Manual, Up: The abstract-arrays Reference Manual [Contents][Index]

1 Introduction

Next: Files, Previous: Introduction, Up: The abstract-arrays Reference Manual [Contents][Index]

2 Systems

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

abstract-arrays

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

2.1 `abstract-arrays`

Julia’s AbstractArray like abstraction for Common Lisp.

Author

License

MIT

Version

0.2.4

Dependencies

polymorphic-functions (system).
alexandria (system).
extensible-compound-types (system).
optima (system)., for feature :extensible-compound-types
closer-mop (system).
introspect-environment (system).
trivial-types (system).

Source

abstract-arrays.asd.

Child Components

pre-package.lisp (file).
package.lisp (file).
abstract-array-ordered-class.lisp (file).
abstract-array.lisp (file).
remaining-protocol.lisp (file).
parametric-types.lisp (file).
specializations.lisp (file).
conditions.lisp (file).

Next: Packages, Previous: Systems, Up: The abstract-arrays Reference Manual [Contents][Index]

3 Files

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

Lisp

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

3.1 Lisp

abstract-arrays/abstract-arrays.asd
abstract-arrays/pre-package.lisp
abstract-arrays/package.lisp
abstract-arrays/abstract-array-ordered-class.lisp
abstract-arrays/abstract-array.lisp
abstract-arrays/remaining-protocol.lisp
abstract-arrays/parametric-types.lisp
abstract-arrays/specializations.lisp
abstract-arrays/conditions.lisp

Next: abstract-arrays/pre-package.lisp, Previous: Lisp, Up: Lisp [Contents][Index]

3.1.1 `abstract-arrays/abstract-arrays.asd`

Source: abstract-arrays.asd.
Parent Component: abstract-arrays (system).
ASDF Systems: abstract-arrays.

Next: abstract-arrays/package.lisp, Previous: abstract-arrays/abstract-arrays.asd, Up: Lisp [Contents][Index]

3.1.2 `abstract-arrays/pre-package.lisp`

Source: abstract-arrays.asd.
Parent Component: abstract-arrays (system).
Packages: abstract-arrays/defpackage.
Internals: export-symbols (function).

Next: abstract-arrays/abstract-array-ordered-class.lisp, Previous: abstract-arrays/pre-package.lisp, Up: Lisp [Contents][Index]

3.1.3 `abstract-arrays/package.lisp`

Dependency: pre-package.lisp (file).
Source: abstract-arrays.asd.
Parent Component: abstract-arrays (system).
Packages: abstract-arrays.

Next: abstract-arrays/abstract-array.lisp, Previous: abstract-arrays/package.lisp, Up: Lisp [Contents][Index]

3.1.4 `abstract-arrays/abstract-array-ordered-class.lisp`

Dependency

package.lisp (file).

Source

abstract-arrays.asd.

Parent Component

abstract-arrays (system).

Public Interface

abstract-array-class (class).
compute-slots (method).
slot-unbound (method).
validate-superclass (method).

Internals

collect-ordered-class-accessor-names (function).
define-ordered-class (macro).
generate-ordered-class-fast-accessors (function).
generate-ordered-class-options (function).
generate-ordered-class-slot-specifiers (function).
order (reader method).
plist-keys (function).
plist-remove (function).
plist-values (function).

Next: abstract-arrays/remaining-protocol.lisp, Previous: abstract-arrays/abstract-array-ordered-class.lisp, Up: Lisp [Contents][Index]

3.1.5 `abstract-arrays/abstract-array.lisp`

Dependency

abstract-array-ordered-class.lisp (file).

Source

abstract-arrays.asd.

Parent Component

abstract-arrays (system).

Public Interface

abstract-array (class).
abstract-array-dimensions (function).
array-dimensions (function).
array-element-type (function).
array-rank (function).
array-total-size (function).
define-array-class (macro).

Internals

+abstract-array-slot-order+ (constant).
define-ordered-class-with-required-slots (macro).

Next: abstract-arrays/parametric-types.lisp, Previous: abstract-arrays/abstract-array.lisp, Up: Lisp [Contents][Index]

3.1.6 `abstract-arrays/remaining-protocol.lisp`

Dependency

abstract-array.lisp (file).

Source

abstract-arrays.asd.

Parent Component

abstract-arrays (system).

Public Interface

array-dimension (function).
(setf array-storage-ref) (compiler macro).
array-storage-ref (function).
(setf array-storage-ref) (function).
array-storage-set (function).
arrayp (function).
column-major-aref (compiler macro).
(setf column-major-aref) (compiler macro).
column-major-aref (function).
(setf column-major-aref) (function).
narray-dimensions (function).

Next: abstract-arrays/specializations.lisp, Previous: abstract-arrays/remaining-protocol.lisp, Up: Lisp [Contents][Index]

3.1.7 `abstract-arrays/parametric-types.lisp`

Dependency

remaining-protocol.lisp (file).

Source

abstract-arrays.asd.

Parent Component

abstract-arrays (system).

Public Interface

*array-class-type-alist* (special variable).

Internals

atom-like-p (function).
define-methods-for-parametric-type-lambda-bodies (macro).
parametric-type-compile-time-lambda-body-for-arrays (function).

Next: abstract-arrays/conditions.lisp, Previous: abstract-arrays/parametric-types.lisp, Up: Lisp [Contents][Index]

3.1.8 `abstract-arrays/specializations.lisp`

Dependency

parametric-types.lisp (file).

Source

abstract-arrays.asd.

Parent Component

abstract-arrays (system).

Public Interface

array-type-dimensions (function).
array-type-element-type (function).
array-type-rank (function).
define-array-specialization-type (macro).
define-array-specializations (macro).

Internals

*element-type-p-fn-name-element-type-alist* (special variable).
*rank-p-fn-name-rank-alist* (special variable).
abstract-array-element-type-(complex⎵double-float)-p (function).
abstract-array-element-type-(complex⎵single-float)-p (function).
abstract-array-element-type-(integer⎵-128⎵127)-p (function).
abstract-array-element-type-(integer⎵-2147483648⎵2147483647)-p (function).
abstract-array-element-type-(integer⎵-32768⎵32767)-p (function).
abstract-array-element-type-(integer⎵-9223372036854775808⎵9223372036854775807)-p (function).
abstract-array-element-type-(integer⎵0⎵18446744073709551615)-p (function).
abstract-array-element-type-(integer⎵0⎵255)-p (function).
abstract-array-element-type-(integer⎵0⎵4294967295)-p (function).
abstract-array-element-type-(integer⎵0⎵65535)-p (function).
abstract-array-element-type-bit-p (function).
abstract-array-element-type-double-float-p (function).
abstract-array-element-type-fixnum-p (function).
abstract-array-element-type-nil-p (function).
abstract-array-element-type-single-float-p (function).
abstract-array-element-type-t-p (function).
abstract-array-rank-0-p (function).
abstract-array-rank-1-p (function).
abstract-array-rank-2-p (function).
abstract-array-rank-3-p (function).
abstract-array-rank-4-p (function).
abstract-array-rank-5-p (function).
abstract-array-rank-6-p (function).
abstract-array-rank-7-p (function).
define-array-element-type-specialization (macro).
define-array-rank-specialization (macro).
element-type-p-fn-name (function).
rank-p-fn-name (function).

Previous: abstract-arrays/specializations.lisp, Up: Lisp [Contents][Index]

3.1.9 `abstract-arrays/conditions.lisp`

Dependency: specializations.lisp (file).
Source: abstract-arrays.asd.
Parent Component: abstract-arrays (system).
Public Interface: invalid-array-index (condition).

Next: Definitions, Previous: Files, Up: The abstract-arrays Reference Manual [Contents][Index]

4 Packages

Packages are listed by definition order.

abstract-arrays
abstract-arrays/defpackage

Next: abstract-arrays/defpackage, Previous: Packages, Up: Packages [Contents][Index]

4.1 `abstract-arrays`

Source

package.lisp.

Use List

common-lisp.

Public Interface

*array-class-type-alist* (special variable).
abstract-array (class).
abstract-array-class (class).
abstract-array-dimensions (function).
aref (compiler macro).
(setf aref) (compiler macro).
array-dimension (function).
array-dimensions (compiler macro).
array-dimensions (function).
array-element-type (compiler macro).
array-element-type (function).
array-rank (compiler macro).
array-rank (function).
array-storage (compiler macro).
array-storage-ref (compiler macro).
(setf array-storage-ref) (compiler macro).
array-storage-ref (function).
(setf array-storage-ref) (function).
array-storage-set (compiler macro).
array-storage-set (function).
array-total-size (compiler macro).
array-total-size (function).
array-type-dimensions (function).
array-type-element-type (function).
array-type-rank (function).
arrayp (function).
col-major-aref (compiler macro).
(setf col-major-aref) (compiler macro).
column-major-aref (compiler macro).
(setf column-major-aref) (compiler macro).
column-major-aref (function).
(setf column-major-aref) (function).
define-array-class (macro).
define-array-specialization-type (macro).
define-array-specializations (macro).
invalid-array-index (condition).
narray-dimensions (compiler macro).
narray-dimensions (function).
row-major-aref (compiler macro).
(setf row-major-aref) (compiler macro).

Internals

*element-type-p-fn-name-element-type-alist* (special variable).
*rank-p-fn-name-rank-alist* (special variable).
+abstract-array-slot-order+ (constant).
abstract-array-element-type-(complex⎵double-float)-p (function).
abstract-array-element-type-(complex⎵single-float)-p (function).
abstract-array-element-type-(integer⎵-128⎵127)-p (function).
abstract-array-element-type-(integer⎵-2147483648⎵2147483647)-p (function).
abstract-array-element-type-(integer⎵-32768⎵32767)-p (function).
abstract-array-element-type-(integer⎵-9223372036854775808⎵9223372036854775807)-p (function).
abstract-array-element-type-(integer⎵0⎵18446744073709551615)-p (function).
abstract-array-element-type-(integer⎵0⎵255)-p (function).
abstract-array-element-type-(integer⎵0⎵4294967295)-p (function).
abstract-array-element-type-(integer⎵0⎵65535)-p (function).
abstract-array-element-type-bit-p (function).
abstract-array-element-type-double-float-p (function).
abstract-array-element-type-fixnum-p (function).
abstract-array-element-type-nil-p (function).
abstract-array-element-type-single-float-p (function).
abstract-array-element-type-t-p (function).
abstract-array-rank-0-p (function).
abstract-array-rank-1-p (function).
abstract-array-rank-2-p (function).
abstract-array-rank-3-p (function).
abstract-array-rank-4-p (function).
abstract-array-rank-5-p (function).
abstract-array-rank-6-p (function).
abstract-array-rank-7-p (function).
atom-like-p (function).
collect-ordered-class-accessor-names (function).
define-array-element-type-specialization (macro).
define-array-rank-specialization (macro).
define-methods-for-parametric-type-lambda-bodies (macro).
define-ordered-class (macro).
define-ordered-class-with-required-slots (macro).
element-type-p-fn-name (function).
generate-ordered-class-fast-accessors (function).
generate-ordered-class-options (function).
generate-ordered-class-slot-specifiers (function).
order (generic reader).
parametric-type-compile-time-lambda-body-for-arrays (function).
plist-keys (function).
plist-remove (function).
plist-values (function).
rank-p-fn-name (function).

Previous: abstract-arrays, Up: Packages [Contents][Index]

4.2 `abstract-arrays/defpackage`

Source: pre-package.lisp.
Use List: common-lisp.
Internals: export-symbols (function).

Next: Indexes, Previous: Packages, Up: The abstract-arrays Reference Manual [Contents][Index]

5 Definitions

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

Public Interface
Internals

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

Next: Macros, Previous: Public Interface, Up: Public Interface [Contents][Index]

5.1.1 Special variables

Special Variable: *array-class-type-alist* ¶

An ALIST used by POLYMORPHIC-FUNCTIONS:SPECIALIZING-TYPE-OF to return the appropriate type associated with the array class. The CAR of each entry of the alist should be the class or class-name of the concerned array object, while the CDR should be a symbol or a function. If the CDR is a symbol, then it forms the CAR of the returned type-specifier; if it is a function, then the function should take the array-object as the input and return a symbol to be used as the CAR of the type-specifier.

See dense-arrays/src/types.lisp for an instance of such a function.

Package: abstract-arrays.
Source: parametric-types.lisp.

Next: Compiler macros, Previous: Special variables, Up: Public Interface [Contents][Index]

5.1.2 Macros

Macro: define-array-class (name &body direct-slots) ¶

Defines NAME as a CLASS with DIRECT-SUPERCLASS ABSTRACT-ARRAY and metaclass as ABSTRACT-ARRAY-CLASS. Also defines the appropriate order using DIRECT-SLOTS.

Package: abstract-arrays.
Source: abstract-array.lisp.

Macro: define-array-specialization-type (type &optional base-type) ¶

Defines a (TYPE &OPTIONAL ELEMENT-TYPE RANK) type for each RANK and ELEMENT-TYPE using SATISFIES type.

Additionally, defines POLYMORPHIC-FUNCTIONS:PARAMETRIC-TYPE-RUN-TIME-LAMBDA-BODY and POLYMORPHIC-FUNCTIONS:PARAMETRIC-TYPE-COMPILE-TIME-LAMBDA-BODY corresponding to TYPE.

BASE-TYPE should be the name of the CLASS upon which the arrays will be based.

See DENSE-ARRAYS:ARRAY for an example.

Package: abstract-arrays.
Source: specializations.lisp.

Macro: define-array-specializations ((&rest element-types) (&rest ranks)) ¶

Defines PREDICATES corresponding to each ELEMENT-TYPE and RANK (not their pairs). The predicates of the two kinds will be independent of each other.

Package: abstract-arrays.
Source: specializations.lisp.

Next: Ordinary functions, Previous: Macros, Up: Public Interface [Contents][Index]

5.1.3 Compiler macros

Compiler Macro: aref (form &optional env) ¶

Package: abstract-arrays.
Alias for: pf-compiler-macro.

Compiler Macro: (setf aref) (form &optional env) ¶

Package: abstract-arrays.
Alias for: pf-compiler-macro.

Compiler Macro: array-dimensions (form &optional env) ¶

Package: abstract-arrays.
Alias for: pf-compiler-macro.

Compiler Macro: array-element-type (form &optional env) ¶

Package: abstract-arrays.
Alias for: pf-compiler-macro.

Compiler Macro: array-rank (form &optional env) ¶

Package: abstract-arrays.
Alias for: pf-compiler-macro.

Compiler Macro: array-storage (form &optional env) ¶

Package: abstract-arrays.
Alias for: pf-compiler-macro.

Compiler Macro: array-storage-ref (form &optional env) ¶

Package: abstract-arrays.
Alias for: pf-compiler-macro.

Compiler Macro: (setf array-storage-ref) (args) ¶

Package: abstract-arrays.
Source: remaining-protocol.lisp.

Compiler Macro: array-storage-set (form &optional env) ¶

Package: abstract-arrays.
Alias for: pf-compiler-macro.

Compiler Macro: array-total-size (form &optional env) ¶

Package: abstract-arrays.
Alias for: pf-compiler-macro.

Compiler Macro: col-major-aref (form &optional env) ¶

Package: abstract-arrays.
Alias for: pf-compiler-macro.

Compiler Macro: (setf col-major-aref) (form &optional env) ¶

Package: abstract-arrays.
Alias for: pf-compiler-macro.

Compiler Macro: column-major-aref (array-form index-form) ¶

Package: abstract-arrays.
Source: remaining-protocol.lisp.

Compiler Macro: (setf column-major-aref) (index-form) ¶

Package: abstract-arrays.
Source: remaining-protocol.lisp.

Compiler Macro: narray-dimensions (form &optional env) ¶

Package: abstract-arrays.
Alias for: pf-compiler-macro.

Compiler Macro: row-major-aref (form &optional env) ¶

Package: abstract-arrays.
Alias for: pf-compiler-macro.

Compiler Macro: (setf row-major-aref) (form &optional env) ¶

Package: abstract-arrays.
Alias for: pf-compiler-macro.

Next: Standalone methods, Previous: Compiler macros, Up: Public Interface [Contents][Index]

5.1.4 Ordinary functions

Function: abstract-array-dimensions (abstract-array) ¶

Access the DIMENSIONS list of the ABSTRACT-ARRAY. Destructively modifying this list would result in a change in the DIMENSIONS of the array; hence use this only for read-only access to the DIMENSIONS.

Package: abstract-arrays.
Source: abstract-array.lisp.

Function: array-dimension (array axis-number) ¶

Package: abstract-arrays.
Source: remaining-protocol.lisp.

Function: array-dimensions (array) ¶

Package: abstract-arrays.
Source: abstract-array.lisp.

Function: array-element-type (array) ¶

Package: abstract-arrays.
Source: abstract-array.lisp.

Function: array-rank (array) ¶

Package: abstract-arrays.
Source: abstract-array.lisp.

Function: array-storage-ref (array &rest subscripts) ¶

Package: abstract-arrays.
Source: remaining-protocol.lisp.

Function: (setf array-storage-ref) (array &rest subscripts) ¶

Package: abstract-arrays.
Source: remaining-protocol.lisp.

Function: array-storage-set (new-value array &rest subscripts) ¶

Package: abstract-arrays.
Source: remaining-protocol.lisp.

Function: array-total-size (array) ¶

Package: abstract-arrays.
Source: abstract-array.lisp.

Function: array-type-dimensions (array-type &optional env) ¶

Similar to SANDALPHON.COMPILER-MACRO:ARRAY-TYPE-DIMENSIONS; returns the actual DIMENSIONS corresponding to ARRAY-DIMENSIONS in ENV.
ARRAY-TYPE is expected to be a subtype of ABSTRACT-ARRAY.
See also: DEFINE-ARRAY-SPECIALIZATIONS and DEFINE-ARRAY-SPECIALIZATION-TYPE

Package: abstract-arrays.
Source: specializations.lisp.

Function: array-type-element-type (array-type &optional env) ¶

Similar to SANDALPHON.COMPILER-MACRO:ARRAY-TYPE-ELEMENT-TYPE; returns the actual ELEMENT-TYPE corresponding to ARRAY-RANK in ENV.
ARRAY-TYPE is expected to be a subtype of ABSTRACT-ARRAY.
See also: DEFINE-ARRAY-SPECIALIZATIONS and DEFINE-ARRAY-SPECIALIZATION-TYPE

Package: abstract-arrays.
Source: specializations.lisp.

Function: array-type-rank (array-type &optional env) ¶

Similar to SANDALPHON.COMPILER-MACRO:ARRAY-TYPE-RANK; returns the actual RANK corresponding to ARRAY-RANK in ENV.
ARRAY-TYPE is expected to be a subtype of ABSTRACT-ARRAY.
See also: DEFINE-ARRAY-SPECIALIZATIONS and DEFINE-ARRAY-SPECIALIZATION-TYPE

Package: abstract-arrays.
Source: specializations.lisp.

Function: arrayp (object) ¶

Package: abstract-arrays.
Source: remaining-protocol.lisp.

Function: column-major-aref (array index) ¶

Return the element of ARRAY corresponding to the column-major INDEX. This is SETFable, and a wrapper around COL-MAJOR-AREF.

Package: abstract-arrays.
Source: remaining-protocol.lisp.

Function: (setf column-major-aref) (array index) ¶

Package: abstract-arrays.
Source: remaining-protocol.lisp.

Function: narray-dimensions (array) ¶

Package: abstract-arrays.
Source: remaining-protocol.lisp.

Next: Conditions, Previous: Ordinary functions, Up: Public Interface [Contents][Index]

5.1.5 Standalone methods

Method: compute-slots ((class abstract-array-class)) ¶

Package: sb-mop.
Source: abstract-array-ordered-class.lisp.

Method: slot-unbound (class (array-class abstract-array-class) (slot-name (eql sb-pcl::%class-precedence-list))) ¶

Source: abstract-array-ordered-class.lisp.

Method: validate-superclass ((class abstract-array-class) (superclass standard-class)) ¶

Package: sb-mop.
Source: abstract-array-ordered-class.lisp.

Next: Classes, Previous: Standalone methods, Up: Public Interface [Contents][Index]

5.1.6 Conditions

Condition: invalid-array-index ¶

Package

abstract-arrays.

Source

conditions.lisp.

Direct superclasses

error.

Direct slots

Slot: index ¶

Initargs: :index

Slot: array ¶

Package: common-lisp.
Initargs: :array

Slot: suggestion ¶

Initform: (quote nil)
Initargs: :suggestion

Previous: Conditions, Up: Public Interface [Contents][Index]

5.1.7 Classes

Class: abstract-array ¶

Package

abstract-arrays.

Source

abstract-array.lisp.

Direct superclasses

t.

Direct slots

Slot: storage ¶

Initform: (error "storage must be supplied during abstract-array initialization")
Initargs: :storage

Slot: dimensions ¶

Type: list
Initform: (error "dimensions must be supplied during abstract-array initialization")
Initargs: :dimensions

Slot: element-type ¶

Initform: (error "element-type must be supplied during abstract-array initialization")
Initargs: :element-type

Slot: rank ¶

Type: (integer 0 129)
Initform: (error "rank must be supplied during abstract-array initialization")
Initargs: :rank

Slot: total-size ¶

Type: (integer 0 4611686018427387901)
Initform: (error "total-size must be supplied during abstract-array initialization")
Initargs: :total-size

Class: abstract-array-class ¶

Package

abstract-arrays.

Source

abstract-array-ordered-class.lisp.

Direct superclasses

standard-class.

Direct methods

compute-slots.
order.
slot-unbound.
validate-superclass.

Direct slots

Slot: order ¶

Initargs: :order
Readers: order.
Writers: This slot is read-only.

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

5.2 Internals

Constants
Special variables
Macros
Ordinary functions
Generic functions

Next: Special variables, Previous: Internals, Up: Internals [Contents][Index]

5.2.1 Constants

Constant: +abstract-array-slot-order+ ¶

Package: abstract-arrays.
Source: abstract-array.lisp.

Next: Macros, Previous: Constants, Up: Internals [Contents][Index]

5.2.2 Special variables

Special Variable: *element-type-p-fn-name-element-type-alist* ¶

Package: abstract-arrays.
Source: specializations.lisp.

Special Variable: *rank-p-fn-name-rank-alist* ¶

Package: abstract-arrays.
Source: specializations.lisp.

Next: Ordinary functions, Previous: Special variables, Up: Internals [Contents][Index]

5.2.3 Macros

Macro: define-array-element-type-specialization (element-type) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Macro: define-array-rank-specialization (rank) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Macro: define-methods-for-parametric-type-lambda-bodies (type) ¶

Package: abstract-arrays.
Source: parametric-types.lisp.

Macro: define-ordered-class (name super-classes &body slots) ¶

Package: abstract-arrays.
Source: abstract-array-ordered-class.lisp.

Macro: define-ordered-class-with-required-slots (name direct-superclasses direct-slots &rest slot-options) ¶

Like DEFINE-ORDERED-CLASS but slots can also have a ‘:required t‘ as an option. This is substituted with a error-ing :initform.

Package: abstract-arrays.
Source: abstract-array.lisp.

Next: Generic functions, Previous: Macros, Up: Internals [Contents][Index]

5.2.4 Ordinary functions

Function: abstract-array-element-type-(complex⎵double-float)-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-(complex⎵single-float)-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-(integer⎵-128⎵127)-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-(integer⎵-2147483648⎵2147483647)-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-(integer⎵-32768⎵32767)-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-(integer⎵-9223372036854775808⎵9223372036854775807)-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-(integer⎵0⎵18446744073709551615)-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-(integer⎵0⎵255)-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-(integer⎵0⎵4294967295)-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-(integer⎵0⎵65535)-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-bit-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-double-float-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-fixnum-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-nil-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-single-float-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-element-type-t-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-rank-0-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-rank-1-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-rank-2-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-rank-3-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-rank-4-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-rank-5-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-rank-6-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: abstract-array-rank-7-p (object) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: atom-like-p (atom-or-list) ¶

Package: abstract-arrays.
Source: parametric-types.lisp.

Function: collect-ordered-class-accessor-names (slot-options accessor-type) ¶

Package: abstract-arrays.
Source: abstract-array-ordered-class.lisp.

Function: element-type-p-fn-name (element-type) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Function: export-symbols () ¶

Package: abstract-arrays/defpackage.
Source: pre-package.lisp.

Function: generate-ordered-class-fast-accessors (class-name slots order) ¶

Package: abstract-arrays.
Source: abstract-array-ordered-class.lisp.

Function: generate-ordered-class-options (order options) ¶

Package: abstract-arrays.
Source: abstract-array-ordered-class.lisp.

Function: generate-ordered-class-slot-specifiers (slots order) ¶

Package: abstract-arrays.
Source: abstract-array-ordered-class.lisp.

Function: parametric-type-compile-time-lambda-body-for-arrays (type-car type-cdr parameter) ¶

Package: abstract-arrays.
Source: parametric-types.lisp.

Function: plist-keys (list) ¶

Package: abstract-arrays.
Source: abstract-array-ordered-class.lisp.

Function: plist-remove (list &rest keys) ¶

Package: abstract-arrays.
Source: abstract-array-ordered-class.lisp.

Function: plist-values (list) ¶

Package: abstract-arrays.
Source: abstract-array-ordered-class.lisp.

Function: rank-p-fn-name (rank) ¶

Package: abstract-arrays.
Source: specializations.lisp.

Previous: Ordinary functions, Up: Internals [Contents][Index]

5.2.5 Generic functions

Generic Reader: order (object) ¶

Package

abstract-arrays.

Methods

Reader Method: order ((abstract-array-class abstract-array-class)) ¶

automatically generated reader method

Source: abstract-array-ordered-class.lisp.
Target Slot: order.

Previous: Definitions, Up: The abstract-arrays Reference Manual [Contents][Index]

Appendix A Indexes

Concepts
Functions
Variables
Data types

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

A.1 Concepts

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

A.2 Functions

Jump to:	( A C D E F G M N O P R S V

	Index Entry	Section

(
	`(setf aref)`:	Public compiler macros
	`(setf array-storage-ref)`:	Public compiler macros
	`(setf array-storage-ref)`:	Public ordinary functions
	`(setf col-major-aref)`:	Public compiler macros
	`(setf column-major-aref)`:	Public compiler macros
	`(setf column-major-aref)`:	Public ordinary functions
	`(setf row-major-aref)`:	Public compiler macros

A
	`abstract-array-dimensions`:	Public ordinary functions
	`abstract-array-element-type-(complex⎵double-float)-p`:	Private ordinary functions
	`abstract-array-element-type-(complex⎵single-float)-p`:	Private ordinary functions
	`abstract-array-element-type-(integer⎵-128⎵127)-p`:	Private ordinary functions
	`abstract-array-element-type-(integer⎵-2147483648⎵2147483647)-p`:	Private ordinary functions
	`abstract-array-element-type-(integer⎵-32768⎵32767)-p`:	Private ordinary functions
	`abstract-array-element-type-(integer⎵-9223372036854775808⎵9223372036854775807)-p`:	Private ordinary functions
	`abstract-array-element-type-(integer⎵0⎵18446744073709551615)-p`:	Private ordinary functions
	`abstract-array-element-type-(integer⎵0⎵255)-p`:	Private ordinary functions
	`abstract-array-element-type-(integer⎵0⎵4294967295)-p`:	Private ordinary functions
	`abstract-array-element-type-(integer⎵0⎵65535)-p`:	Private ordinary functions
	`abstract-array-element-type-bit-p`:	Private ordinary functions
	`abstract-array-element-type-double-float-p`:	Private ordinary functions
	`abstract-array-element-type-fixnum-p`:	Private ordinary functions
	`abstract-array-element-type-nil-p`:	Private ordinary functions
	`abstract-array-element-type-single-float-p`:	Private ordinary functions
	`abstract-array-element-type-t-p`:	Private ordinary functions
	`abstract-array-rank-0-p`:	Private ordinary functions
	`abstract-array-rank-1-p`:	Private ordinary functions
	`abstract-array-rank-2-p`:	Private ordinary functions
	`abstract-array-rank-3-p`:	Private ordinary functions
	`abstract-array-rank-4-p`:	Private ordinary functions
	`abstract-array-rank-5-p`:	Private ordinary functions
	`abstract-array-rank-6-p`:	Private ordinary functions
	`abstract-array-rank-7-p`:	Private ordinary functions
	`aref`:	Public compiler macros
	`array-dimension`:	Public ordinary functions
	`array-dimensions`:	Public compiler macros
	`array-dimensions`:	Public ordinary functions
	`array-element-type`:	Public compiler macros
	`array-element-type`:	Public ordinary functions
	`array-rank`:	Public compiler macros
	`array-rank`:	Public ordinary functions
	`array-storage`:	Public compiler macros
	`array-storage-ref`:	Public compiler macros
	`array-storage-ref`:	Public ordinary functions
	`array-storage-set`:	Public compiler macros
	`array-storage-set`:	Public ordinary functions
	`array-total-size`:	Public compiler macros
	`array-total-size`:	Public ordinary functions
	`array-type-dimensions`:	Public ordinary functions
	`array-type-element-type`:	Public ordinary functions
	`array-type-rank`:	Public ordinary functions
	`arrayp`:	Public ordinary functions
	`atom-like-p`:	Private ordinary functions

C
	`col-major-aref`:	Public compiler macros
	`collect-ordered-class-accessor-names`:	Private ordinary functions
	`column-major-aref`:	Public compiler macros
	`column-major-aref`:	Public ordinary functions
	`Compiler Macro, (setf aref)`:	Public compiler macros
	`Compiler Macro, (setf array-storage-ref)`:	Public compiler macros
	`Compiler Macro, (setf col-major-aref)`:	Public compiler macros
	`Compiler Macro, (setf column-major-aref)`:	Public compiler macros
	`Compiler Macro, (setf row-major-aref)`:	Public compiler macros
	`Compiler Macro, aref`:	Public compiler macros
	`Compiler Macro, array-dimensions`:	Public compiler macros
	`Compiler Macro, array-element-type`:	Public compiler macros
	`Compiler Macro, array-rank`:	Public compiler macros
	`Compiler Macro, array-storage`:	Public compiler macros
	`Compiler Macro, array-storage-ref`:	Public compiler macros
	`Compiler Macro, array-storage-set`:	Public compiler macros
	`Compiler Macro, array-total-size`:	Public compiler macros
	`Compiler Macro, col-major-aref`:	Public compiler macros
	`Compiler Macro, column-major-aref`:	Public compiler macros
	`Compiler Macro, narray-dimensions`:	Public compiler macros
	`Compiler Macro, row-major-aref`:	Public compiler macros
	`compute-slots`:	Public standalone methods

D
	`define-array-class`:	Public macros
	`define-array-element-type-specialization`:	Private macros
	`define-array-rank-specialization`:	Private macros
	`define-array-specialization-type`:	Public macros
	`define-array-specializations`:	Public macros
	`define-methods-for-parametric-type-lambda-bodies`:	Private macros
	`define-ordered-class`:	Private macros
	`define-ordered-class-with-required-slots`:	Private macros

E
	`element-type-p-fn-name`:	Private ordinary functions
	`export-symbols`:	Private ordinary functions

F
	`Function, (setf array-storage-ref)`:	Public ordinary functions
	`Function, (setf column-major-aref)`:	Public ordinary functions
	`Function, abstract-array-dimensions`:	Public ordinary functions
	`Function, abstract-array-element-type-(complex⎵double-float)-p`:	Private ordinary functions
	`Function, abstract-array-element-type-(complex⎵single-float)-p`:	Private ordinary functions
	`Function, abstract-array-element-type-(integer⎵-128⎵127)-p`:	Private ordinary functions
	`Function, abstract-array-element-type-(integer⎵-2147483648⎵2147483647)-p`:	Private ordinary functions
	`Function, abstract-array-element-type-(integer⎵-32768⎵32767)-p`:	Private ordinary functions
	`Function, abstract-array-element-type-(integer⎵-9223372036854775808⎵9223372036854775807)-p`:	Private ordinary functions
	`Function, abstract-array-element-type-(integer⎵0⎵18446744073709551615)-p`:	Private ordinary functions
	`Function, abstract-array-element-type-(integer⎵0⎵255)-p`:	Private ordinary functions
	`Function, abstract-array-element-type-(integer⎵0⎵4294967295)-p`:	Private ordinary functions
	`Function, abstract-array-element-type-(integer⎵0⎵65535)-p`:	Private ordinary functions
	`Function, abstract-array-element-type-bit-p`:	Private ordinary functions
	`Function, abstract-array-element-type-double-float-p`:	Private ordinary functions
	`Function, abstract-array-element-type-fixnum-p`:	Private ordinary functions
	`Function, abstract-array-element-type-nil-p`:	Private ordinary functions
	`Function, abstract-array-element-type-single-float-p`:	Private ordinary functions
	`Function, abstract-array-element-type-t-p`:	Private ordinary functions
	`Function, abstract-array-rank-0-p`:	Private ordinary functions
	`Function, abstract-array-rank-1-p`:	Private ordinary functions
	`Function, abstract-array-rank-2-p`:	Private ordinary functions
	`Function, abstract-array-rank-3-p`:	Private ordinary functions
	`Function, abstract-array-rank-4-p`:	Private ordinary functions
	`Function, abstract-array-rank-5-p`:	Private ordinary functions
	`Function, abstract-array-rank-6-p`:	Private ordinary functions
	`Function, abstract-array-rank-7-p`:	Private ordinary functions
	`Function, array-dimension`:	Public ordinary functions
	`Function, array-dimensions`:	Public ordinary functions
	`Function, array-element-type`:	Public ordinary functions
	`Function, array-rank`:	Public ordinary functions
	`Function, array-storage-ref`:	Public ordinary functions
	`Function, array-storage-set`:	Public ordinary functions
	`Function, array-total-size`:	Public ordinary functions
	`Function, array-type-dimensions`:	Public ordinary functions
	`Function, array-type-element-type`:	Public ordinary functions
	`Function, array-type-rank`:	Public ordinary functions
	`Function, arrayp`:	Public ordinary functions
	`Function, atom-like-p`:	Private ordinary functions
	`Function, collect-ordered-class-accessor-names`:	Private ordinary functions
	`Function, column-major-aref`:	Public ordinary functions
	`Function, element-type-p-fn-name`:	Private ordinary functions
	`Function, export-symbols`:	Private ordinary functions
	`Function, generate-ordered-class-fast-accessors`:	Private ordinary functions
	`Function, generate-ordered-class-options`:	Private ordinary functions
	`Function, generate-ordered-class-slot-specifiers`:	Private ordinary functions
	`Function, narray-dimensions`:	Public ordinary functions
	`Function, parametric-type-compile-time-lambda-body-for-arrays`:	Private ordinary functions
	`Function, plist-keys`:	Private ordinary functions
	`Function, plist-remove`:	Private ordinary functions
	`Function, plist-values`:	Private ordinary functions
	`Function, rank-p-fn-name`:	Private ordinary functions

G
	`generate-ordered-class-fast-accessors`:	Private ordinary functions
	`generate-ordered-class-options`:	Private ordinary functions
	`generate-ordered-class-slot-specifiers`:	Private ordinary functions
	`Generic Function, order`:	Private generic functions

M
	`Macro, define-array-class`:	Public macros
	`Macro, define-array-element-type-specialization`:	Private macros
	`Macro, define-array-rank-specialization`:	Private macros
	`Macro, define-array-specialization-type`:	Public macros
	`Macro, define-array-specializations`:	Public macros
	`Macro, define-methods-for-parametric-type-lambda-bodies`:	Private macros
	`Macro, define-ordered-class`:	Private macros
	`Macro, define-ordered-class-with-required-slots`:	Private macros
	`Method, compute-slots`:	Public standalone methods
	`Method, order`:	Private generic functions
	`Method, slot-unbound`:	Public standalone methods
	`Method, validate-superclass`:	Public standalone methods

N
	`narray-dimensions`:	Public compiler macros
	`narray-dimensions`:	Public ordinary functions

O
	`order`:	Private generic functions
	`order`:	Private generic functions

P
	`parametric-type-compile-time-lambda-body-for-arrays`:	Private ordinary functions
	`plist-keys`:	Private ordinary functions
	`plist-remove`:	Private ordinary functions
	`plist-values`:	Private ordinary functions

R
	`rank-p-fn-name`:	Private ordinary functions
	`row-major-aref`:	Public compiler macros

S
	`slot-unbound`:	Public standalone methods

V
	`validate-superclass`:	Public standalone methods

Next: Data types, Previous: Functions, Up: Indexes [Contents][Index]

A.3 Variables

Jump to:	* + A C D E I O R S T

	Index Entry	Section

*
	`array-class-type-alist`:	Public special variables
	`element-type-p-fn-name-element-type-alist`:	Private special variables
	`rank-p-fn-name-rank-alist`:	Private special variables

+
	`+abstract-array-slot-order+`:	Private constants

A
	`array`:	Public conditions

C
	`Constant, +abstract-array-slot-order+`:	Private constants

D
	`dimensions`:	Public classes

E
	`element-type`:	Public classes

I
	`index`:	Public conditions

O
	`order`:	Public classes

R
	`rank`:	Public classes

S
	`Slot, array`:	Public conditions
	`Slot, dimensions`:	Public classes
	`Slot, element-type`:	Public classes
	`Slot, index`:	Public conditions
	`Slot, order`:	Public classes
	`Slot, rank`:	Public classes
	`Slot, storage`:	Public classes
	`Slot, suggestion`:	Public conditions
	`Slot, total-size`:	Public classes
	`Special Variable, array-class-type-alist`:	Public special variables
	`Special Variable, element-type-p-fn-name-element-type-alist`:	Private special variables
	`Special Variable, rank-p-fn-name-rank-alist`:	Private special variables
	`storage`:	Public classes
	`suggestion`:	Public conditions

T
	`total-size`:	Public classes

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

A.4 Data types

Jump to:	A C F I P R S

	Index Entry	Section

A
	`abstract-array`:	Public classes
	`abstract-array-class`:	Public classes
	`abstract-array-ordered-class.lisp`:	The abstract-arrays/abstract-array-ordered-class․lisp file
	`abstract-array.lisp`:	The abstract-arrays/abstract-array․lisp file
	`abstract-arrays`:	The abstract-arrays system
	`abstract-arrays`:	The abstract-arrays package
	`abstract-arrays.asd`:	The abstract-arrays/abstract-arrays․asd file
	`abstract-arrays/defpackage`:	The abstract-arrays/defpackage package

C
	`Class, abstract-array`:	Public classes
	`Class, abstract-array-class`:	Public classes
	`Condition, invalid-array-index`:	Public conditions
	`conditions.lisp`:	The abstract-arrays/conditions․lisp file

F
	`File, abstract-array-ordered-class.lisp`:	The abstract-arrays/abstract-array-ordered-class․lisp file
	`File, abstract-array.lisp`:	The abstract-arrays/abstract-array․lisp file
	`File, abstract-arrays.asd`:	The abstract-arrays/abstract-arrays․asd file
	`File, conditions.lisp`:	The abstract-arrays/conditions․lisp file
	`File, package.lisp`:	The abstract-arrays/package․lisp file
	`File, parametric-types.lisp`:	The abstract-arrays/parametric-types․lisp file
	`File, pre-package.lisp`:	The abstract-arrays/pre-package․lisp file
	`File, remaining-protocol.lisp`:	The abstract-arrays/remaining-protocol․lisp file
	`File, specializations.lisp`:	The abstract-arrays/specializations․lisp file

I
	`invalid-array-index`:	Public conditions

P
	`Package, abstract-arrays`:	The abstract-arrays package
	`Package, abstract-arrays/defpackage`:	The abstract-arrays/defpackage package
	`package.lisp`:	The abstract-arrays/package․lisp file
	`parametric-types.lisp`:	The abstract-arrays/parametric-types․lisp file
	`pre-package.lisp`:	The abstract-arrays/pre-package․lisp file

R
	`remaining-protocol.lisp`:	The abstract-arrays/remaining-protocol․lisp file

S
	`specializations.lisp`:	The abstract-arrays/specializations․lisp file
	`System, abstract-arrays`:	The abstract-arrays system

The abstract-arrays Reference Manual

Table of Contents

1 Introduction

2 Systems

2.1 abstract-arrays

3 Files

3.1 Lisp

3.1.1 abstract-arrays/abstract-arrays.asd

3.1.2 abstract-arrays/pre-package.lisp

3.1.3 abstract-arrays/package.lisp

3.1.4 abstract-arrays/abstract-array-ordered-class.lisp

3.1.5 abstract-arrays/abstract-array.lisp

3.1.6 abstract-arrays/remaining-protocol.lisp

3.1.7 abstract-arrays/parametric-types.lisp

3.1.8 abstract-arrays/specializations.lisp

3.1.9 abstract-arrays/conditions.lisp

4 Packages

4.1 abstract-arrays

4.2 abstract-arrays/defpackage

5 Definitions

5.1 Public Interface

5.1.1 Special variables

5.1.2 Macros

5.1.3 Compiler macros

5.1.4 Ordinary functions

5.1.5 Standalone methods

5.1.6 Conditions

5.1.7 Classes

5.2 Internals

5.2.1 Constants

5.2.2 Special variables

5.2.3 Macros

5.2.4 Ordinary functions

5.2.5 Generic functions

Appendix A Indexes

A.1 Concepts

A.2 Functions

A.3 Variables

A.4 Data types

2.1 `abstract-arrays`

3.1.1 `abstract-arrays/abstract-arrays.asd`

3.1.2 `abstract-arrays/pre-package.lisp`

3.1.3 `abstract-arrays/package.lisp`

3.1.4 `abstract-arrays/abstract-array-ordered-class.lisp`

3.1.5 `abstract-arrays/abstract-array.lisp`

3.1.6 `abstract-arrays/remaining-protocol.lisp`

3.1.7 `abstract-arrays/parametric-types.lisp`

3.1.8 `abstract-arrays/specializations.lisp`

3.1.9 `abstract-arrays/conditions.lisp`

4.1 `abstract-arrays`

4.2 `abstract-arrays/defpackage`