The com.clearly-useful.generic-collection-interface Reference Manual

This is the com.clearly-useful.generic-collection-interface Reference Manual, version 0.2.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sat Dec 03 21:06:45 2022 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 com.clearly-useful.generic-collection-interface

generic collection interfaces for common lisp

Author

Jason Aeschliman <>

License

revised BSD

Version

0.2.1

Dependencies
  • com.clearly-useful.protocols (system).
  • bordeaux-threads (system).
  • lparallel (system).
Source

com.clearly-useful.generic-collection-interface.asd.

Child Components

3 Files

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


3.1 Lisp


3.1.1 com.clearly-useful.generic-collection-interface/com.clearly-useful.generic-collection-interface.asd

Source

com.clearly-useful.generic-collection-interface.asd.

Parent Component

com.clearly-useful.generic-collection-interface (system).

ASDF Systems

com.clearly-useful.generic-collection-interface.


3.1.4 com.clearly-useful.generic-collection-interface/protocols.lisp

Dependency

features.lisp (file).

Source

com.clearly-useful.generic-collection-interface.asd.

Parent Component

com.clearly-useful.generic-collection-interface (system).

Public Interface
Internals

associative-p (function).


3.1.5 com.clearly-useful.generic-collection-interface/internal-utils.lisp

Dependency

protocols.lisp (file).

Source

com.clearly-useful.generic-collection-interface.asd.

Parent Component

com.clearly-useful.generic-collection-interface (system).

Internals

3.1.6 com.clearly-useful.generic-collection-interface/macros.lisp

Dependency

internal-utils.lisp (file).

Source

com.clearly-useful.generic-collection-interface.asd.

Parent Component

com.clearly-useful.generic-collection-interface (system).

Public Interface

3.1.7 com.clearly-useful.generic-collection-interface/methods.lisp

Dependency

macros.lisp (file).

Source

com.clearly-useful.generic-collection-interface.asd.

Parent Component

com.clearly-useful.generic-collection-interface (system).

Public Interface

3.1.8 com.clearly-useful.generic-collection-interface/conversions.lisp

Dependency

methods.lisp (file).

Source

com.clearly-useful.generic-collection-interface.asd.

Parent Component

com.clearly-useful.generic-collection-interface (system).

Public Interface
Internals

3.1.9 com.clearly-useful.generic-collection-interface/reduceable-base.lisp

Dependency

conversions.lisp (file).

Source

com.clearly-useful.generic-collection-interface.asd.

Parent Component

com.clearly-useful.generic-collection-interface (system).

Public Interface
Internals

3.1.10 com.clearly-useful.generic-collection-interface/foldable-base.lisp

Dependency

reduceable-base.lisp (file).

Source

com.clearly-useful.generic-collection-interface.asd.

Parent Component

com.clearly-useful.generic-collection-interface (system).

Public Interface
Internals

3.1.11 com.clearly-useful.generic-collection-interface/base-methods.lisp

Dependency

foldable-base.lisp (file).

Source

com.clearly-useful.generic-collection-interface.asd.

Parent Component

com.clearly-useful.generic-collection-interface (system).

Public Interface

3.1.12 com.clearly-useful.generic-collection-interface/default-methods.lisp

Dependency

base-methods.lisp (file).

Source

com.clearly-useful.generic-collection-interface.asd.

Parent Component

com.clearly-useful.generic-collection-interface (system).

Public Interface

3.1.13 com.clearly-useful.generic-collection-interface/conj.lisp

Dependency

default-methods.lisp (file).

Source

com.clearly-useful.generic-collection-interface.asd.

Parent Component

com.clearly-useful.generic-collection-interface (system).

Public Interface
  • conj (generic function).
  • into (function).
Internals

3.1.14 com.clearly-useful.generic-collection-interface/parallel.lisp

Dependency

conj.lisp (file).

Source

com.clearly-useful.generic-collection-interface.asd.

Parent Component

com.clearly-useful.generic-collection-interface (system).

Internals

3.1.15 com.clearly-useful.generic-collection-interface/builtins.lisp

Dependency

parallel.lisp (file).

Source

com.clearly-useful.generic-collection-interface.asd.

Parent Component

com.clearly-useful.generic-collection-interface (system).

Public Interface

4 Packages

Packages are listed by definition order.


4.1 com.clearly-useful.foldable-protocol

Interface to the foldable protocol

Source

com.clearly-useful.generic-collection-interface.lisp.

Use List

4.2 com.clearly-useful.reduceable-protocol

Interface to the reduceable protocol

Source

com.clearly-useful.generic-collection-interface.lisp.

Use List

4.3 com.clearly-useful.countable-protocol

Interface to the countable protocol

Source

com.clearly-useful.generic-collection-interface.lisp.

Use List

4.4 com.clearly-useful.sequence-protocol

Interface to the sequence protocol

Source

com.clearly-useful.generic-collection-interface.lisp.

Use List

4.5 com.clearly-useful.generic-collection-interface

Source

package.lisp.

Use List
  • com.clearly-useful.protocols.
  • common-lisp.
  • lparallel.
Used By List
Public Interface
Internals

4.6 com.clearly-useful.indexable-protocol

Interface to the indexable protocol

Source

com.clearly-useful.generic-collection-interface.lisp.

Use List

4.7 com.clearly-useful.associative-protocol

Interface to the associative protocol

Source

com.clearly-useful.generic-collection-interface.lisp.

Use List

4.8 com.clearly-useful.collection-protocol

Interface to the collection protocol

Source

com.clearly-useful.generic-collection-interface.lisp.

Use List

5 Definitions

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


5.1 Public Interface


5.1.1 Macros

Macro: doindexable ((var form &optional return-clause) &body body)

bind var to each item in (element-at indexed n) and execute body.
where n is 0..(count-elements indexed)
and indexed is (indexable form)
similar to dolist.

Package

com.clearly-useful.generic-collection-interface.

Source

macros.lisp.

Macro: doseq ((var form &optional return-clause) &body body)

bind var to each item in (seq form) and execute body. similar to dolist.

Package

com.clearly-useful.generic-collection-interface.

Source

macros.lisp.


5.1.2 Ordinary functions

Function: collection-p (object)

test if object implements COLLECTION

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Function: countable-p (object)

test if object implements COUNTABLE

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Function: filtering (pred)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Function: fold (reducefn collection &key divide-by combine-with)
Package

com.clearly-useful.generic-collection-interface.

Source

foldable-base.lisp.

Function: fold-left (fn collection &key initial-value)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Function: foldable-p (object)

test if object implements FOLDABLE

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Function: folder (collection transformer)
Package

com.clearly-useful.generic-collection-interface.

Source

foldable-base.lisp.

Function: getkey (object key &optional default)

calls associative on object. if the result contains key, returns value-for-key, else default

Package

com.clearly-useful.generic-collection-interface.

Source

methods.lisp.

Function: indexable-p (object)

test if object implements INDEXABLE

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Function: into (coll reduceable)
Package

com.clearly-useful.generic-collection-interface.

Source

conj.lisp.

Function: mapcatting (f)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Function: mapping (fn)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Function: monoid (fn epsilon)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Function: reduceable-p (object)

test if object implements REDUCEABLE

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Function: reduced (v)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Function: reducer (collection transformer)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Function: seq-p (object)

test if object implements SEQ

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Function: seq-to-list (seq)

a fresh list will all elements of seq

Package

com.clearly-useful.generic-collection-interface.

Source

methods.lisp.

Function: seqable-p (object)

test if object implements SEQABLE

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.


5.1.3 Generic functions

Generic Function: all-keys (o)

a seq of all keys in o

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: all-keys ((it hash-table))
Source

builtins.lisp.

Method: all-keys ((it array))
Source

builtins.lisp.

Method: all-keys ((it vector))
Source

builtins.lisp.

Method: all-keys ((o cons))
Source

builtins.lisp.

Method: all-keys ((o null))
Source

builtins.lisp.

Method: all-keys (thing)
Source

default-methods.lisp.

Method: all-keys ((o %countable-associative))
Source

conversions.lisp.

Generic Function: all-keys-and-values (o)

return a seq of proper lists in the form (key value)

Package

com.clearly-useful.generic-collection-interface.

Source

methods.lisp.

Methods
Method: all-keys-and-values ((a hash-table))
Source

builtins.lisp.

Method: all-keys-and-values (o)
Generic Function: all-values (o)

a seq of all values in o

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: all-values ((it hash-table))
Source

builtins.lisp.

Method: all-values ((it array))
Source

builtins.lisp.

Method: all-values ((it vector))
Source

builtins.lisp.

Method: all-values ((o cons))
Source

builtins.lisp.

Method: all-values ((o null))
Source

builtins.lisp.

Method: all-values (thing)
Source

default-methods.lisp.

Method: all-values ((o %countable-associative))
Source

conversions.lisp.

Generic Function: associative (object)

convert an object to ASSOCIATIVE protocol, or error.

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: associative ((object hash-table))
Source

builtins.lisp.

Method: associative ((object array))
Source

builtins.lisp.

Method: associative ((object vector))
Source

builtins.lisp.

Method: associative ((object cons))
Source

builtins.lisp.

Method: associative ((object null))
Source

builtins.lisp.

Method: associative (o)
Source

base-methods.lisp.

Method: associative ((object %countable-associative))
Source

conversions.lisp.

Generic Function: coll-fold (self n combinef reducef)
Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: coll-fold ((self vector) n combinef reducef)
Source

builtins.lisp.

Method: coll-fold (self n cm rd)
Source

base-methods.lisp.

Method: coll-fold ((self %folder) n combine reduce)
Source

foldable-base.lisp.

Generic Function: coll-reduce (self fn seed)
Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: coll-reduce ((self hash-table) fn seed)
Source

builtins.lisp.

Method: coll-reduce ((self array) fn seed)
Source

builtins.lisp.

Method: coll-reduce ((self vector) fn seed)
Source

builtins.lisp.

Method: coll-reduce ((self cons) fn seed)
Source

builtins.lisp.

Method: coll-reduce ((self null) fn seed)
Source

builtins.lisp.

Method: coll-reduce (self fn seed)
Source

base-methods.lisp.

Method: coll-reduce ((self %reducer) fn seed)
Source

reduceable-base.lisp.

Generic Function: conj (a val)
Package

com.clearly-useful.generic-collection-interface.

Source

conj.lisp.

Methods
Method: conj ((a null) v)
Method: conj ((a cons) v)
Method: conj ((a vector) v)
Method: conj ((a hash-table) v)
Generic Function: contains-key-p (o k)

whether o contains k

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: contains-key-p ((o hash-table) k)
Source

builtins.lisp.

Method: contains-key-p ((it array) key)
Source

builtins.lisp.

Method: contains-key-p ((it vector) key)
Source

builtins.lisp.

Method: contains-key-p ((o cons) key)
Source

builtins.lisp.

Method: contains-key-p ((o null) k)
Source

builtins.lisp.

Method: contains-key-p (thing k)
Source

default-methods.lisp.

Method: contains-key-p ((o %countable-associative) key)
Source

conversions.lisp.

Generic Function: count-elements (o)

the number of elements in o

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: count-elements ((it hash-table))
Source

builtins.lisp.

Method: count-elements ((it array))
Source

builtins.lisp.

Method: count-elements ((it vector))
Source

builtins.lisp.

Method: count-elements ((o cons))
Source

builtins.lisp.

Method: count-elements ((o null))
Source

builtins.lisp.

Method: count-elements (thing)
Source

default-methods.lisp.

Method: count-elements ((o %seq-countable))
Source

conversions.lisp.

Method: count-elements ((range %range))
Source

conversions.lisp.

Generic Function: countable (object)

convert an object to COUNTABLE protocol, or error.

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: countable ((object hash-table))
Source

builtins.lisp.

Method: countable ((object array))
Source

builtins.lisp.

Method: countable ((object vector))
Source

builtins.lisp.

Method: countable ((object cons))
Source

builtins.lisp.

Method: countable ((object null))
Source

builtins.lisp.

Method: countable (o)
Source

base-methods.lisp.

Method: countable ((object %seq-countable))
Source

conversions.lisp.

Method: countable ((object %range))
Source

conversions.lisp.

Generic Function: counted-p (o)

whether a collection is counted in constant time

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: counted-p ((it hash-table))
Source

builtins.lisp.

Method: counted-p ((it array))
Source

builtins.lisp.

Method: counted-p ((it vector))
Source

builtins.lisp.

Method: counted-p ((o cons))
Source

builtins.lisp.

Method: counted-p ((o null))
Source

builtins.lisp.

Method: counted-p (thing)
Source

default-methods.lisp.

Method: counted-p ((o %seq-countable))
Source

conversions.lisp.

Method: counted-p ((range %range))
Source

conversions.lisp.

Generic Function: element-at (o index)

the element of o at index, or raise an error

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: element-at ((it array) n)
Source

builtins.lisp.

Method: element-at ((it vector) n)
Source

builtins.lisp.

Method: element-at ((o null) index)
Source

builtins.lisp.

Method: element-at (thing n)
Source

default-methods.lisp.

Method: element-at ((o %seq-countable) index)
Source

conversions.lisp.

Method: element-at ((range %range) index)
Source

conversions.lisp.

Generic Function: empty (o)

an empty version of this collection

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: empty ((it hash-table))
Source

builtins.lisp.

Method: empty ((it array))
Source

builtins.lisp.

Method: empty ((it vector))
Source

builtins.lisp.

Method: empty ((o cons))
Source

builtins.lisp.

Method: empty ((o null))
Source

builtins.lisp.

Method: empty ((o %seq-countable))
Source

conversions.lisp.

Method: empty ((o %countable-associative))
Source

conversions.lisp.

Method: empty ((c %countable-sequence))
Source

conversions.lisp.

Method: empty ((range %range))
Source

conversions.lisp.

Method: empty (o)
Generic Function: empty-p (o)

wether this collection is empty

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: empty-p ((it hash-table))
Source

builtins.lisp.

Method: empty-p ((it array))
Source

builtins.lisp.

Method: empty-p ((it vector))
Source

builtins.lisp.

Method: empty-p ((o cons))
Source

builtins.lisp.

Method: empty-p ((o null))
Source

builtins.lisp.

Method: empty-p ((o %seq-countable))
Source

conversions.lisp.

Method: empty-p ((o %countable-associative))
Source

conversions.lisp.

Method: empty-p ((c %countable-sequence))
Source

conversions.lisp.

Method: empty-p ((range %range))
Source

conversions.lisp.

Method: empty-p (o)
Generic Function: head (o)

first element

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: head ((it vector))
Source

builtins.lisp.

Method: head ((o cons))
Source

builtins.lisp.

Method: head ((o null))
Source

builtins.lisp.

Method: head (thing)
Source

default-methods.lisp.

Method: head ((c %countable-sequence))
Source

conversions.lisp.

Method: head ((range %range))
Source

conversions.lisp.

Generic Function: indexable (object)

convert an object to INDEXABLE protocol, or error.

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: indexable ((object array))
Source

builtins.lisp.

Method: indexable ((object vector))
Source

builtins.lisp.

Method: indexable ((object null))
Source

builtins.lisp.

Method: indexable (o)
Source

base-methods.lisp.

Method: indexable ((object %seq-countable))
Source

conversions.lisp.

Method: indexable ((object %range))
Source

conversions.lisp.

Generic Function: seq (o)

return a seq (or nil if count = 0) or error

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: seq ((it hash-table))
Source

builtins.lisp.

Method: seq ((it array))
Source

builtins.lisp.

Method: seq ((it vector))
Source

builtins.lisp.

Method: seq ((o cons))
Source

builtins.lisp.

Method: seq ((o null))
Source

builtins.lisp.

Method: seq (o)
Source

base-methods.lisp.

Method: seq ((c %countable-sequence))
Source

conversions.lisp.

Method: seq ((range %range))
Source

conversions.lisp.

Generic Function: tail (o)

the rest of the collection or nil

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: tail ((it vector))
Source

builtins.lisp.

Method: tail ((o cons))
Source

builtins.lisp.

Method: tail ((o null))
Source

builtins.lisp.

Method: tail (thing)
Source

default-methods.lisp.

Method: tail ((c %countable-sequence))
Source

conversions.lisp.

Method: tail ((range %range))
Source

conversions.lisp.

Generic Function: value-for-key (o k)

returns the value of k in o and t, or (values nil nil)

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Methods
Method: value-for-key ((o hash-table) k)
Source

builtins.lisp.

Method: value-for-key ((it array) key)
Source

builtins.lisp.

Method: value-for-key ((it vector) key)
Source

builtins.lisp.

Method: value-for-key ((o cons) index)
Source

builtins.lisp.

Method: value-for-key ((o null) k)
Source

builtins.lisp.

Method: value-for-key (thing k)
Source

default-methods.lisp.

Method: value-for-key ((o %countable-associative) key)
Source

conversions.lisp.


5.1.4 Types

Type: associative ()

a dictionary-like abstraction

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Type: collection ()

a collection knows if it is empty, and can produce an empty version of itself

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Type: countable ()

countable collection

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Type: foldable ()
Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Type: indexable ()

a thing that may be indexed

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Type: reduceable ()
Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Type: seq ()

a list-like abstraction

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Type: seqable ()

a thing that may be converted to a seq default implementation provided for indexable, associative and seq.

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.


5.2 Internals


5.2.1 Macros

Macro: define-interface-package (name documentation &rest exports)

create a package named name with documentation which uses :cl and *package*, exporting the symbols of exports.

Package

com.clearly-useful.generic-collection-interface.

Source

internal-utils.lisp.

Macro: with-fold-kernel (&body body)
Package

com.clearly-useful.generic-collection-interface.

Source

foldable-base.lisp.


5.2.2 Ordinary functions

Function: %%%%.defpun.fold-vector (kernel0 v n combiner reducer)
Package

com.clearly-useful.generic-collection-interface.

Source

parallel.lisp.

Function: %adjustable (vector &optional pad)
Package

com.clearly-useful.generic-collection-interface.

Source

internal-utils.lisp.

Function: %associative-to-indexable (assoc)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %count-seq (seq)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Reader: %countable-associative-countable (instance)
Writer: (setf %countable-associative-countable) (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Target Slot

countable.

Reader: %countable-associative-length (instance)
Writer: (setf %countable-associative-length) (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Target Slot

length.

Function: %countable-associative-p (object)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Reader: %countable-sequence-countable (instance)
Writer: (setf %countable-sequence-countable) (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Target Slot

countable.

Reader: %countable-sequence-index (instance)
Writer: (setf %countable-sequence-index) (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Target Slot

index.

Reader: %countable-sequence-length (instance)
Writer: (setf %countable-sequence-length) (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Target Slot

length.

Function: %countable-sequence-p (object)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %countable-sequence-size (c)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %countable-to-associative (countable)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %countable-to-seq (countable)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %dup-hash (it)
Package

com.clearly-useful.generic-collection-interface.

Source

internal-utils.lisp.

Function: %empty-hash (it)
Package

com.clearly-useful.generic-collection-interface.

Source

internal-utils.lisp.

Function: %folder-coll (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

foldable-base.lisp.

Function: (setf %folder-coll) (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

foldable-base.lisp.

Function: %folder-p (object)
Package

com.clearly-useful.generic-collection-interface.

Source

foldable-base.lisp.

Function: %folder-transformer (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

foldable-base.lisp.

Function: (setf %folder-transformer) (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

foldable-base.lisp.

Function: %hash-conj! (ht seq)
Package

com.clearly-useful.generic-collection-interface.

Source

conj.lisp.

Function: %interface-package (name documentation &rest exports)
Package

com.clearly-useful.generic-collection-interface.

Source

internal-utils.lisp.

Function: %next-countable-sequence (c)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %next-range (range)

return the next range by incrementing the lower bound of range, or nil

Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Reader: %range-high (instance)
Writer: (setf %range-high) (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Target Slot

high.

Reader: %range-low (instance)
Writer: (setf %range-low) (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Target Slot

low.

Function: %range-p (object)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %range-size (range)

the number of elements in a range

Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %reduce (fn collection &key initial-value)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Reader: %reducer-coll (instance)
Writer: (setf %reducer-coll) (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Target Slot

coll.

Function: %reducer-p (object)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Reader: %reducer-transformer (instance)
Writer: (setf %reducer-transformer) (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Target Slot

transformer.

Function: %seq-countable-contains-index (sc index)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %seq-countable-count (sc)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Reader: %seq-countable-fully-counted (instance)
Writer: (setf %seq-countable-fully-counted) (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Target Slot

fully-counted.

Function: %seq-countable-p (object)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Reader: %seq-countable-seq (instance)
Writer: (setf %seq-countable-seq) (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Target Slot

seq.

Reader: %seq-countable-ubound (instance)
Writer: (setf %seq-countable-ubound) (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Target Slot

ubound.

Function: %seq-indexable-by (seq n)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %seq-nth-or-error (seq n)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %seq-nth-or-nil-with-values (seq n)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %seq-to-associative (seq)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %seq-to-countable (seq)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %seq-to-list (seq)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: %vector-conj! (adjustable-vector val)
Package

com.clearly-useful.generic-collection-interface.

Source

conj.lisp.

Function: associative-p (object)

test if object implements ASSOCIATIVE

Package

com.clearly-useful.generic-collection-interface.

Source

protocols.lisp.

Function: copy-%countable-associative (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: copy-%countable-sequence (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: copy-%folder (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

foldable-base.lisp.

Function: copy-%range (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: copy-%reducer (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Function: copy-%seq-countable (instance)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: fold-vector (v n combiner reducer)
Package

com.clearly-useful.generic-collection-interface.

Source

parallel.lisp.

Function: make-%countable-associative (&key length countable)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: make-%countable-sequence (&key length index countable)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: make-%folder (&key coll transformer)
Package

com.clearly-useful.generic-collection-interface.

Source

foldable-base.lisp.

Function: make-%range (&key low high)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: make-%reducer (&key coll transformer)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Function: make-%seq-countable (&key seq ubound fully-counted)
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Function: reduce-indexable (r fn seed)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Function: reduce-seq (r fn seed)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Function: reduceable-reduce (fn collection &key initial-value)
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Function: subvec (vec start &optional end)
Package

com.clearly-useful.generic-collection-interface.

Source

internal-utils.lisp.


5.2.3 Standalone methods

Method: implements-protocol? ((object %countable-associative) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e9d3}>)))
Package

com.clearly-useful.protocols.

Source

conversions.lisp.

Method: implements-protocol? ((object %countable-associative) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e9c3}>)))
Package

com.clearly-useful.protocols.

Source

conversions.lisp.

Method: implements-protocol? ((object %folder) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e9f3}>)))
Package

com.clearly-useful.protocols.

Source

foldable-base.lisp.

Method: implements-protocol? ((object %countable-sequence) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e9a3}>)))
Package

com.clearly-useful.protocols.

Source

conversions.lisp.

Method: implements-protocol? ((object %countable-sequence) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e9b3}>)))
Package

com.clearly-useful.protocols.

Source

conversions.lisp.

Method: implements-protocol? ((object %countable-sequence) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e9c3}>)))
Package

com.clearly-useful.protocols.

Source

conversions.lisp.

Method: implements-protocol? ((object %reducer) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e9e3}>)))
Package

com.clearly-useful.protocols.

Source

reduceable-base.lisp.

Method: implements-protocol? ((object %seq-countable) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e983}>)))
Package

com.clearly-useful.protocols.

Source

conversions.lisp.

Method: implements-protocol? ((object %seq-countable) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e993}>)))
Package

com.clearly-useful.protocols.

Source

conversions.lisp.

Method: implements-protocol? ((object %seq-countable) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e9c3}>)))
Package

com.clearly-useful.protocols.

Source

conversions.lisp.

Method: implements-protocol? ((object %range) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e983}>)))
Package

com.clearly-useful.protocols.

Source

conversions.lisp.

Method: implements-protocol? ((object %range) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e993}>)))
Package

com.clearly-useful.protocols.

Source

conversions.lisp.

Method: implements-protocol? ((object %range) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e9a3}>)))
Package

com.clearly-useful.protocols.

Source

conversions.lisp.

Method: implements-protocol? ((object %range) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e9b3}>)))
Package

com.clearly-useful.protocols.

Source

conversions.lisp.

Method: implements-protocol? ((object %range) (protocol (eql #<com.clearly-useful.protocols::protocol {100a98e9c3}>)))
Package

com.clearly-useful.protocols.

Source

conversions.lisp.


5.2.4 Structures

Structure: %countable-associative
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: length
Package

common-lisp.

Readers

%countable-associative-length.

Writers

(setf %countable-associative-length).

Slot: countable
Readers

%countable-associative-countable.

Writers

(setf %countable-associative-countable).

Structure: %countable-sequence
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: length
Package

common-lisp.

Readers

%countable-sequence-length.

Writers

(setf %countable-sequence-length).

Slot: index
Readers

%countable-sequence-index.

Writers

(setf %countable-sequence-index).

Slot: countable
Readers

%countable-sequence-countable.

Writers

(setf %countable-sequence-countable).

Structure: %folder
Package

com.clearly-useful.generic-collection-interface.

Source

foldable-base.lisp.

Direct superclasses

%reducer.

Direct methods
Structure: %range

an immutable integer range from low to high, exclusive.

Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: low
Readers

%range-low.

Writers

(setf %range-low).

Slot: high
Readers

%range-high.

Writers

(setf %range-high).

Structure: %reducer
Package

com.clearly-useful.generic-collection-interface.

Source

reduceable-base.lisp.

Direct superclasses

structure-object.

Direct subclasses

%folder.

Direct methods
Direct slots
Slot: coll
Readers

%reducer-coll.

Writers

(setf %reducer-coll).

Slot: transformer
Readers

%reducer-transformer.

Writers

(setf %reducer-transformer).

Structure: %seq-countable
Package

com.clearly-useful.generic-collection-interface.

Source

conversions.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: seq
Readers

%seq-countable-seq.

Writers

(setf %seq-countable-seq).

Slot: ubound
Readers

%seq-countable-ubound.

Writers

(setf %seq-countable-ubound).

Slot: fully-counted
Readers

%seq-countable-fully-counted.

Writers

(setf %seq-countable-fully-counted).


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   %   (  
A   C   D   E   F   G   H   I   M   R   S   T   V   W  
Index Entry  Section

%
%%%%.defpun.fold-vector: Private ordinary functions
%adjustable: Private ordinary functions
%associative-to-indexable: Private ordinary functions
%count-seq: Private ordinary functions
%countable-associative-countable: Private ordinary functions
%countable-associative-length: Private ordinary functions
%countable-associative-p: Private ordinary functions
%countable-sequence-countable: Private ordinary functions
%countable-sequence-index: Private ordinary functions
%countable-sequence-length: Private ordinary functions
%countable-sequence-p: Private ordinary functions
%countable-sequence-size: Private ordinary functions
%countable-to-associative: Private ordinary functions
%countable-to-seq: Private ordinary functions
%dup-hash: Private ordinary functions
%empty-hash: Private ordinary functions
%folder-coll: Private ordinary functions
%folder-p: Private ordinary functions
%folder-transformer: Private ordinary functions
%hash-conj!: Private ordinary functions
%interface-package: Private ordinary functions
%next-countable-sequence: Private ordinary functions
%next-range: Private ordinary functions
%range-high: Private ordinary functions
%range-low: Private ordinary functions
%range-p: Private ordinary functions
%range-size: Private ordinary functions
%reduce: Private ordinary functions
%reducer-coll: Private ordinary functions
%reducer-p: Private ordinary functions
%reducer-transformer: Private ordinary functions
%seq-countable-contains-index: Private ordinary functions
%seq-countable-count: Private ordinary functions
%seq-countable-fully-counted: Private ordinary functions
%seq-countable-p: Private ordinary functions
%seq-countable-seq: Private ordinary functions
%seq-countable-ubound: Private ordinary functions
%seq-indexable-by: Private ordinary functions
%seq-nth-or-error: Private ordinary functions
%seq-nth-or-nil-with-values: Private ordinary functions
%seq-to-associative: Private ordinary functions
%seq-to-countable: Private ordinary functions
%seq-to-list: Private ordinary functions
%vector-conj!: Private ordinary functions

(
(setf %countable-associative-countable): Private ordinary functions
(setf %countable-associative-length): Private ordinary functions
(setf %countable-sequence-countable): Private ordinary functions
(setf %countable-sequence-index): Private ordinary functions
(setf %countable-sequence-length): Private ordinary functions
(setf %folder-coll): Private ordinary functions
(setf %folder-transformer): Private ordinary functions
(setf %range-high): Private ordinary functions
(setf %range-low): Private ordinary functions
(setf %reducer-coll): Private ordinary functions
(setf %reducer-transformer): Private ordinary functions
(setf %seq-countable-fully-counted): Private ordinary functions
(setf %seq-countable-seq): Private ordinary functions
(setf %seq-countable-ubound): Private ordinary functions

A
all-keys: Public generic functions
all-keys: Public generic functions
all-keys: Public generic functions
all-keys: Public generic functions
all-keys: Public generic functions
all-keys: Public generic functions
all-keys: Public generic functions
all-keys: Public generic functions
all-keys-and-values: Public generic functions
all-keys-and-values: Public generic functions
all-keys-and-values: Public generic functions
all-values: Public generic functions
all-values: Public generic functions
all-values: Public generic functions
all-values: Public generic functions
all-values: Public generic functions
all-values: Public generic functions
all-values: Public generic functions
all-values: Public generic functions
associative: Public generic functions
associative: Public generic functions
associative: Public generic functions
associative: Public generic functions
associative: Public generic functions
associative: Public generic functions
associative: Public generic functions
associative: Public generic functions
associative-p: Private ordinary functions

C
coll-fold: Public generic functions
coll-fold: Public generic functions
coll-fold: Public generic functions
coll-fold: Public generic functions
coll-reduce: Public generic functions
coll-reduce: Public generic functions
coll-reduce: Public generic functions
coll-reduce: Public generic functions
coll-reduce: Public generic functions
coll-reduce: Public generic functions
coll-reduce: Public generic functions
coll-reduce: Public generic functions
collection-p: Public ordinary functions
conj: Public generic functions
conj: Public generic functions
conj: Public generic functions
conj: Public generic functions
conj: Public generic functions
contains-key-p: Public generic functions
contains-key-p: Public generic functions
contains-key-p: Public generic functions
contains-key-p: Public generic functions
contains-key-p: Public generic functions
contains-key-p: Public generic functions
contains-key-p: Public generic functions
contains-key-p: Public generic functions
copy-%countable-associative: Private ordinary functions
copy-%countable-sequence: Private ordinary functions
copy-%folder: Private ordinary functions
copy-%range: Private ordinary functions
copy-%reducer: Private ordinary functions
copy-%seq-countable: Private ordinary functions
count-elements: Public generic functions
count-elements: Public generic functions
count-elements: Public generic functions
count-elements: Public generic functions
count-elements: Public generic functions
count-elements: Public generic functions
count-elements: Public generic functions
count-elements: Public generic functions
count-elements: Public generic functions
countable: Public generic functions
countable: Public generic functions
countable: Public generic functions
countable: Public generic functions
countable: Public generic functions
countable: Public generic functions
countable: Public generic functions
countable: Public generic functions
countable: Public generic functions
countable-p: Public ordinary functions
counted-p: Public generic functions
counted-p: Public generic functions
counted-p: Public generic functions
counted-p: Public generic functions
counted-p: Public generic functions
counted-p: Public generic functions
counted-p: Public generic functions
counted-p: Public generic functions
counted-p: Public generic functions

D
define-interface-package: Private macros
doindexable: Public macros
doseq: Public macros

E
element-at: Public generic functions
element-at: Public generic functions
element-at: Public generic functions
element-at: Public generic functions
element-at: Public generic functions
element-at: Public generic functions
element-at: Public generic functions
empty: Public generic functions
empty: Public generic functions
empty: Public generic functions
empty: Public generic functions
empty: Public generic functions
empty: Public generic functions
empty: Public generic functions
empty: Public generic functions
empty: Public generic functions
empty: Public generic functions
empty: Public generic functions
empty-p: Public generic functions
empty-p: Public generic functions
empty-p: Public generic functions
empty-p: Public generic functions
empty-p: Public generic functions
empty-p: Public generic functions
empty-p: Public generic functions
empty-p: Public generic functions
empty-p: Public generic functions
empty-p: Public generic functions
empty-p: Public generic functions

F
filtering: Public ordinary functions
fold: Public ordinary functions
fold-left: Public ordinary functions
fold-vector: Private ordinary functions
foldable-p: Public ordinary functions
folder: Public ordinary functions
Function, %%%%.defpun.fold-vector: Private ordinary functions
Function, %adjustable: Private ordinary functions
Function, %associative-to-indexable: Private ordinary functions
Function, %count-seq: Private ordinary functions
Function, %countable-associative-countable: Private ordinary functions
Function, %countable-associative-length: Private ordinary functions
Function, %countable-associative-p: Private ordinary functions
Function, %countable-sequence-countable: Private ordinary functions
Function, %countable-sequence-index: Private ordinary functions
Function, %countable-sequence-length: Private ordinary functions
Function, %countable-sequence-p: Private ordinary functions
Function, %countable-sequence-size: Private ordinary functions
Function, %countable-to-associative: Private ordinary functions
Function, %countable-to-seq: Private ordinary functions
Function, %dup-hash: Private ordinary functions
Function, %empty-hash: Private ordinary functions
Function, %folder-coll: Private ordinary functions
Function, %folder-p: Private ordinary functions
Function, %folder-transformer: Private ordinary functions
Function, %hash-conj!: Private ordinary functions
Function, %interface-package: Private ordinary functions
Function, %next-countable-sequence: Private ordinary functions
Function, %next-range: Private ordinary functions
Function, %range-high: Private ordinary functions
Function, %range-low: Private ordinary functions
Function, %range-p: Private ordinary functions
Function, %range-size: Private ordinary functions
Function, %reduce: Private ordinary functions
Function, %reducer-coll: Private ordinary functions
Function, %reducer-p: Private ordinary functions
Function, %reducer-transformer: Private ordinary functions
Function, %seq-countable-contains-index: Private ordinary functions
Function, %seq-countable-count: Private ordinary functions
Function, %seq-countable-fully-counted: Private ordinary functions
Function, %seq-countable-p: Private ordinary functions
Function, %seq-countable-seq: Private ordinary functions
Function, %seq-countable-ubound: Private ordinary functions
Function, %seq-indexable-by: Private ordinary functions
Function, %seq-nth-or-error: Private ordinary functions
Function, %seq-nth-or-nil-with-values: Private ordinary functions
Function, %seq-to-associative: Private ordinary functions
Function, %seq-to-countable: Private ordinary functions
Function, %seq-to-list: Private ordinary functions
Function, %vector-conj!: Private ordinary functions
Function, (setf %countable-associative-countable): Private ordinary functions
Function, (setf %countable-associative-length): Private ordinary functions
Function, (setf %countable-sequence-countable): Private ordinary functions
Function, (setf %countable-sequence-index): Private ordinary functions
Function, (setf %countable-sequence-length): Private ordinary functions
Function, (setf %folder-coll): Private ordinary functions
Function, (setf %folder-transformer): Private ordinary functions
Function, (setf %range-high): Private ordinary functions
Function, (setf %range-low): Private ordinary functions
Function, (setf %reducer-coll): Private ordinary functions
Function, (setf %reducer-transformer): Private ordinary functions
Function, (setf %seq-countable-fully-counted): Private ordinary functions
Function, (setf %seq-countable-seq): Private ordinary functions
Function, (setf %seq-countable-ubound): Private ordinary functions
Function, associative-p: Private ordinary functions
Function, collection-p: Public ordinary functions
Function, copy-%countable-associative: Private ordinary functions
Function, copy-%countable-sequence: Private ordinary functions
Function, copy-%folder: Private ordinary functions
Function, copy-%range: Private ordinary functions
Function, copy-%reducer: Private ordinary functions
Function, copy-%seq-countable: Private ordinary functions
Function, countable-p: Public ordinary functions
Function, filtering: Public ordinary functions
Function, fold: Public ordinary functions
Function, fold-left: Public ordinary functions
Function, fold-vector: Private ordinary functions
Function, foldable-p: Public ordinary functions
Function, folder: Public ordinary functions
Function, getkey: Public ordinary functions
Function, indexable-p: Public ordinary functions
Function, into: Public ordinary functions
Function, make-%countable-associative: Private ordinary functions
Function, make-%countable-sequence: Private ordinary functions
Function, make-%folder: Private ordinary functions
Function, make-%range: Private ordinary functions
Function, make-%reducer: Private ordinary functions
Function, make-%seq-countable: Private ordinary functions
Function, mapcatting: Public ordinary functions
Function, mapping: Public ordinary functions
Function, monoid: Public ordinary functions
Function, reduce-indexable: Private ordinary functions
Function, reduce-seq: Private ordinary functions
Function, reduceable-p: Public ordinary functions
Function, reduceable-reduce: Private ordinary functions
Function, reduced: Public ordinary functions
Function, reducer: Public ordinary functions
Function, seq-p: Public ordinary functions
Function, seq-to-list: Public ordinary functions
Function, seqable-p: Public ordinary functions
Function, subvec: Private ordinary functions

G
Generic Function, all-keys: Public generic functions
Generic Function, all-keys-and-values: Public generic functions
Generic Function, all-values: Public generic functions
Generic Function, associative: Public generic functions
Generic Function, coll-fold: Public generic functions
Generic Function, coll-reduce: Public generic functions
Generic Function, conj: Public generic functions
Generic Function, contains-key-p: Public generic functions
Generic Function, count-elements: Public generic functions
Generic Function, countable: Public generic functions
Generic Function, counted-p: Public generic functions
Generic Function, element-at: Public generic functions
Generic Function, empty: Public generic functions
Generic Function, empty-p: Public generic functions
Generic Function, head: Public generic functions
Generic Function, indexable: Public generic functions
Generic Function, seq: Public generic functions
Generic Function, tail: Public generic functions
Generic Function, value-for-key: Public generic functions
getkey: Public ordinary functions

H
head: Public generic functions
head: Public generic functions
head: Public generic functions
head: Public generic functions
head: Public generic functions
head: Public generic functions
head: Public generic functions

I
implements-protocol?: Private standalone methods
implements-protocol?: Private standalone methods
implements-protocol?: Private standalone methods
implements-protocol?: Private standalone methods
implements-protocol?: Private standalone methods
implements-protocol?: Private standalone methods
implements-protocol?: Private standalone methods
implements-protocol?: Private standalone methods
implements-protocol?: Private standalone methods
implements-protocol?: Private standalone methods
implements-protocol?: Private standalone methods
implements-protocol?: Private standalone methods
implements-protocol?: Private standalone methods
implements-protocol?: Private standalone methods
implements-protocol?: Private standalone methods
indexable: Public generic functions
indexable: Public generic functions
indexable: Public generic functions
indexable: Public generic functions
indexable: Public generic functions
indexable: Public generic functions
indexable: Public generic functions
indexable-p: Public ordinary functions
into: Public ordinary functions

M
Macro, define-interface-package: Private macros
Macro, doindexable: Public macros
Macro, doseq: Public macros
Macro, with-fold-kernel: Private macros
make-%countable-associative: Private ordinary functions
make-%countable-sequence: Private ordinary functions
make-%folder: Private ordinary functions
make-%range: Private ordinary functions
make-%reducer: Private ordinary functions
make-%seq-countable: Private ordinary functions
mapcatting: Public ordinary functions
mapping: Public ordinary functions
Method, all-keys: Public generic functions
Method, all-keys: Public generic functions
Method, all-keys: Public generic functions
Method, all-keys: Public generic functions
Method, all-keys: Public generic functions
Method, all-keys: Public generic functions
Method, all-keys: Public generic functions
Method, all-keys-and-values: Public generic functions
Method, all-keys-and-values: Public generic functions
Method, all-values: Public generic functions
Method, all-values: Public generic functions
Method, all-values: Public generic functions
Method, all-values: Public generic functions
Method, all-values: Public generic functions
Method, all-values: Public generic functions
Method, all-values: Public generic functions
Method, associative: Public generic functions
Method, associative: Public generic functions
Method, associative: Public generic functions
Method, associative: Public generic functions
Method, associative: Public generic functions
Method, associative: Public generic functions
Method, associative: Public generic functions
Method, coll-fold: Public generic functions
Method, coll-fold: Public generic functions
Method, coll-fold: Public generic functions
Method, coll-reduce: Public generic functions
Method, coll-reduce: Public generic functions
Method, coll-reduce: Public generic functions
Method, coll-reduce: Public generic functions
Method, coll-reduce: Public generic functions
Method, coll-reduce: Public generic functions
Method, coll-reduce: Public generic functions
Method, conj: Public generic functions
Method, conj: Public generic functions
Method, conj: Public generic functions
Method, conj: Public generic functions
Method, contains-key-p: Public generic functions
Method, contains-key-p: Public generic functions
Method, contains-key-p: Public generic functions
Method, contains-key-p: Public generic functions
Method, contains-key-p: Public generic functions
Method, contains-key-p: Public generic functions
Method, contains-key-p: Public generic functions
Method, count-elements: Public generic functions
Method, count-elements: Public generic functions
Method, count-elements: Public generic functions
Method, count-elements: Public generic functions
Method, count-elements: Public generic functions
Method, count-elements: Public generic functions
Method, count-elements: Public generic functions
Method, count-elements: Public generic functions
Method, countable: Public generic functions
Method, countable: Public generic functions
Method, countable: Public generic functions
Method, countable: Public generic functions
Method, countable: Public generic functions
Method, countable: Public generic functions
Method, countable: Public generic functions
Method, countable: Public generic functions
Method, counted-p: Public generic functions
Method, counted-p: Public generic functions
Method, counted-p: Public generic functions
Method, counted-p: Public generic functions
Method, counted-p: Public generic functions
Method, counted-p: Public generic functions
Method, counted-p: Public generic functions
Method, counted-p: Public generic functions
Method, element-at: Public generic functions
Method, element-at: Public generic functions
Method, element-at: Public generic functions
Method, element-at: Public generic functions
Method, element-at: Public generic functions
Method, element-at: Public generic functions
Method, empty: Public generic functions
Method, empty: Public generic functions
Method, empty: Public generic functions
Method, empty: Public generic functions
Method, empty: Public generic functions
Method, empty: Public generic functions
Method, empty: Public generic functions
Method, empty: Public generic functions
Method, empty: Public generic functions
Method, empty: Public generic functions
Method, empty-p: Public generic functions
Method, empty-p: Public generic functions
Method, empty-p: Public generic functions
Method, empty-p: Public generic functions
Method, empty-p: Public generic functions
Method, empty-p: Public generic functions
Method, empty-p: Public generic functions
Method, empty-p: Public generic functions
Method, empty-p: Public generic functions
Method, empty-p: Public generic functions
Method, head: Public generic functions
Method, head: Public generic functions
Method, head: Public generic functions
Method, head: Public generic functions
Method, head: Public generic functions
Method, head: Public generic functions
Method, implements-protocol?: Private standalone methods
Method, implements-protocol?: Private standalone methods
Method, implements-protocol?: Private standalone methods
Method, implements-protocol?: Private standalone methods
Method, implements-protocol?: Private standalone methods
Method, implements-protocol?: Private standalone methods
Method, implements-protocol?: Private standalone methods
Method, implements-protocol?: Private standalone methods
Method, implements-protocol?: Private standalone methods
Method, implements-protocol?: Private standalone methods
Method, implements-protocol?: Private standalone methods
Method, implements-protocol?: Private standalone methods
Method, implements-protocol?: Private standalone methods
Method, implements-protocol?: Private standalone methods
Method, implements-protocol?: Private standalone methods
Method, indexable: Public generic functions
Method, indexable: Public generic functions
Method, indexable: Public generic functions
Method, indexable: Public generic functions
Method, indexable: Public generic functions
Method, indexable: Public generic functions
Method, seq: Public generic functions
Method, seq: Public generic functions
Method, seq: Public generic functions
Method, seq: Public generic functions
Method, seq: Public generic functions
Method, seq: Public generic functions
Method, seq: Public generic functions
Method, seq: Public generic functions
Method, tail: Public generic functions
Method, tail: Public generic functions
Method, tail: Public generic functions
Method, tail: Public generic functions
Method, tail: Public generic functions
Method, tail: Public generic functions
Method, value-for-key: Public generic functions
Method, value-for-key: Public generic functions
Method, value-for-key: Public generic functions
Method, value-for-key: Public generic functions
Method, value-for-key: Public generic functions
Method, value-for-key: Public generic functions
Method, value-for-key: Public generic functions
monoid: Public ordinary functions

R
reduce-indexable: Private ordinary functions
reduce-seq: Private ordinary functions
reduceable-p: Public ordinary functions
reduceable-reduce: Private ordinary functions
reduced: Public ordinary functions
reducer: Public ordinary functions

S
seq: Public generic functions
seq: Public generic functions
seq: Public generic functions
seq: Public generic functions
seq: Public generic functions
seq: Public generic functions
seq: Public generic functions
seq: Public generic functions
seq: Public generic functions
seq-p: Public ordinary functions
seq-to-list: Public ordinary functions
seqable-p: Public ordinary functions
subvec: Private ordinary functions

T
tail: Public generic functions
tail: Public generic functions
tail: Public generic functions
tail: Public generic functions
tail: Public generic functions
tail: Public generic functions
tail: Public generic functions

V
value-for-key: Public generic functions
value-for-key: Public generic functions
value-for-key: Public generic functions
value-for-key: Public generic functions
value-for-key: Public generic functions
value-for-key: Public generic functions
value-for-key: Public generic functions
value-for-key: Public generic functions

W
with-fold-kernel: Private macros


A.4 Data types

Jump to:   %  
A   B   C   D   F   I   M   P   R   S   T  
Index Entry  Section

%
%countable-associative: Private structures
%countable-sequence: Private structures
%folder: Private structures
%range: Private structures
%reducer: Private structures
%seq-countable: Private structures

A
associative: Public types

B
base-methods.lisp: The com․clearly-useful․generic-collection-interface/base-methods․lisp file
builtins.lisp: The com․clearly-useful․generic-collection-interface/builtins․lisp file

C
collection: Public types
com.clearly-useful.associative-protocol: The com․clearly-useful․associative-protocol package
com.clearly-useful.collection-protocol: The com․clearly-useful․collection-protocol package
com.clearly-useful.countable-protocol: The com․clearly-useful․countable-protocol package
com.clearly-useful.foldable-protocol: The com․clearly-useful․foldable-protocol package
com.clearly-useful.generic-collection-interface: The com․clearly-useful․generic-collection-interface system
com.clearly-useful.generic-collection-interface: The com․clearly-useful․generic-collection-interface package
com.clearly-useful.generic-collection-interface.asd: The com․clearly-useful․generic-collection-interface/com․clearly-useful․generic-collection-interface․asd file
com.clearly-useful.generic-collection-interface.lisp: The com․clearly-useful․generic-collection-interface/com․clearly-useful․generic-collection-interface․lisp file
com.clearly-useful.indexable-protocol: The com․clearly-useful․indexable-protocol package
com.clearly-useful.reduceable-protocol: The com․clearly-useful․reduceable-protocol package
com.clearly-useful.sequence-protocol: The com․clearly-useful․sequence-protocol package
conj.lisp: The com․clearly-useful․generic-collection-interface/conj․lisp file
conversions.lisp: The com․clearly-useful․generic-collection-interface/conversions․lisp file
countable: Public types

D
default-methods.lisp: The com․clearly-useful․generic-collection-interface/default-methods․lisp file

F
features.lisp: The com․clearly-useful․generic-collection-interface/features․lisp file
File, base-methods.lisp: The com․clearly-useful․generic-collection-interface/base-methods․lisp file
File, builtins.lisp: The com․clearly-useful․generic-collection-interface/builtins․lisp file
File, com.clearly-useful.generic-collection-interface.asd: The com․clearly-useful․generic-collection-interface/com․clearly-useful․generic-collection-interface․asd file
File, com.clearly-useful.generic-collection-interface.lisp: The com․clearly-useful․generic-collection-interface/com․clearly-useful․generic-collection-interface․lisp file
File, conj.lisp: The com․clearly-useful․generic-collection-interface/conj․lisp file
File, conversions.lisp: The com․clearly-useful․generic-collection-interface/conversions․lisp file
File, default-methods.lisp: The com․clearly-useful․generic-collection-interface/default-methods․lisp file
File, features.lisp: The com․clearly-useful․generic-collection-interface/features․lisp file
File, foldable-base.lisp: The com․clearly-useful․generic-collection-interface/foldable-base․lisp file
File, internal-utils.lisp: The com․clearly-useful․generic-collection-interface/internal-utils․lisp file
File, macros.lisp: The com․clearly-useful․generic-collection-interface/macros․lisp file
File, methods.lisp: The com․clearly-useful․generic-collection-interface/methods․lisp file
File, package.lisp: The com․clearly-useful․generic-collection-interface/package․lisp file
File, parallel.lisp: The com․clearly-useful․generic-collection-interface/parallel․lisp file
File, protocols.lisp: The com․clearly-useful․generic-collection-interface/protocols․lisp file
File, reduceable-base.lisp: The com․clearly-useful․generic-collection-interface/reduceable-base․lisp file
foldable: Public types
foldable-base.lisp: The com․clearly-useful․generic-collection-interface/foldable-base․lisp file

I
indexable: Public types
internal-utils.lisp: The com․clearly-useful․generic-collection-interface/internal-utils․lisp file

M
macros.lisp: The com․clearly-useful․generic-collection-interface/macros․lisp file
methods.lisp: The com․clearly-useful․generic-collection-interface/methods․lisp file

P
Package, com.clearly-useful.associative-protocol: The com․clearly-useful․associative-protocol package
Package, com.clearly-useful.collection-protocol: The com․clearly-useful․collection-protocol package
Package, com.clearly-useful.countable-protocol: The com․clearly-useful․countable-protocol package
Package, com.clearly-useful.foldable-protocol: The com․clearly-useful․foldable-protocol package
Package, com.clearly-useful.generic-collection-interface: The com․clearly-useful․generic-collection-interface package
Package, com.clearly-useful.indexable-protocol: The com․clearly-useful․indexable-protocol package
Package, com.clearly-useful.reduceable-protocol: The com․clearly-useful․reduceable-protocol package
Package, com.clearly-useful.sequence-protocol: The com․clearly-useful․sequence-protocol package
package.lisp: The com․clearly-useful․generic-collection-interface/package․lisp file
parallel.lisp: The com․clearly-useful․generic-collection-interface/parallel․lisp file
protocols.lisp: The com․clearly-useful․generic-collection-interface/protocols․lisp file

R
reduceable: Public types
reduceable-base.lisp: The com․clearly-useful․generic-collection-interface/reduceable-base․lisp file

S
seq: Public types
seqable: Public types
Structure, %countable-associative: Private structures
Structure, %countable-sequence: Private structures
Structure, %folder: Private structures
Structure, %range: Private structures
Structure, %reducer: Private structures
Structure, %seq-countable: Private structures
System, com.clearly-useful.generic-collection-interface: The com․clearly-useful․generic-collection-interface system

T
Type, associative: Public types
Type, collection: Public types
Type, countable: Public types
Type, foldable: Public types
Type, indexable: Public types
Type, reduceable: Public types
Type, seq: Public types
Type, seqable: Public types