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

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

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 Mon Aug 15 04:18:31 2022 GMT+0.

Table of Contents


1 Introduction

#+TITLE: generic collection interface for common lisp

* overview

  Warning:
  This system is not yet at 1.0, and the interfaces will change as
  I use them more and work out design problems. Buyer beware!
  
  This system provides several related protocols and a few functions
  for collection manipulation in common lisp, and implementations for
  built-in types. It includes an interface for clojure-style reducers.
  While this system may be used to simply consume collections,
  it does not contain many utility functions for doing so, as
  it is intended to be used by implementors that wish to provide
  a clean interface to their own collection classes.
  As a convenience, interface packages are provided for each of the protocols
  defined which export only the symbols relevant to that
  protocol. (see com.clearly-useful.generic-collection-interface.lisp)
  None of the symbols exported by this system clash
  with common lisp.

* justification

  There are many quality data structure libraries for common lisp,
  but they have disparate interfaces, and swapping in a new collection
  type to existing code can be painful. This library is an attempt
  to provide a sufficiently generic set of protocols so that code written
  to them may use any data structure appropriate to the task at hand
  without difficulty. 

* design

  The design of this library is modelled quite a bit after clojure,
  but it is written to integrate with common lisp. None of the symbols
  exported by this package clash with the cl package, and the code
  follows cl naming conventions. There are several packages related
  to this one that simply export a subset of it's interface. These
  packages are to help implementors who don't want to import the
  entire collection interface just to implement a certain aspect 
  of it.

* protocol overview

  This package defines several protocols for working with
  collections, some of which are interrelated.

** =collection=
   This is the base protocol for the library.
   A collection responds to two methods:

   =empty= -> produce an empty collection
   =empty-p= -> whether the collection is empty

** =seqable=
   A thing which may be converted to a seq.  This protocol
   defines the method =seq= which serves a bit of a double duty: it
   may be used to create a list-like object from another, but should
   always return /nil/ when it's result is empty. For example, given a
   (hypothetical) unordered set which implements =collection= and
   =seqable=:
#begin_src lisp
   a ;=> {2 1 3}
   (empty a) ;=> {}
   (empty-p a) ;=> nil
   (empty-p (empty a)) ;=> t
   (seq a) ; => (3 2 1) or similar
   (seq (empty a)) ;=> nil
#end_src
   
   
** =seq=
   requires =collection=, =seqable=
   This protocol provides a list-like abstraction with
   the methods =head= and =tail=.
 

** =associative=
   requires =collection=
   This protocol provides a dictionary-like abstraction with the
   methods =all-keys=, =all-values=, =contains-key-p=, and
   =value-for-key=.
   

** =countable=
   requires =collection=
   A collection that may be counted.
   =counted-p= -> bool, whether count-elements is o(1)
   =count-elements= -> number
   
** =indexable=
   requires =collection=, =countable=
   This protocol provides a vector-like abstraction
   with the method =element-at=

** =reduceable=
   a thing which can reduce itself via =coll-reduce=
   used to implement clojure-style reducers.
   
** =foldable=
   a thing which can fold itself via =coll-fold=
   ditto reducable, includes a parallel implementation
   for common lisp vectors.
   
* additional functions
** additional associative functions
   all-keys-and-values
   getkey
   
** fold-left, fold

* exported symbols

  See [[https://github.com/jaeschliman/com.clearly-useful.generic-collection-interface/blob/master/package.lisp][package.lisp]] for a list of all exported symbols.

  For in depth information each protocol and their associated symbols,
  visit the links to the individual protocol systems above.

  The file builtins.lisp contains the protocol implementations
  for many built-in common lisp types.
  
* notes & todos

  the file test.lisp defines some data structures, each implementing
  one of the three major protocols & confirms that they translate
  among each other correctly.


** TODO fix hash-table weakness
   (empty h-t) not yet aware of hash table weakness

** TODO write examples/demo, more docs
   better to factor them out among the
   sub-packages


2 Systems

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


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

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

generic collection interfaces for common lisp

Author

Jason Aeschliman <j.aeschliman@gmail.com>

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.


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

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.countable-protocol

Interface to the countable protocol

Source

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

Use List

4.3 com.clearly-useful.sequence-protocol

Interface to the sequence protocol

Source

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

Use List

4.4 com.clearly-useful.reduceable-protocol

Interface to the reduceable protocol

Source

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

Use List

4.5 com.clearly-useful.indexable-protocol

Interface to the indexable protocol

Source

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

Use List

4.6 com.clearly-useful.associative-protocol

Interface to the associative protocol

Source

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

Use List

4.7 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.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.


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

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


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

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.


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

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.


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

5.2.3 Standalone methods

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

com.clearly-useful.protocols.

Source

conversions.lisp.

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

com.clearly-useful.protocols.

Source

conversions.lisp.

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

com.clearly-useful.protocols.

Source

foldable-base.lisp.

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

com.clearly-useful.protocols.

Source

conversions.lisp.

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

com.clearly-useful.protocols.

Source

conversions.lisp.

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

com.clearly-useful.protocols.

Source

conversions.lisp.

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

com.clearly-useful.protocols.

Source

reduceable-base.lisp.

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

com.clearly-useful.protocols.

Source

conversions.lisp.

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

com.clearly-useful.protocols.

Source

conversions.lisp.

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

com.clearly-useful.protocols.

Source

conversions.lisp.

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

com.clearly-useful.protocols.

Source

conversions.lisp.

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

com.clearly-useful.protocols.

Source

conversions.lisp.

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

com.clearly-useful.protocols.

Source

conversions.lisp.

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

com.clearly-useful.protocols.

Source

conversions.lisp.

Method: implements-protocol? ((object %range) (protocol (eql #<com.clearly-useful.protocols::protocol {100a9d9d83}>)))
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


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

A.1 Concepts


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

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

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

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

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

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