The collectors Reference Manual

This is the collectors Reference Manual, version 1.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon May 15 04:39:35 2023 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 collectors

A library providing various collector type macros
pulled from arnesi into its own library and stripped of dependencies

Maintainer

Russ Tyndall <>

Author

Marco Baringer, Russ Tyndall <>

License

BSD

Version

1.0

Dependencies
  • alexandria (system).
  • closer-mop (system).
  • symbol-munger (system).
Source

collectors.asd.

Child Component

collectors.lisp (file).


3 Files

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


3.1 Lisp


3.1.1 collectors/collectors.asd

Source

collectors.asd.

Parent Component

collectors (system).

ASDF Systems

collectors.


3.1.2 collectors/collectors.lisp

Source

collectors.asd.

Parent Component

collectors (system).

Packages
Public Interface
Internals

4 Packages

Packages are listed by definition order.


4.1 collectors

Source

collectors.lisp.

Use List
Public Interface
Internals

4.2 collectors-signals

Source

collectors.lisp.

Used By List

collectors.

Public Interface

5 Definitions

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


5.1 Public Interface


5.1.1 Macros

Macro: append-at-end (head-place tail-place values-place)

Macros to ease efficient collection (with appending) at the end of a list

Package

collectors.

Source

collectors.lisp.

Macro: appending ((arg list) &body body)

A mapping collecting macro for operating on elements of a list (similar to (mapcan (lambda (,arg) ,@body) list), but using a collector so all signals are in place)

Package

collectors.

Source

collectors.lisp.

Macro: collect-at-end (head-place tail-place values-place)

Macros to ease efficient collection at the end of a list

Package

collectors.

Source

collectors.lisp.

Macro: collecting ((arg list) &body body)

A mapping collecting macro for operating on elements of a list (similar to (mapcar (lambda (,arg) ,@body) list), but using a collector so all signals are in place)

Package

collectors.

Source

collectors.lisp.

Macro: make-simple-appender-to-place (place)

A fastest possible, fewest frills collector suitable to places where efficiency matters that appends any values that re lists

Package

collectors.

Source

collectors.lisp.

Macro: make-simple-collector-to-place (place)
Package

collectors.

Source

collectors.lisp.

Macro: with-alist-output ((name &key collect-nil initial-value from-end place) &body body)
Package

collectors.

Source

collectors.lisp.

Macro: with-appender ((name &key initial-value place) &body body)

Bind NAME to a collector function and execute BODY. If FROM-END is true the collector will actually be a pusher, (see MAKE-PUSHER), otherwise NAME will be bound to a collector, (see MAKE-COLLECTOR).

(with-appender (app)
(app ’(1 2))
(app ’(2 3))
(app ’(3 4))
(app)) => (1 2 2 3 3 4)

Package

collectors.

Source

collectors.lisp.

Macro: with-appender-output ((name &key initial-value place) &body body)

Same as with-appender, but this form returns the collected values automatically

Package

collectors.

Source

collectors.lisp.

Macro: with-collector ((name &key place collect-nil initial-value from-end) &body body)

Bind NAME to a collector function and execute BODY. If FROM-END is true the collector will actually be a pusher, (see MAKE-PUSHER), otherwise NAME will be bound to a collector, (see MAKE-COLLECTOR).
(with-collector (col)
(col 1)
(col 2)
(col 3)
(col)) => (1 2 3)

Package

collectors.

Source

collectors.lisp.

Macro: with-collector-output ((name &key collect-nil initial-value from-end place) &body body)
Package

collectors.

Source

collectors.lisp.

Macro: with-collectors (names &body body)

Bind multiple collectors. Each element of NAMES should be a list as per WITH-COLLECTOR’s first orgument.

Package

collectors.

Source

collectors.lisp.

Macro: with-formatter ((name &key delimiter stream pretty) &body body)

A macro makes a function with name for body that is a string formatter see make-formatter

Package

collectors.

Source

collectors.lisp.

Macro: with-formatter-output ((name &key delimiter stream pretty) &body body)

A macro makes a function with name for body that is a string formatter see make-formatter.
This form returns the result of that formatter

Package

collectors.

Source

collectors.lisp.

Macro: with-mapping-appender ((name fn-args &body fn-body) &body body)

Like a with-appender, but instead of a name we take a function spec

calling the function will appen

(with-mapping-appender (app (l) (mapcar #’(lambda (x) (* 2 x)) l)) (app ’(1 2))
(app ’(2 3))
(app ’(3 4))
(app)) => (2 4 4 6 6 8)

Package

collectors.

Source

collectors.lisp.

Macro: with-mapping-collector ((name fn-args &body fn-body) &body body)

Like a with-collector, but instead of a name we take a function spec

if you call the resultant function with no arguments, you get the collection so far
if you call it with arguments the results of calling your function spec are collected
(with-mapping-collector (col (x) (* 2 x))
(col 1)
(col 2)
(col 3)
(col)) => (2 4 6)

Package

collectors.

Source

collectors.lisp.

Macro: with-reducer ((name function &key initial-value place) &body body)

Locally bind NAME to a reducing function. The arguments FUNCTION and INITIAL-VALUE are passed directly to MAKE-REDUCER.

Package

collectors.

Source

collectors.lisp.

Macro: with-string-builder ((name &key delimiter ignore-empty-strings-and-nil stream) &body body)

A macro that creates a string builder with name in scope during the duration of the env

Package

collectors.

Source

collectors.lisp.

Macro: with-string-builder-output ((name &key delimiter ignore-empty-strings-and-nil stream) &body body)

A macro that creates a string builder with name in scope during the duration of the env, the form returns the string that is built

Package

collectors.

Source

collectors.lisp.


5.1.2 Ordinary functions

Function: make-appender (&key initial-value place-setter)
Package

collectors.

Source

collectors.lisp.

Function: make-collector (&key initial-value collect-nil place-setter)
Package

collectors.

Source

collectors.lisp.

Function: make-formatter (&key delimiter stream pretty)

Create a string formatter collector function.

creates a (lambda &optional format-string &rest args) and collects these in a list When called with no args, returns the concatenated (with delimiter) results

binds *print-pretty* to nil

Package

collectors.

Source

collectors.lisp.

Function: make-pusher (&key initial-value collect-nil place-setter)
Package

collectors.

Source

collectors.lisp.

Function: make-reducer (function &key initial-value place-setter)
Package

collectors.

Source

collectors.lisp.

Function: make-simple-appender (&optional initial-value)

A fastest possible, fewest frills collector suitable to places where efficiency matters that appends any values that re lists

Package

collectors.

Source

collectors.lisp.

Function: make-simple-collector (&optional initial-value)

A fastest possible, fewest frills collector suitable to places where efficiency matters

Package

collectors.

Source

collectors.lisp.

Function: make-string-builder (&key delimiter ignore-empty-strings-and-nil stream)
Package

collectors.

Source

collectors.lisp.


5.1.3 Generic functions

Generic Reader: after-values (condition)
Generic Writer: (setf after-values) (condition)
Package

collectors-signals.

Methods
Reader Method: after-values ((condition done-aggregating))
Writer Method: (setf after-values) ((condition done-aggregating))
Source

collectors.lisp.

Target Slot

after-values.

Generic Reader: aggregate (condition)
Generic Writer: (setf aggregate) (condition)
Package

collectors-signals.

Methods
Reader Method: aggregate ((condition done-aggregating))
Writer Method: (setf aggregate) ((condition done-aggregating))
Source

collectors.lisp.

Target Slot

aggregate.

Generic Reader: aggregator (condition)
Generic Writer: (setf aggregator) (condition)
Package

collectors-signals.

Methods
Reader Method: aggregator ((condition done-aggregating))
Writer Method: (setf aggregator) ((condition done-aggregating))
Source

collectors.lisp.

Target Slot

aggregator.

Reader Method: aggregator ((condition aggregating))
Writer Method: (setf aggregator) ((condition aggregating))
Source

collectors.lisp.

Target Slot

aggregator.

Generic Function: deoperate (aggregator values &key test key)

Undo the aggregation operation of an aggregator and list of values

Package

collectors.

Source

collectors.lisp.

Methods
Method: deoperate ((o list-aggregator) to-remove &key test key)
Method: deoperate :after ((o value-aggregator) values &key test key)
Generic Function: operate (aggregator values)

Perform the aggregation operation on the aggregator for the values

Package

collectors.

Source

collectors.lisp.

Methods
Method: operate ((o string-builder) values)
Method: operate ((o string-formatter) values)
Method: operate ((o appender) values)
Method: operate ((o collector) values)
Method: operate ((o pusher) values)
Method: operate ((o reducer) values)
Method: operate :around ((o value-aggregator) values)
Generic Reader: value (condition)
Package

collectors-signals.

Methods
Reader Method: value ((value-aggregator value-aggregator))

automatically generated reader method

Source

collectors.lisp.

Target Slot

value.

Reader Method: value ((condition aggregating))
Source

collectors.lisp.

Target Slot

value.

Generic Writer: (setf value) (condition)
Package

collectors-signals.

Methods
Writer Method: (setf value) ((value-aggregator value-aggregator))

automatically generated writer method

Source

collectors.lisp.

Target Slot

value.

Writer Method: (setf value) ((condition aggregating))
Source

collectors.lisp.

Target Slot

value.


5.1.4 Standalone methods

Method: initialize-instance :after ((o collector) &key &allow-other-keys)
Source

collectors.lisp.

Method: initialize-instance :after ((o string-formatter) &key &allow-other-keys)
Source

collectors.lisp.

Method: initialize-instance :after ((o value-aggregator) &key &allow-other-keys)
Source

collectors.lisp.


5.1.5 Conditions

Condition: aggregating
Package

collectors-signals.

Source

collectors.lisp.

Direct superclasses

condition.

Direct methods
Direct slots
Slot: value
Initform

(quote nil)

Initargs

:value

Readers

value.

Writers

(setf value).

Slot: aggregator
Initform

(quote nil)

Initargs

:aggregator

Readers

aggregator.

Writers

(setf aggregator).

Condition: done-aggregating
Package

collectors-signals.

Source

collectors.lisp.

Direct superclasses

condition.

Direct methods
Direct slots
Slot: after-values
Initform

(quote nil)

Initargs

:after-values

Readers

after-values.

Writers

(setf after-values).

Slot: aggregate
Initform

(quote nil)

Initargs

:aggregate

Readers

aggregate.

Writers

(setf aggregate).

Slot: aggregator
Initform

(quote nil)

Initargs

:aggregator

Readers

aggregator.

Writers

(setf aggregator).


5.2 Internals


5.2.1 Macros

Macro: append-at-end-with-signals (head-place tail-place values-place aggregator-place post-values-place)

Macros to ease efficient collection (with appending) at the end of a list

Package

collectors.

Source

collectors.lisp.

Macro: collect-at-end-with-signals (head-place tail-place values-place aggregator-place post-values-place)

Macros to ease efficient collection at the end of a list

Package

collectors.

Source

collectors.lisp.

Macro: map-aggregation ((aggregator fn-spec) &body body)
Package

collectors.

Source

collectors.lisp.

Macro: with-alist ((name &key place collect-nil initial-value from-end) &body body)
Package

collectors.

Source

collectors.lisp.

Macro: with-signal-context ((value after-values aggregator) &body body)
Package

collectors.

Source

collectors.lisp.


5.2.2 Ordinary functions

Function: mapping-aggregation-context (body-fn &key aggregator map-fn)
Package

collectors.

Source

collectors.lisp.


5.2.3 Generic functions

Generic Function: %enqueue (o values)
Package

collectors.

Methods
Method: %enqueue ((o collector) values)
Source

collectors.lisp.

Method: %enqueue ((o list-aggregator) values)
Source

collectors.lisp.

Generic Function: %pop-n (o &optional n)
Package

collectors.

Methods
Method: %pop-n ((o list-aggregator) &optional n)
Source

collectors.lisp.

Generic Function: %push (o values)
Package

collectors.

Methods
Method: %push ((o list-aggregator) values)
Source

collectors.lisp.

Generic Function: %unenqueue-n (o &optional n)
Package

collectors.

Methods
Method: %unenqueue-n ((o list-aggregator) &optional n)
Source

collectors.lisp.

Generic Reader: collect-nil? (object)
Generic Writer: (setf collect-nil?) (object)
Package

collectors.

Methods
Reader Method: collect-nil? ((list-aggregator list-aggregator))
Writer Method: (setf collect-nil?) ((list-aggregator list-aggregator))

Should we collect nil into our results

Source

collectors.lisp.

Target Slot

collect-nil?.

Generic Reader: delimiter (object)
Package

collectors.

Methods
Reader Method: delimiter ((string-formatter string-formatter))

automatically generated reader method

Source

collectors.lisp.

Target Slot

delimiter.

Generic Writer: (setf delimiter) (object)
Package

collectors.

Methods
Writer Method: (setf delimiter) ((string-formatter string-formatter))

automatically generated writer method

Source

collectors.lisp.

Target Slot

delimiter.

Generic Reader: has-written? (object)
Package

collectors.

Methods
Reader Method: has-written? ((string-formatter string-formatter))

automatically generated reader method

Source

collectors.lisp.

Target Slot

has-written?.

Generic Writer: (setf has-written?) (object)
Package

collectors.

Methods
Writer Method: (setf has-written?) ((string-formatter string-formatter))

automatically generated writer method

Source

collectors.lisp.

Target Slot

has-written?.

Generic Reader: ignore-empty-strings-and-nil? (object)
Package

collectors.

Methods
Reader Method: ignore-empty-strings-and-nil? ((string-builder string-builder))

automatically generated reader method

Source

collectors.lisp.

Target Slot

ignore-empty-strings-and-nil?.

Generic Writer: (setf ignore-empty-strings-and-nil?) (object)
Package

collectors.

Methods
Writer Method: (setf ignore-empty-strings-and-nil?) ((string-builder string-builder))

automatically generated writer method

Source

collectors.lisp.

Target Slot

ignore-empty-strings-and-nil?.

Generic Reader: initial-value (object)
Package

collectors.

Methods
Reader Method: initial-value ((value-aggregator value-aggregator))

automatically generated reader method

Source

collectors.lisp.

Target Slot

initial-value.

Generic Writer: (setf initial-value) (object)
Package

collectors.

Methods
Writer Method: (setf initial-value) ((value-aggregator value-aggregator))

automatically generated writer method

Source

collectors.lisp.

Target Slot

initial-value.

Generic Reader: new-only-key (object)
Package

collectors.

Methods
Reader Method: new-only-key ((list-aggregator list-aggregator))

automatically generated reader method

Source

collectors.lisp.

Target Slot

new-only-key.

Generic Writer: (setf new-only-key) (object)
Package

collectors.

Methods
Writer Method: (setf new-only-key) ((list-aggregator list-aggregator))

automatically generated writer method

Source

collectors.lisp.

Target Slot

new-only-key.

Generic Reader: new-only-test (object)
Generic Writer: (setf new-only-test) (object)
Package

collectors.

Methods
Reader Method: new-only-test ((list-aggregator list-aggregator))
Writer Method: (setf new-only-test) ((list-aggregator list-aggregator))

If supplied with a new-only-test, we will verify that we
have not already collected this item before collecting again

Source

collectors.lisp.

Target Slot

new-only-test.

Generic Reader: operation (object)
Package

collectors.

Methods
Reader Method: operation ((reducer reducer))

automatically generated reader method

Source

collectors.lisp.

Target Slot

operation.

Generic Writer: (setf operation) (object)
Package

collectors.

Methods
Writer Method: (setf operation) ((reducer reducer))

automatically generated writer method

Source

collectors.lisp.

Target Slot

operation.

Generic Reader: output-stream (object)
Package

collectors.

Methods
Reader Method: output-stream ((string-formatter string-formatter))

automatically generated reader method

Source

collectors.lisp.

Target Slot

output-stream.

Generic Writer: (setf output-stream) (object)
Package

collectors.

Methods
Writer Method: (setf output-stream) ((string-formatter string-formatter))

automatically generated writer method

Source

collectors.lisp.

Target Slot

output-stream.

Generic Reader: place-setter (object)
Package

collectors.

Methods
Reader Method: place-setter ((value-aggregator value-aggregator))

automatically generated reader method

Source

collectors.lisp.

Target Slot

place-setter.

Generic Writer: (setf place-setter) (object)
Package

collectors.

Methods
Writer Method: (setf place-setter) ((value-aggregator value-aggregator))

automatically generated writer method

Source

collectors.lisp.

Target Slot

place-setter.

Generic Reader: pretty? (object)
Package

collectors.

Methods
Reader Method: pretty? ((string-formatter string-formatter))

automatically generated reader method

Source

collectors.lisp.

Target Slot

pretty?.

Generic Writer: (setf pretty?) (object)
Package

collectors.

Methods
Writer Method: (setf pretty?) ((string-formatter string-formatter))

automatically generated writer method

Source

collectors.lisp.

Target Slot

pretty?.

Generic Function: should-aggregate? (aggregator value)

Should we aggregate a given value into our collection

Package

collectors.

Source

collectors.lisp.

Methods
Method: should-aggregate? ((o string-builder) v)
Method: should-aggregate? ((o list-aggregator) v)
Method: should-aggregate? ((o value-aggregator) v)
Generic Reader: tail (object)
Package

collectors.

Methods
Reader Method: tail ((collector collector))

automatically generated reader method

Source

collectors.lisp.

Target Slot

tail.

Generic Writer: (setf tail) (object)
Package

collectors.

Methods
Writer Method: (setf tail) ((collector collector))

automatically generated writer method

Source

collectors.lisp.

Target Slot

tail.


5.2.4 Classes

Class: appender

Create an appender function.

An Appender will append any arguments into a list, all the values passed to it in the order in which they were passed. If the appender function is called without arguments it returns the current list of values.

Package

collectors.

Source

collectors.lisp.

Direct superclasses

collector.

Direct methods

operate.

Class: collector

Create a collector function.
A Collector function will collect, into a list, all the values passed to it in the order in which they were passed. If the callector function is called without arguments it returns the current list of values.

Package

collectors.

Source

collectors.lisp.

Direct superclasses

list-aggregator.

Direct subclasses

appender.

Direct methods
Direct slots
Slot: tail
Initargs

:tail

Readers

tail.

Writers

(setf tail).

Class: list-aggregator
Package

collectors.

Source

collectors.lisp.

Direct superclasses

value-aggregator.

Direct subclasses
Direct methods
Direct slots
Slot: collect-nil?

Should we collect nil into our results

Initform

t

Initargs

:collect-nil?

Readers

collect-nil?.

Writers

(setf collect-nil?).

Slot: new-only-test

If supplied with a new-only-test, we will verify that we
have not already collected this item before collecting again

Initargs

:new-only-test

Readers

new-only-test.

Writers

(setf new-only-test).

Slot: new-only-key
Initargs

:new-only-key

Readers

new-only-key.

Writers

(setf new-only-key).

Class: pusher
Package

collectors.

Source

collectors.lisp.

Direct superclasses

list-aggregator.

Direct methods

operate.

Class: reducer

Create a function which, starting with INITIAL-VALUE, reduces any other values into a single final value.

OPERATION will be called with two values: the current value and the new value, in that order. OPERATION should return exactly one value.

The reducing function can be called with n arguments which will be applied to OPERATION one after the other (left to right) and will return the new value.

If the reducing function is called with no arguments it will return the current value.

Example:

(setf r (make-reducer #’+ 5))
(funcall r 0) => 5
(funcall r 1 2) => 8
(funcall r) => 8

Package

collectors.

Source

collectors.lisp.

Direct superclasses

value-aggregator.

Direct methods
Direct slots
Slot: operation
Initargs

:operation

Readers

operation.

Writers

(setf operation).

Class: string-builder

Create a function that will build up a string for you
Each call to the function with arguments appends those arguments to the string with an optional delimiter between them.

if ignore-empty-strings-and-nil is true neither empty strings nor nil will be printed to the stream

A call to the function with no arguments returns the output string

Package

collectors.

Source

collectors.lisp.

Direct superclasses

string-formatter.

Direct methods
Direct slots
Slot: ignore-empty-strings-and-nil?
Initform

t

Initargs

:ignore-empty-strings-and-nil?

Readers

ignore-empty-strings-and-nil?.

Writers

(setf ignore-empty-strings-and-nil?).

Class: string-formatter

Create a string formatter collector function.

creates a (lambda &optional format-string &rest args) and collects these in a list When called with no args, returns the concatenated (with delimiter) results

binds *print-pretty* to nil

Package

collectors.

Source

collectors.lisp.

Direct superclasses

value-aggregator.

Direct subclasses

string-builder.

Direct methods
Direct slots
Slot: delimiter
Initargs

:delimiter

Readers

delimiter.

Writers

(setf delimiter).

Slot: has-written?
Initargs

:has-written?

Readers

has-written?.

Writers

(setf has-written?).

Slot: output-stream
Initargs

:output-stream

Readers

output-stream.

Writers

(setf output-stream).

Slot: pretty?
Initargs

:pretty?

Readers

pretty?.

Writers

(setf pretty?).

Class: value-aggregator
Package

collectors.

Source

collectors.lisp.

Direct superclasses

funcallable-standard-object.

Direct subclasses
Direct methods
Direct slots
Slot: initial-value
Initargs

:initial-value

Readers

initial-value.

Writers

(setf initial-value).

Slot: place-setter
Initargs

:place-setter

Readers

place-setter.

Writers

(setf place-setter).

Slot: value
Package

collectors-signals.

Initargs

:value

Readers

value.

Writers

(setf value).


Appendix A Indexes


A.1 Concepts


A.2 Functions

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

%
%enqueue: Private generic functions
%enqueue: Private generic functions
%enqueue: Private generic functions
%pop-n: Private generic functions
%pop-n: Private generic functions
%push: Private generic functions
%push: Private generic functions
%unenqueue-n: Private generic functions
%unenqueue-n: Private generic functions

(
(setf after-values): Public generic functions
(setf after-values): Public generic functions
(setf aggregate): Public generic functions
(setf aggregate): Public generic functions
(setf aggregator): Public generic functions
(setf aggregator): Public generic functions
(setf aggregator): Public generic functions
(setf collect-nil?): Private generic functions
(setf collect-nil?): Private generic functions
(setf delimiter): Private generic functions
(setf delimiter): Private generic functions
(setf has-written?): Private generic functions
(setf has-written?): Private generic functions
(setf ignore-empty-strings-and-nil?): Private generic functions
(setf ignore-empty-strings-and-nil?): Private generic functions
(setf initial-value): Private generic functions
(setf initial-value): Private generic functions
(setf new-only-key): Private generic functions
(setf new-only-key): Private generic functions
(setf new-only-test): Private generic functions
(setf new-only-test): Private generic functions
(setf operation): Private generic functions
(setf operation): Private generic functions
(setf output-stream): Private generic functions
(setf output-stream): Private generic functions
(setf place-setter): Private generic functions
(setf place-setter): Private generic functions
(setf pretty?): Private generic functions
(setf pretty?): Private generic functions
(setf tail): Private generic functions
(setf tail): Private generic functions
(setf value): Public generic functions
(setf value): Public generic functions
(setf value): Public generic functions

A
after-values: Public generic functions
after-values: Public generic functions
aggregate: Public generic functions
aggregate: Public generic functions
aggregator: Public generic functions
aggregator: Public generic functions
aggregator: Public generic functions
append-at-end: Public macros
append-at-end-with-signals: Private macros
appending: Public macros

C
collect-at-end: Public macros
collect-at-end-with-signals: Private macros
collect-nil?: Private generic functions
collect-nil?: Private generic functions
collecting: Public macros

D
delimiter: Private generic functions
delimiter: Private generic functions
deoperate: Public generic functions
deoperate: Public generic functions
deoperate: Public generic functions

F
Function, make-appender: Public ordinary functions
Function, make-collector: Public ordinary functions
Function, make-formatter: Public ordinary functions
Function, make-pusher: Public ordinary functions
Function, make-reducer: Public ordinary functions
Function, make-simple-appender: Public ordinary functions
Function, make-simple-collector: Public ordinary functions
Function, make-string-builder: Public ordinary functions
Function, mapping-aggregation-context: Private ordinary functions

G
Generic Function, %enqueue: Private generic functions
Generic Function, %pop-n: Private generic functions
Generic Function, %push: Private generic functions
Generic Function, %unenqueue-n: Private generic functions
Generic Function, (setf after-values): Public generic functions
Generic Function, (setf aggregate): Public generic functions
Generic Function, (setf aggregator): Public generic functions
Generic Function, (setf collect-nil?): Private generic functions
Generic Function, (setf delimiter): Private generic functions
Generic Function, (setf has-written?): Private generic functions
Generic Function, (setf ignore-empty-strings-and-nil?): Private generic functions
Generic Function, (setf initial-value): Private generic functions
Generic Function, (setf new-only-key): Private generic functions
Generic Function, (setf new-only-test): Private generic functions
Generic Function, (setf operation): Private generic functions
Generic Function, (setf output-stream): Private generic functions
Generic Function, (setf place-setter): Private generic functions
Generic Function, (setf pretty?): Private generic functions
Generic Function, (setf tail): Private generic functions
Generic Function, (setf value): Public generic functions
Generic Function, after-values: Public generic functions
Generic Function, aggregate: Public generic functions
Generic Function, aggregator: Public generic functions
Generic Function, collect-nil?: Private generic functions
Generic Function, delimiter: Private generic functions
Generic Function, deoperate: Public generic functions
Generic Function, has-written?: Private generic functions
Generic Function, ignore-empty-strings-and-nil?: Private generic functions
Generic Function, initial-value: Private generic functions
Generic Function, new-only-key: Private generic functions
Generic Function, new-only-test: Private generic functions
Generic Function, operate: Public generic functions
Generic Function, operation: Private generic functions
Generic Function, output-stream: Private generic functions
Generic Function, place-setter: Private generic functions
Generic Function, pretty?: Private generic functions
Generic Function, should-aggregate?: Private generic functions
Generic Function, tail: Private generic functions
Generic Function, value: Public generic functions

H
has-written?: Private generic functions
has-written?: Private generic functions

I
ignore-empty-strings-and-nil?: Private generic functions
ignore-empty-strings-and-nil?: Private generic functions
initial-value: Private generic functions
initial-value: Private generic functions
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods

M
Macro, append-at-end: Public macros
Macro, append-at-end-with-signals: Private macros
Macro, appending: Public macros
Macro, collect-at-end: Public macros
Macro, collect-at-end-with-signals: Private macros
Macro, collecting: Public macros
Macro, make-simple-appender-to-place: Public macros
Macro, make-simple-collector-to-place: Public macros
Macro, map-aggregation: Private macros
Macro, with-alist: Private macros
Macro, with-alist-output: Public macros
Macro, with-appender: Public macros
Macro, with-appender-output: Public macros
Macro, with-collector: Public macros
Macro, with-collector-output: Public macros
Macro, with-collectors: Public macros
Macro, with-formatter: Public macros
Macro, with-formatter-output: Public macros
Macro, with-mapping-appender: Public macros
Macro, with-mapping-collector: Public macros
Macro, with-reducer: Public macros
Macro, with-signal-context: Private macros
Macro, with-string-builder: Public macros
Macro, with-string-builder-output: Public macros
make-appender: Public ordinary functions
make-collector: Public ordinary functions
make-formatter: Public ordinary functions
make-pusher: Public ordinary functions
make-reducer: Public ordinary functions
make-simple-appender: Public ordinary functions
make-simple-appender-to-place: Public macros
make-simple-collector: Public ordinary functions
make-simple-collector-to-place: Public macros
make-string-builder: Public ordinary functions
map-aggregation: Private macros
mapping-aggregation-context: Private ordinary functions
Method, %enqueue: Private generic functions
Method, %enqueue: Private generic functions
Method, %pop-n: Private generic functions
Method, %push: Private generic functions
Method, %unenqueue-n: Private generic functions
Method, (setf after-values): Public generic functions
Method, (setf aggregate): Public generic functions
Method, (setf aggregator): Public generic functions
Method, (setf aggregator): Public generic functions
Method, (setf collect-nil?): Private generic functions
Method, (setf delimiter): Private generic functions
Method, (setf has-written?): Private generic functions
Method, (setf ignore-empty-strings-and-nil?): Private generic functions
Method, (setf initial-value): Private generic functions
Method, (setf new-only-key): Private generic functions
Method, (setf new-only-test): Private generic functions
Method, (setf operation): Private generic functions
Method, (setf output-stream): Private generic functions
Method, (setf place-setter): Private generic functions
Method, (setf pretty?): Private generic functions
Method, (setf tail): Private generic functions
Method, (setf value): Public generic functions
Method, (setf value): Public generic functions
Method, after-values: Public generic functions
Method, aggregate: Public generic functions
Method, aggregator: Public generic functions
Method, aggregator: Public generic functions
Method, collect-nil?: Private generic functions
Method, delimiter: Private generic functions
Method, deoperate: Public generic functions
Method, deoperate: Public generic functions
Method, has-written?: Private generic functions
Method, ignore-empty-strings-and-nil?: Private generic functions
Method, initial-value: Private generic functions
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, new-only-key: Private generic functions
Method, new-only-test: Private generic functions
Method, operate: Public generic functions
Method, operate: Public generic functions
Method, operate: Public generic functions
Method, operate: Public generic functions
Method, operate: Public generic functions
Method, operate: Public generic functions
Method, operate: Public generic functions
Method, operation: Private generic functions
Method, output-stream: Private generic functions
Method, place-setter: Private generic functions
Method, pretty?: Private generic functions
Method, should-aggregate?: Private generic functions
Method, should-aggregate?: Private generic functions
Method, should-aggregate?: Private generic functions
Method, tail: Private generic functions
Method, value: Public generic functions
Method, value: Public generic functions

N
new-only-key: Private generic functions
new-only-key: Private generic functions
new-only-test: Private generic functions
new-only-test: Private generic functions

O
operate: Public generic functions
operate: Public generic functions
operate: Public generic functions
operate: Public generic functions
operate: Public generic functions
operate: Public generic functions
operate: Public generic functions
operate: Public generic functions
operation: Private generic functions
operation: Private generic functions
output-stream: Private generic functions
output-stream: Private generic functions

P
place-setter: Private generic functions
place-setter: Private generic functions
pretty?: Private generic functions
pretty?: Private generic functions

S
should-aggregate?: Private generic functions
should-aggregate?: Private generic functions
should-aggregate?: Private generic functions
should-aggregate?: Private generic functions

T
tail: Private generic functions
tail: Private generic functions

V
value: Public generic functions
value: Public generic functions
value: Public generic functions

W
with-alist: Private macros
with-alist-output: Public macros
with-appender: Public macros
with-appender-output: Public macros
with-collector: Public macros
with-collector-output: Public macros
with-collectors: Public macros
with-formatter: Public macros
with-formatter-output: Public macros
with-mapping-appender: Public macros
with-mapping-collector: Public macros
with-reducer: Public macros
with-signal-context: Private macros
with-string-builder: Public macros
with-string-builder-output: Public macros