The cl-slice Reference Manual

Table of Contents

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

The cl-slice Reference Manual

This is the cl-slice Reference Manual, version 0.1, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 11:23:42 2018 GMT+0.


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

1 Introduction

#+CAPTION: Project Status: Abandoned – Initial development has started, but there has not yet been a stable, usable release; the project has been abandoned and the author(s) do not intend on continuing development.
[[http://www.repostatus.org/badges/latest/abandoned.svg]]

* Array slices for Common Lisp

This library provides the following:

1. A user interface for taking slices (elements selected by the Cartesian product of vectors of subscripts for each axis) of array-like objects.  The most important function is =slice=.  Unless you want to define a method for this (besides what is already implemented), this is pretty much all you need from this library.  See the next section for a tutorial.

2. An extensible DSL for selecting a subset of valid subscripts.  This is useful if, for example, you want to resolve column names in a data frame in your implementation of =slice=.

3. A set of utility functions for traversing slices in array-like objects.


* User interface

The most frequently used form is
#+BEGIN_SRC lisp
(slice object slice1 slice2 ...)
#+END_SRC
Each /slice/ selects a subset of subscripts along the corresponding axis.  The library supports the following slice specifications:

- a nonnegative integer selects the corresponding index, while a negative integer selects an index counting backwards from the last index:
  #+BEGIN_SRC lisp
  (slice #(0 1 2 3) 1)                  ; => 1  
  (slice #(0 1 2 3) -2)                 ; => 2    
  #+END_SRC
  These are called /singleton slices/.  Each singleton slice /drops/ the dimension: vectors become atoms, matrices become vectors, etc.

- =(cons start end)= selects integers $i: \text{start} \leq i < \text{end}$.  When =end= is =nil=, the last index is included (cf. =subseq=).  Each boundary is resolved according to the other rules if applicable, so you can use negative integers:
  #+BEGIN_SRC lisp
  (slice #(0 1 2 3) (cons 1 3))         ; => #(1 2)
  (slice #(0 1 2 3) (cons 1 -1))        ; => #(1 2)
  #+END_SRC
  However, =(cons start end)= is /invalid unless/ $\text{start} < \text{end}$, so you can't use
  #+BEGIN_SRC lisp
  (slice #(0 1 2 3) (cons 2 2))         ; ERROR
  #+END_SRC

- =t= selects all subscripts:
  #+BEGIN_SRC lisp
  (slice #2A((0 1 2)
             (3 4 5))
         t 1)                           ; => #(1 4)
  #+END_SRC

- vectors concatenate selections (except for bit vectors):
  #+BEGIN_SRC lisp
  (slice #(0 1 2 3 4 5 6 7 8 9)
          (vector (cons 1 3) 6 (cons -2 -1)))
                                        ; => #(1 2 3 6 8 9)
  (slice #(0 1 2) #(2 2 1 0 0))         ; => #(2 2 1 0 0)
  #+END_SRC

- bit vectors can be used as a mask:
  #+BEGIN_SRC lisp
  (slice #(0 1 2 3 4) #*00110)          ; => #(2 3)
  #+END_SRC

This is pretty much the core functionality --- the semantics can be extended, see the next section.  The following extensions are provided by the library.

- =including= is convenient if you want the slice to include the end of the range:
#+BEGIN_SRC lisp
(slice #(0 1 2 3) (including 1 2))     ; => #(1 2), cf (slice ... (cons 1 3))
#+END_SRC

- =nodrop= is useful if you don't want to drop dimensions:
  #+BEGIN_SRC lisp
  (slice #(0 1 2 3) (nodrop 2))          ; => #(2), cf (slice ... (cons 2 3))
  #+END_SRC

- =head= and =tail= do the obvious:
  #+BEGIN_SRC lisp
  (slice #(0 1 2 3) (head 2))            ; => #(0 1)
  (slice #(0 1 2 3) (tail 2))            ; => #(2 3)
  #+END_SRC

All of these are trivial to implement --- if there is something you are missing, you can easily extend =slice=.  You may also want to submit a patch!

=ref= is a version of slice that always returns a single element, so it can only be used with singleton slices.


* Slice semantics

Arguments of =slice= (apart from the first one) are meant to be resolved using =canonical-representation=, in the =cl-slice-dev= package.  If you want to extend =slice=, you should define methods for =canonical-representation=.  See the documentation for details, here I provide a simple example that extends the semantics with ordinal numbers.

#+BEGIN_SRC lisp
(defmacro define-ordinal-slice (number)
  (check-type number (integer 0))
  `(defmethod cl-slice-dev:canonical-representation
       ((axis integer) (slice (eql ',(intern (format nil "~:@(~:r~)" number)))))
     (assert (< ,number axis))
     (cl-slice-dev:canonical-singleton ,number)))

(define-ordinal-slice 1)
(define-ordinal-slice 2)
(define-ordinal-slice 3)

(slice #(0 1 2 3 4 5) (cons 'first 'third)) ; => #(1 2)
#+END_SRC

Note the following:
1. The value returned by =canonical-representation= needs to be constructed using =canonical-singleton=, =canonical-range=, or =canonical-sequence=.  You should not use the internal representation directly as it is subject to change.
2. You can assume that =axis= is an integer: this is the default.  An object may define a more complex mapping (such as, for example, named rows & columns), but unless a method specialized to that is found, =canonical-representation= will just query its dimension (with =axis-dimension=) and try to find a method that works on integers.
3. You need to make sure that the subscript is valid, hence the assertion.


* Traversing slices

** TODO write this

* Reporting bugs

Please report bugs using the [[https://github.com/tpapp/cl-slice/issues][issue tracker]].


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

2 Systems

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


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

2.1 cl-slice

Author

Tamas K Papp <tkpapp@gmail.com>

License

MIT

Description

DSL for array slices in Common Lisp.

Version

0.1

Dependencies
Source

cl-slice.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 cl-slice.asd

Location

cl-slice.asd

Systems

cl-slice (system)


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

3.1.2 cl-slice/cl-slice-dev.lisp

Parent

cl-slice (system)

Location

cl-slice-dev.lisp

Packages

cl-slice-dev

Exported Definitions
Internal Definitions

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

3.1.3 cl-slice/cl-slice.lisp

Dependency

cl-slice-dev.lisp (file)

Parent

cl-slice (system)

Location

cl-slice.lisp

Packages

cl-slice

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 cl-slice-dev

Source

cl-slice-dev.lisp (file)

Use List
Used By List

cl-slice

Exported Definitions
Internal Definitions

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

4.2 cl-slice

Source

cl-slice.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Macros

Macro: aslice OBJECT &rest SUBSCRIPTS

Anaphoric macro version of SLICE that binds the first argument to IT.

Package

cl-slice

Source

cl-slice.lisp (file)

Macro: traverse-representations (SUBSCRIPTS REPRESENTATIONS &key INDEX SETUP) &body BODY

A macro for traversing representations. Loops over all possible subscripts in REPRESENTAITONS, making them available in SUBSCRIPS during the execution of BODY. The iterator is constructed using the function SETUP (see for example ROW-MAJOR-SETUP). When INDEX is given, a variable with that name is provided, containing an index that counts iterations.

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)


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

5.1.2 Functions

Function: all-singleton-representations? REPRESENTATIONS

Test if all canonical representations are singletons.

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: canonical-range START END

Canonical representation of a contiguous set of array indices from START (inclusive) to END (exclusive).

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: canonical-representations AXES SLICES

Return the canonical representations of SLICES given the corresponding AXES, checking for matching length.

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: canonical-sequence SEQUENCE

Canonical representation of array indexes from sequence. May share structure. Vectors of the upgraded type of (SIMPLE-ARRAY ARRAY-INDEX (*)) are preferred for efficiency, otherwise they are coerced.

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: canonical-singleton INDEX

Canonical representation of a singleton index (a nonnegative integer, which is a valid array index).

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: head COUNT

First COUNT indexes.

Package

cl-slice

Source

cl-slice.lisp (file)

Function: including START END

Range, including both ends.

Package

cl-slice

Source

cl-slice.lisp (file)

Function: nodrop INDEX

Slice a single index, but don’t drop a dimension.

Package

cl-slice

Source

cl-slice.lisp (file)

Function: representation-dimensions REPRESENTATIONS

Return a list for the dimensions of canonical representations, dropping singletons.

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: row-major-setup REPRESENTATIONS TERMINATOR

Return SUBSCRIPTS (a list) and ITERATOR (a closure, no arguments) that increments the contents of SUBSCRIPTS. TERMINATOR is called when all subscripts have been visited.

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: singleton-representation? REPRESENTATION

Test if a canonical REPRESENTATION is a singleton.

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: slice-reserved-symbol? SYMBOL

Test if SYMBOL has special semantics for SLICE.

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: tail COUNT

Last COUNT indexes.

Package

cl-slice

Source

cl-slice.lisp (file)


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

5.1.3 Generic functions

Generic Function: axis-dimension AXIS

Return the dimension of axis. Needs to be defined for non-integer axes.

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Generic Function: canonical-representation AXIS SLICE

Canonical representation of SLICE, given information in AXIS. The default methods just use dimensions as AXIS.

Each slice needs to be resolved into a canonical representation, which is either a singleton, a range, or a sequence of subscripts. They should only be constructed with the corresponding CANONICAL-SINGLETION, CANONICAL-RANGE and CANONICAL-SEQUENCE functions.

CANONICAL-REPRESENTATION needs to ensure that the represented subscripts are valid for the axis.

Unless a specialized method is found, the dimension of the axis is queried with AXIS-DIMENSION and resolution is attempted using the latter. It recommended that methods that resolve symbols test them with SLICE-RESERVED-SYMBOL? and use CALL-NEXT-METHOD.

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Methods
Method: canonical-representation AXIS (SLICE nodrop)
Source

cl-slice.lisp (file)

Method: canonical-representation AXIS (SLICE including)
Source

cl-slice.lisp (file)

Method: canonical-representation AXIS SLICE
Method: canonical-representation AXIS (CANONICAL-RANGE canonical-range)
Method: canonical-representation AXIS (CANONICAL-SEQUENCE canonical-sequence)
Method: canonical-representation (AXIS integer) (SLICE null)
Method: canonical-representation (AXIS integer) (SLICE integer)
Method: canonical-representation AXIS (SLICE cons)
Method: canonical-representation AXIS (SLICE vector)
Method: canonical-representation (AXIS integer) (SLICE (eql t))
Method: canonical-representation AXIS (SLICE bit-vector)
Generic Function: mask PREDICATE SEQUENCE

Map sequence into a simple-bit-vector, using 1 when PREDICATE yields true, 0 otherwise.

Package

cl-slice

Source

cl-slice.lisp (file)

Methods
Method: mask PREDICATE (SEQUENCE sequence)
Generic Function: ref OBJECT &rest SUBSCRIPTS

Return the element of OBJECT specified by SUBSCRIPTS.

Package

cl-slice

Source

cl-slice.lisp (file)

Writer

(setf ref) (generic function)

Methods
Method: ref (ARRAY array) &rest SUBSCRIPTS
Generic Function: (setf ref) VALUE OBJECT &rest SUBSCRIPTS
Package

cl-slice

Source

cl-slice.lisp (file)

Reader

ref (generic function)

Methods
Method: (setf ref) VALUE (ARRAY array) &rest SUBSCRIPTS
Generic Function: slice OBJECT &rest SLICES

Return the slice of OBJECT specified by SLICES.

Package

cl-slice

Source

cl-slice.lisp (file)

Writer

(setf slice) (generic function)

Methods
Method: slice (LIST list) &rest SLICES
Method: slice (ARRAY array) &rest SLICES
Generic Function: (setf slice) VALUE OBJECT &rest SLICES
Package

cl-slice

Source

cl-slice.lisp (file)

Reader

slice (generic function)

Methods
Method: (setf slice) VALUE (ARRAY array) &rest SLICES
Generic Function: which PREDICATE SEQUENCE

Return an index of the positions in SEQUENCE which satisfy PREDICATE.

Package

cl-slice

Source

cl-slice.lisp (file)

Methods
Method: which PREDICATE (SEQUENCE sequence)

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

5.1.4 Structures

Structure: canonical-range ()

Canonical representation of a contiguous set of array indices from START (inclusive) to END (exclusive).

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

canonical-representation (method)

Direct slots
Slot: start
Type

alexandria.0.dev:array-index

Readers

canonical-range-start (function)

Writers

(setf canonical-range-start) (function)

Slot: end
Type

alexandria.0.dev:array-index

Readers

canonical-range-end (function)

Writers

(setf canonical-range-end) (function)

Structure: canonical-sequence ()

Canonical representation of a sequence of array indexes.

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

canonical-representation (method)

Direct slots
Slot: vector
Type

(simple-array alexandria.0.dev:array-index (*))

Readers

canonical-sequence-vector (function)

Writers

(setf canonical-sequence-vector) (function)

Structure: including ()

Range, including both ends.

Package

cl-slice

Source

cl-slice.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

canonical-representation (method)

Direct slots
Slot: start
Readers

including-start (function)

Writers

(setf including-start) (function)

Slot: end
Readers

including-end (function)

Writers

(setf including-end) (function)

Structure: nodrop ()

Select a single index, but don’t drop a dimension.

Package

cl-slice

Source

cl-slice.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

canonical-representation (method)

Direct slots
Slot: index
Readers

nodrop-index (function)

Writers

(setf nodrop-index) (function)


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

5.2 Internal definitions


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

5.2.1 Functions

Function: canonical-range-end INSTANCE
Function: (setf canonical-range-end) VALUE INSTANCE
Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: canonical-range-p OBJECT
Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: canonical-range-start INSTANCE
Function: (setf canonical-range-start) VALUE INSTANCE
Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: canonical-sequence-p OBJECT
Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: canonical-sequence-vector INSTANCE
Function: (setf canonical-sequence-vector) VALUE INSTANCE
Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: copy-canonical-range INSTANCE
Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: copy-canonical-sequence INSTANCE
Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: copy-including INSTANCE
Package

cl-slice

Source

cl-slice.lisp (file)

Function: copy-nodrop INSTANCE
Package

cl-slice

Source

cl-slice.lisp (file)

Function: including-end INSTANCE
Function: (setf including-end) VALUE INSTANCE
Package

cl-slice

Source

cl-slice.lisp (file)

Function: including-p OBJECT
Package

cl-slice

Source

cl-slice.lisp (file)

Function: including-start INSTANCE
Function: (setf including-start) VALUE INSTANCE
Package

cl-slice

Source

cl-slice.lisp (file)

Function: make-canonical-range &key (START START) (END END)
Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: make-canonical-sequence &key (VECTOR VECTOR)
Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: make-including &key (START START) (END END)
Package

cl-slice

Source

cl-slice.lisp (file)

Function: make-nodrop &key (INDEX INDEX)
Package

cl-slice

Source

cl-slice.lisp (file)

Function: nodrop-index INSTANCE
Function: (setf nodrop-index) VALUE INSTANCE
Package

cl-slice

Source

cl-slice.lisp (file)

Function: nodrop-p OBJECT
Package

cl-slice

Source

cl-slice.lisp (file)

Function: representation-dimension REPRESENTATION

Return the dimension of a canonical-representation, or NIL for singleton slices (they are dropped).

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: representation-initial-value REPRESENTATION

Initial value for iteration.

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)

Function: representation-iterator REPRESENTATION CARRY CONS

Return a closure that sets the car of CONS to the next value each time it is called, resetting and calling CARRY when it reaches the end of its range.

Package

cl-slice-dev

Source

cl-slice-dev.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   L  
Index Entry  Section

C
cl-slice.asd: The cl-slice<dot>asd file
cl-slice/cl-slice-dev.lisp: The cl-slice/cl-slice-dev<dot>lisp file
cl-slice/cl-slice.lisp: The cl-slice/cl-slice<dot>lisp file

F
File, Lisp, cl-slice.asd: The cl-slice<dot>asd file
File, Lisp, cl-slice/cl-slice-dev.lisp: The cl-slice/cl-slice-dev<dot>lisp file
File, Lisp, cl-slice/cl-slice.lisp: The cl-slice/cl-slice<dot>lisp file

L
Lisp File, cl-slice.asd: The cl-slice<dot>asd file
Lisp File, cl-slice/cl-slice-dev.lisp: The cl-slice/cl-slice-dev<dot>lisp file
Lisp File, cl-slice/cl-slice.lisp: The cl-slice/cl-slice<dot>lisp file

Jump to:   C   F   L  

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

A.2 Functions

Jump to:   (  
A   C   F   G   H   I   M   N   R   S   T   W  
Index Entry  Section

(
(setf canonical-range-end): Internal functions
(setf canonical-range-start): Internal functions
(setf canonical-sequence-vector): Internal functions
(setf including-end): Internal functions
(setf including-start): Internal functions
(setf nodrop-index): Internal functions
(setf ref): Exported generic functions
(setf ref): Exported generic functions
(setf slice): Exported generic functions
(setf slice): Exported generic functions

A
all-singleton-representations?: Exported functions
aslice: Exported macros
axis-dimension: Exported generic functions

C
canonical-range: Exported functions
canonical-range-end: Internal functions
canonical-range-p: Internal functions
canonical-range-start: Internal functions
canonical-representation: Exported generic functions
canonical-representation: Exported generic functions
canonical-representation: Exported generic functions
canonical-representation: Exported generic functions
canonical-representation: Exported generic functions
canonical-representation: Exported generic functions
canonical-representation: Exported generic functions
canonical-representation: Exported generic functions
canonical-representation: Exported generic functions
canonical-representation: Exported generic functions
canonical-representation: Exported generic functions
canonical-representation: Exported generic functions
canonical-representations: Exported functions
canonical-sequence: Exported functions
canonical-sequence-p: Internal functions
canonical-sequence-vector: Internal functions
canonical-singleton: Exported functions
copy-canonical-range: Internal functions
copy-canonical-sequence: Internal functions
copy-including: Internal functions
copy-nodrop: Internal functions

F
Function, (setf canonical-range-end): Internal functions
Function, (setf canonical-range-start): Internal functions
Function, (setf canonical-sequence-vector): Internal functions
Function, (setf including-end): Internal functions
Function, (setf including-start): Internal functions
Function, (setf nodrop-index): Internal functions
Function, all-singleton-representations?: Exported functions
Function, canonical-range: Exported functions
Function, canonical-range-end: Internal functions
Function, canonical-range-p: Internal functions
Function, canonical-range-start: Internal functions
Function, canonical-representations: Exported functions
Function, canonical-sequence: Exported functions
Function, canonical-sequence-p: Internal functions
Function, canonical-sequence-vector: Internal functions
Function, canonical-singleton: Exported functions
Function, copy-canonical-range: Internal functions
Function, copy-canonical-sequence: Internal functions
Function, copy-including: Internal functions
Function, copy-nodrop: Internal functions
Function, head: Exported functions
Function, including: Exported functions
Function, including-end: Internal functions
Function, including-p: Internal functions
Function, including-start: Internal functions
Function, make-canonical-range: Internal functions
Function, make-canonical-sequence: Internal functions
Function, make-including: Internal functions
Function, make-nodrop: Internal functions
Function, nodrop: Exported functions
Function, nodrop-index: Internal functions
Function, nodrop-p: Internal functions
Function, representation-dimension: Internal functions
Function, representation-dimensions: Exported functions
Function, representation-initial-value: Internal functions
Function, representation-iterator: Internal functions
Function, row-major-setup: Exported functions
Function, singleton-representation?: Exported functions
Function, slice-reserved-symbol?: Exported functions
Function, tail: Exported functions

G
Generic Function, (setf ref): Exported generic functions
Generic Function, (setf slice): Exported generic functions
Generic Function, axis-dimension: Exported generic functions
Generic Function, canonical-representation: Exported generic functions
Generic Function, mask: Exported generic functions
Generic Function, ref: Exported generic functions
Generic Function, slice: Exported generic functions
Generic Function, which: Exported generic functions

H
head: Exported functions

I
including: Exported functions
including-end: Internal functions
including-p: Internal functions
including-start: Internal functions

M
Macro, aslice: Exported macros
Macro, traverse-representations: Exported macros
make-canonical-range: Internal functions
make-canonical-sequence: Internal functions
make-including: Internal functions
make-nodrop: Internal functions
mask: Exported generic functions
mask: Exported generic functions
Method, (setf ref): Exported generic functions
Method, (setf slice): Exported generic functions
Method, canonical-representation: Exported generic functions
Method, canonical-representation: Exported generic functions
Method, canonical-representation: Exported generic functions
Method, canonical-representation: Exported generic functions
Method, canonical-representation: Exported generic functions
Method, canonical-representation: Exported generic functions
Method, canonical-representation: Exported generic functions
Method, canonical-representation: Exported generic functions
Method, canonical-representation: Exported generic functions
Method, canonical-representation: Exported generic functions
Method, canonical-representation: Exported generic functions
Method, mask: Exported generic functions
Method, ref: Exported generic functions
Method, slice: Exported generic functions
Method, slice: Exported generic functions
Method, which: Exported generic functions

N
nodrop: Exported functions
nodrop-index: Internal functions
nodrop-p: Internal functions

R
ref: Exported generic functions
ref: Exported generic functions
representation-dimension: Internal functions
representation-dimensions: Exported functions
representation-initial-value: Internal functions
representation-iterator: Internal functions
row-major-setup: Exported functions

S
singleton-representation?: Exported functions
slice: Exported generic functions
slice: Exported generic functions
slice: Exported generic functions
slice-reserved-symbol?: Exported functions

T
tail: Exported functions
traverse-representations: Exported macros

W
which: Exported generic functions
which: Exported generic functions

Jump to:   (  
A   C   F   G   H   I   M   N   R   S   T   W  

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

A.3 Variables

Jump to:   E   I   S   V  
Index Entry  Section

E
end: Exported structures
end: Exported structures

I
index: Exported structures

S
Slot, end: Exported structures
Slot, end: Exported structures
Slot, index: Exported structures
Slot, start: Exported structures
Slot, start: Exported structures
Slot, vector: Exported structures
start: Exported structures
start: Exported structures

V
vector: Exported structures

Jump to:   E   I   S   V  

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

A.4 Data types

Jump to:   C   I   N   P   S  
Index Entry  Section

C
canonical-range: Exported structures
canonical-sequence: Exported structures
cl-slice: The cl-slice system
cl-slice: The cl-slice package
cl-slice-dev: The cl-slice-dev package

I
including: Exported structures

N
nodrop: Exported structures

P
Package, cl-slice: The cl-slice package
Package, cl-slice-dev: The cl-slice-dev package

S
Structure, canonical-range: Exported structures
Structure, canonical-sequence: Exported structures
Structure, including: Exported structures
Structure, nodrop: Exported structures
System, cl-slice: The cl-slice system

Jump to:   C   I   N   P   S