The colliflower Reference Manual

This is the colliflower Reference Manual, version 0.2.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Sep 15 04:50:10 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 colliflower

Generic interfaces for collections and iterators.

Author

Thayne McCombs <>

License

MIT

Version

0.2.1

Defsystem Dependency

asdf-package-system (system).

Dependencies
Source

colliflower.asd.


2.2 liter

Collection of tools for basic iterators

Author

Thayne McCombs <>

License

MIT

Version

0.2.0

Dependency

liter/interface (system).

Source

liter.asd.


2.3 liter/interface

Author

Thayne McCombs <>

License

MIT

Dependencies
Source

liter.asd.


2.4 liter/base

Author

Thayne McCombs <>

License

MIT

Dependencies
  • iterate (system).
  • serapeum (system).
Source

liter.asd.


2.5 liter/generate

Author

Thayne McCombs <>

License

MIT

Dependencies
Source

liter.asd.


2.6 liter/tools

Author

Thayne McCombs <>

License

MIT

Dependencies
Source

liter.asd.


2.7 liter/iter-object

Author

Thayne McCombs <>

License

MIT

Dependency

closer-mop (system).

Source

liter.asd.


2.8 liter/file

Author

Thayne McCombs <>

License

MIT

Dependencies
Source

liter.asd.


2.9 garten

Generic interface for "growing" data structures/collections.

Author

<>

Version

0.1.0

Dependency

garten/interface (system).

Source

garten.asd.


2.10 garten/interface

Author

<>

Dependencies
Source

garten.asd.


2.11 garten/base

Author

<>

Dependencies
Source

garten.asd.


2.12 garten/grower

Author

<>

Dependencies
Source

garten.asd.


2.13 garten/list

Author

<>

Dependencies
Source

garten.asd.


2.14 garten/tools

Author

<>

Dependencies
Source

garten.asd.


2.15 colliflower/interface

Author

Thayne McCombs <>

License

MIT

Dependencies
Source

colliflower.asd.


2.16 silo

Generic getters and setters for data structures.

Author

<>

License

MIT

Version

0.2.0

Dependency

silo/interface (system).

Source

silo.asd.


2.17 silo/interface

Author

<>

License

MIT

Dependencies
Source

silo.asd.


2.18 silo/protocol

Author

<>

License

MIT

Source

silo.asd.


2.19 silo/base

Author

<>

License

MIT

Dependency

silo/protocol (system).

Source

silo.asd.


2.20 colliflower/ext

Author

Thayne McCombs <>

License

MIT

Dependencies
Source

colliflower.asd.


3 Files

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


3.1 Lisp


3.1.1 colliflower/colliflower.asd

Source

colliflower.asd.

Parent Component

colliflower (system).

ASDF Systems

3.1.2 liter/liter.asd

Source

liter.asd.

Parent Component

liter (system).

ASDF Systems

3.1.3 garten/garten.asd

Source

garten.asd.

Parent Component

garten (system).

ASDF Systems

3.1.4 silo/silo.asd

Source

silo.asd.

Parent Component

silo (system).

ASDF Systems

3.1.5 liter/interface/file-type.lisp

Source

liter.asd.

Parent Component

liter/interface (system).

Packages

liter/interface.


3.1.6 liter/base/file-type.lisp

Source

liter.asd.

Parent Component

liter/base (system).

Packages

liter/base.

Public Interface
Internals

3.1.7 liter/generate/file-type.lisp

Source

liter.asd.

Parent Component

liter/generate (system).

Packages

liter/generate.

Public Interface
Internals

ilist (function).


3.1.8 liter/tools/file-type.lisp

Source

liter.asd.

Parent Component

liter/tools (system).

Packages

liter/tools.

Public Interface

3.1.9 liter/iter-object/file-type.lisp

Source

liter.asd.

Parent Component

liter/iter-object (system).

Packages

liter/iter-object.

Public Interface

3.1.10 liter/file/file-type.lisp

Source

liter.asd.

Parent Component

liter/file (system).

Packages

liter/file.

Public Interface
Internals

3.1.11 garten/interface/file-type.lisp

Source

garten.asd.

Parent Component

garten/interface (system).

Packages

garten/interface.


3.1.12 garten/base/file-type.lisp

Source

garten.asd.

Parent Component

garten/base (system).

Packages

garten/base.

Public Interface
Internals

*default-grower-size* (special variable).


3.1.13 garten/grower/file-type.lisp

Source

garten.asd.

Parent Component

garten/grower (system).

Packages

garten/grower.

Public Interface

3.1.14 garten/list/file-type.lisp

Source

garten.asd.

Parent Component

garten/list (system).

Packages

garten/list.

Public Interface
Internals

3.1.15 garten/tools/file-type.lisp

Source

garten.asd.

Parent Component

garten/tools (system).

Packages

garten/tools.

Public Interface

with-grower (macro).

Internals

clause-growing-from-3 (macro).


3.1.16 colliflower/interface/file-type.lisp

Source

colliflower.asd.

Parent Component

colliflower/interface (system).

Packages

colliflower/interface.


3.1.17 silo/interface/file-type.lisp

Source

silo.asd.

Parent Component

silo/interface (system).

Packages

silo/interface.


3.1.18 silo/protocol/file-type.lisp

Source

silo.asd.

Parent Component

silo/protocol (system).

Packages

silo/protocol.

Public Interface

3.1.19 silo/base/file-type.lisp

Source

silo.asd.

Parent Component

silo/base (system).

Packages

silo/base.

Public Interface
Internals

3.1.20 colliflower/ext/file-type.lisp

Source

colliflower.asd.

Parent Component

colliflower/ext (system).

Packages

colliflower/ext.

Public Interface

grow-from-iterable (function).


4 Packages

Packages are listed by definition order.


4.1 liter/tools

Source

file-type.lisp.

Use List
Used By List

liter/interface.

Public Interface

4.2 silo/protocol

Source

file-type.lisp.

Use List

common-lisp.

Used By List
Public Interface

4.3 garten/tools

Source

file-type.lisp.

Use List
Used By List

garten/interface.

Public Interface

with-grower (macro).

Internals

clause-growing-from-3 (macro).


4.4 liter/interface

Liter is a collection of tools to work with basic iterators.

An iterator in Liter is just a function (usually a closure) which returns
the next value in the iterable, and signals a ITERATION-ENDED condition
if there are no more values. It should follow the following rules:

* An iterator MAY be called with optional, keyword, or rest arguments, but MUST function correctly if called with no arguments.
* If an iterator has completed, it SHOULD signal an ITERATION-ENDED condition, typically using END-ITERATION.
* Once an iterator signals an ITERATION-ENDED condition, it SHOULD signal an ITERATION-ENDED condition on each future call, unless something changes the state of the iterator so that it can continue iterating.
* Client code SHOULD handle any ITERATION-ENDED condition, or use a function or macro that does (such as the iterate drivers, DO-ITERATOR, etc).
* Additional return values may be ignored by the caller of an iterator.
* By convention, key-value pairs SHOULD be represented as a cons pair. (as in alists)
* An iterator MAY be infinite, but not all liter functions can be safely used with such iterators. Functions such as ITAKE can be used to convert an infinite iterator to a finite one.

An iterable is any object for which there is a method defined for GET-ITERATOR.
Most liter function accept an iterable, and will get an iterator using GET-ITERATOR.
There is a GET-ITERATOR method defined for iterators that is equivalent to the identity function, so iterators can be passed to these functions.

Source

file-type.lisp.

Nicknames
  • liter
  • iterator
Use List
Used By List

4.5 liter/iter-object

Source

file-type.lisp.

Nickname

liter-object

Use List

common-lisp.

Used By List
Public Interface

4.6 liter/file

Source

file-type.lisp.

Use List
Used By List

liter/interface.

Public Interface
Internals

4.7 liter/base

Source

file-type.lisp.

Use List
  • common-lisp.
  • iterate.
Used By List
Public Interface
Internals

4.8 liter/generate

Source

file-type.lisp.

Use List
Used By List
Public Interface
Internals

ilist (function).


4.9 garten/base

Source

file-type.lisp.

Use List
Used By List

garten/interface.

Internals

*default-grower-size* (special variable).


4.10 colliflower/interface

Combination of the LITER, SILO, and GARTEN packages.

Source

file-type.lisp.

Nicknames
  • colliflower
  • cf
Use List

4.11 garten/list

Source

file-type.lisp.

Use List
Used By List

garten/base.

Public Interface
Internals

4.12 garten/grower

Source

file-type.lisp.

Use List
Used By List
Public Interface

4.13 silo/interface

Source

file-type.lisp.

Nicknames
  • silo
  • s
Use List
Used By List

4.14 silo/base

Source

file-type.lisp.

Use List
Used By List

silo/interface.

Public Interface
Internals

4.15 colliflower/ext

Extra utitilies that combine liter, garten, and/or silo

Source

file-type.lisp.

Use List
Used By List

colliflower/interface.

Public Interface

grow-from-iterable (function).


4.16 garten/interface

Garten is a library that provides a generic interface to build collections.

Source

file-type.lisp.

Nicknames
  • garten
  • grow
Use List
Used By List

5 Definitions

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


5.1 Public Interface


5.1.1 Macros

Macro: define-sgetter (lambda-list place-expr &key declarations documentation)

Define SGET and (SETF SGET) for a place to use sget with.

Package

silo/protocol.

Source

file-type.lisp.

Macro: do-iterable ((var iterable &optional return) &body body)

Loop over all items in the iterable ITERABLE, in a manner similar to dolist.

Package

liter/base.

Source

file-type.lisp.

Macro: do-iterator ((var iterator &optional return) &body body)

A DO macro in the style of dolist that executes body for each item in ITERATOR.

Package

liter/base.

Source

file-type.lisp.

Macro: make-iterator (&body body)

Create an iterator that executes BODY each time.

Basically a simple wrapper for LAMBDA. Iteration can be ended by calling END-ITERATION.

Package

liter/generate.

Source

file-type.lisp.

Macro: make-state-iterator* (initial-state (&rest lambda-list) &body body)

Macro form of MAKE-STATE-ITERATOR. Note that in this form INITIAL-STATE is required.

Package

liter/generate.

Source

file-type.lisp.

Macro: rget (object &rest keys)

Recursive get. Calls sget for each key in turn from left to right.

As long as (SETF SGET) is defined for the final result, RGET is setfable.

Package

silo/protocol.

Source

file-type.lisp.

Macro: ssetf (place key value &rest key-args)

Modify macro that sets a place equal to the result of SUPDATE.

Package

silo/protocol.

Source

file-type.lisp.

Macro: with-file-iterator ((var filename &key reader element-type if-does-not-exist external-format) &body body)

Macro similar to WITH-OPEN-FILE, but VAR is bound to a file iterator instead of a STREAM. The result is guaranteed to be an actual iterator, even if closer-mop isn’t enabled.

Package

liter/file.

Source

file-type.lisp.

Macro: with-grower ((feeder type &rest args) &body body)

Execute BODY where FEEDER is a function that takes a single argument, which is added to the resulting data structure.
TYPE is the type of the structure to create. And ARGS are passed through to MAKE-GROWER.

WITH-GROWER returns the result (fruit) of the grower.

Package

garten/tools.

Source

file-type.lisp.


5.1.2 Compiler macros

Compiler Macro: irepeat (v &optional n)
Package

liter/generate.

Source

file-type.lisp.


5.1.3 Setf expanders

Setf Expander: (setf slocation) (place key &rest args)

SETF expander that uses SUPDATE to compute the new value to store in PLACE.

PLACE must be a SETFable place, and since this uses SUPDATE, it is safe for operations that don’t mutate PLACE directly (such as prepending to a list).

Package

silo/protocol.

Source

file-type.lisp.


5.1.4 Ordinary functions

Function: alist-key (item &key key test)

Create a key to access values in alists with sget

Package

silo/base.

Source

file-type.lisp.

Function: end-iteration ()

Convenience function to return values for an iterator that has reached the end.

Package

liter/base.

Source

file-type.lisp.

Function: feed* (grower &rest items)

Var-arg form of feed. Add multiple items at once.

Package

garten/grower.

Source

file-type.lisp.

Function: grow-from-iterable (iterable type &rest type-args)

Create a growable of type TYPE from an iterable.

TYPE-ARGS are additional arguments to pass to MAKE-GROWER after the type.

Package

colliflower/ext.

Source

file-type.lisp.

Function: iaccumulate (iterable &optional op)

Return an iterator that accumulates the results of appling OP to the previous result and the current item.

IACCUMULATE is like IFOLD that keeps track of intermediary results.

Package

liter/tools.

Source

file-type.lisp.

Function: ichain (first &rest rest)

Return a new iterator that iterates through each of the iterables passed to it in series.

Package

liter/tools.

Source

file-type.lisp.

Function: icounter (&key from by to)

Create an iterator that just counts up from FROM by amount BY forever.
The returned iterator takes an optional argument which resets the counter if true.

If a TO parameter is provided, then the counter will stop when the value returned would equal the TO parameter. Note that if using a BY parameter it is possible to step over the TO end-point, but a >= comparison is undesirable because it wouldn’t work for a negative step.

Package

liter/generate.

Source

file-type.lisp.

Function: icycle (iterable)

Create an iterator that iterates through ITERABLE, and then cycles through the values again.
This stores the results of iterating over ITERABLE.

Package

liter/generate.

Source

file-type.lisp.

Function: icycle* (&rest args)

Create an iterator that cycles through the arguments passed to it.

Package

liter/generate.

Source

file-type.lisp.

Function: idrop (iterable n)

Return an iterator over the elements of iterable after dropping the first n.

Package

liter/tools.

Source

file-type.lisp.

Function: idrop-while (iterable pred)

Return an iterator over the elements of iterable that drops the initial elements while PRED returns false for them. This is the inverse of ITAKE-WHILE.

Package

liter/tools.

Source

file-type.lisp.

Function: ifilter (iterable predicate)

Return a new iterator that iterates over the values of ITERABLE for which PREDICATE is true.

Package

liter/tools.

Source

file-type.lisp.

Function: ifold (iterable op &optional initial)

Fold over an iterable.
ITERABLE is the iterable to fold over.
OP is a binary operation that takes the accumulated result, and an iterated item and returns a new accumulated result.
INITIAL is the initial accumulated state.

Package

liter/tools.

Source

file-type.lisp.

Function: inext (iterator &rest args)

Return the next value of an iterator and whether or not an actual value was retrieved as values.

Any additional arguments are passed through to the iterator function.

Package

liter/base.

Source

file-type.lisp.

Function: irepeat (v &optional n)

Create an iterator that returns the value V N times.
If N is negative (the default) iterate forever.

Note that CONSTANTLY is equivalent to IREPEAT with a negative N,
and in fact there is a compiler macro that compiles IREPEAT as CONSTANTLY in that case.

Package

liter/generate.

Source

file-type.lisp.

Function: itake (iterable n)

Take the first N elements of iterable. Returns an iterator.

Package

liter/tools.

Source

file-type.lisp.

Function: itake-while (iterable pred)

Return an iterator that returns elements from ITERABLE as long as PRED returns true when passed the value. Not that this will consume the first item where PRED returns nil and not return it.

Package

liter/tools.

Source

file-type.lisp.

Function: itee (iterable &optional n)

Split a single iterable into N iterators.
The iterators are returned as values.
Note that ITEE depends on the iterator of iterable signaling an END-ITERATION if the iterator has ended, even if an END-ITERATION has already been signaled.

Package

liter/tools.

Source

file-type.lisp.

Function: iterator-list (iterator)

Create a list from an iterator. Note that this will only work if the iterator terminates.

Package

liter/base.

Source

file-type.lisp.

Function: itransform (iterable map-fun)

Return an iterator that iterates over transformed values of an iterable.

ITERABLE is on object for which GET-ITERATOR is defined.
MAP-FUN is a function which is called with each value returned by the iterator and returns the value that the new iterator should return.

Package

liter/tools.

Source

file-type.lisp.

Function: izip (&rest iterables)

Zip iterables together.

This returns an iterator that returns a list of the results of getting the next value from each iterable. The iterator ends when the shortest of the iterables ends.

Package

liter/tools.

Source

file-type.lisp.

Function: izip-longest (missing-value &rest iterables)

Like IZIP but stops on the longest iterable.
When a shorter iterable ends, it will continually return MISSING-VALUE until the whole iterator ends.

Package

liter/tools.

Source

file-type.lisp.

Function: izip-with-index (iterable)

Zip an iterable with an index.

Each element of the new iterator is a list of the index (starting with 0) and the next element of ITERABLE.

Package

liter/tools.

Source

file-type.lisp.

Function: make-byte-stream-iterator (stream)

Get an iterator for a binary input stream.

Package

liter/base.

Source

file-type.lisp.

Function: make-character-stream-iterator (stream)

Get an iterator for a character input stream

Package

liter/base.

Source

file-type.lisp.

Function: make-file-iterator (filename &key reader element-type if-does-not-exist external-format)

Create a FILE-ITERATOR using the same arguments as OPEN. In fact this is basically like OPEN, but
returns a FILE-ITERATOR instead of a stream.

If a reader function is supplied, then that function is used to read elements from the file. So for example, #’read-line can be used for the iterator to return lines at a time. The reader function takes an input stream as an argument.

By default READ-CHAR is used for a character stream and READ-BYTE is used for binary streams.

Package

liter/file.

Source

file-type.lisp.

Function: make-hash-key-iterator (h)

Get an iterator over the keys of H.

Package

liter/base.

Source

file-type.lisp.

Function: make-hash-value-iterator (h)

Get an iterator over the values of H.

Package

liter/base.

Source

file-type.lisp.

Function: make-line-iterator (stream)

Get an iterator that iterates over lines in a character stream.

Package

liter/base.

Source

file-type.lisp.

Function: make-state-iterator (state-machine &optional initial)

Create an iterator that starts with an initial state INITIAL and on each call to the iterator STATE-MACHINE is called with the previous state as the first argument followed by any arguments passed to the iterator function. The return value is then stored and used for the next iteration.

Note that STATE-MACHINE will be called on the first iteration with INITIAL as the state.

This can be used to create simple state machines.

Package

liter/generate.

Source

file-type.lisp.

Function: plist-key (key-item)

Create a key to access an item in a plist

Package

silo/base.

Source

file-type.lisp.

Function: rget-apply (object &rest keys+)

A combination of RGET and APPLY. It repeatedly calls SGET on successive results for each key, and the last argument is a list of keys to use.

Package

silo/protocol.

Source

file-type.lisp.

Function: singleton-iterator (element)

Create an iterator that returns element on the first iteration, and ends on the second.

Equivalent to ‘(irepeat element 1)‘.

Package

liter/generate.

Source

file-type.lisp.


5.1.5 Generic functions

Generic Function: contains-p (container element)

Test if a container contains an element or key.
The exact semantics of whether or not a container contains an element depend on the container.

Package

silo/protocol.

Source

file-type.lisp.

Methods
Method: contains-p ((alist list) (key %alist-ref))
Source

file-type.lisp.

Method: contains-p ((plist list) (key %plist-ref))
Source

file-type.lisp.

Method: contains-p ((container list) element)
Source

file-type.lisp.

Method: contains-p ((container vector) element)
Source

file-type.lisp.

Method: contains-p ((table hash-table) key)
Source

file-type.lisp.

Method: contains-p ((object standard-object) key)
Source

file-type.lisp.

Generic Function: feed (grower item)

Add an item to the collection. If the collection needs a key-value
pair, ITEM should be a CONS cell with the key as the CAR and the value as the CDR.

Package

garten/grower.

Source

file-type.lisp.

Methods
Method: feed ((grower hash-table) (item cons))
Source

file-type.lisp.

Method: feed ((grower stream) (item sequence))
Source

file-type.lisp.

Method: feed ((grower stream) (item integer))
Source

file-type.lisp.

Method: feed ((grower stream) (item character))
Source

file-type.lisp.

Method: feed ((grower stream) (item string))
Source

file-type.lisp.

Method: feed ((grower vector) item)
Source

file-type.lisp.

Method: feed ((grower list) item)

This is a shorthand for (nconc grower (list item))
It is defined for consistancy, but using a LIST-GROWER is more efficient for building lists.

Source

file-type.lisp.

Method: feed ((grower plist-grower) item)
Source

file-type.lisp.

Method: feed ((grower plist-grower) (item cons))
Source

file-type.lisp.

Method: feed ((grower prepend-list-grower) item)
Source

file-type.lisp.

Method: feed ((grower list-grower) item)
Source

file-type.lisp.

Generic Function: feed-iterable (grower iterable)

Add all items from ITERABLE into GROWER. The default method
just iterates over iterable and calls FEED with each item.

The function is generic so that GROWERs can use more efficient methods if desired.

Package

garten/grower.

Source

file-type.lisp.

Methods
Method: feed-iterable ((grower stream) (seq vector))
Source

file-type.lisp.

Method: feed-iterable ((grower list-grower) (items list))

More efficient way to append a list to a list-grower.

Note that the list passed in may be destructively modified. If you want a copy of the list to be appended, you can use a liter iterator over the list instead of the list itself.

Source

file-type.lisp.

Method: feed-iterable (grower iterable)
Generic Reader: file-iterator-stream (object)
Generic Writer: (setf file-iterator-stream) (object)
Package

liter/file.

Methods
Reader Method: file-iterator-stream ((file-iterator file-iterator))
Writer Method: (setf file-iterator-stream) ((file-iterator file-iterator))

The stream that the file-iterator is backed by.

Source

file-type.lisp.

Target Slot

stream.

Generic Function: fruit (grower)

Return the final result of a grower.
A grower doesn’t necessarily need this to be defined if there is another way to access the result, but in most cases it should be supplied.

It is undefined what happens if this is called more than once for the same grower. Or more specifically, the behavior depends on the grower implementation.

Package

garten/grower.

Source

file-type.lisp.

Methods
Method: fruit :after ((grower stream))

If we got the result of a stream, then we should close it.

Source

file-type.lisp.

Method: fruit ((grower string-stream))
Source

file-type.lisp.

Method: fruit ((grower list-grower))
Source

file-type.lisp.

Method: fruit ((grower grower))

Default method for fruit for a GROWER. Just returns GROWER-STATE.

Method: fruit (grower)

Default implementation is to just return the grower itself.

Generic Function: get-iterator (iterable)

Get an iterator for some iterable object. Implementations are provided for builtin iterable types.

Package

liter/base.

Source

file-type.lisp.

Methods
Method: get-iterator ((f function))

The iterator for a function is just the function

Method: get-iterator ((o (eql nil)))

The nil iterator is always empty

Method: get-iterator ((l list))

Iterator for the items of a list, or pairs of an alist.

Method: get-iterator ((s vector))

Iterate over the items of a vector respecting the fill-counter if extant.

Method: get-iterator ((a array))

Iterate over elements of array in row-major order.

Method: get-iterator ((h hash-table))

Iterate over elements of a hash-table. Returns a cons of the key and value.

Since a clousre over a the form from a HASH-TABLE-ITERATOR is undefiend, at the time of creation a list of keys is created and the iterator closes over that.

If you know of a better way of doing this, please let me know.

Method: get-iterator ((s stream))

Iterate over the elements of a stream. I.e. the characters of a character stream or the bytes of a byte stream.

Generic Function: grower-result (grower)

Alias for FRUIT.

Package

garten/grower.

Alias for

fruit.

Generic Reader: grower-state (object)
Generic Writer: (setf grower-state) (object)
Package

garten/grower.

Methods
Reader Method: grower-state ((grower grower))
Writer Method: (setf grower-state) ((grower grower))

The state of the grower. By default this is what is returned by FRUIT.

Source

file-type.lisp.

Target Slot

grower-state.

Generic Function: iter-object-end-p (iter-ojbect)

Predicate to test if the iterator has ended.

Package

liter/iter-object.

Source

file-type.lisp.

Methods
Method: iter-object-end-p ((obj file-iterator))
Source

file-type.lisp.

Generic Function: iter-object-next (iter-object &rest args)

Get the next object in the iter-object iterator.

Package

liter/iter-object.

Source

file-type.lisp.

Methods
Method: iter-object-next ((obj file-iterator) &rest args)
Source

file-type.lisp.

Generic Function: iter-object-prev (iter-object &rest args)

Get the previous object in the iter-object iterator.

This is optional for iter-object implementations.

Package

liter/iter-object.

Source

file-type.lisp.

Generic Function: make-grower (type &key element-type size adjustable default prepend &allow-other-keys)

Make a grower object that can be used to "grow"
a collection. The returned object must define the FEED method and in most
cases should define the FRUIT method and RESET-GROWER methods.

The TYPE argument is an object for which a MAKE-GROWER method is specialized, usually a symbol.

Package

garten/grower.

Source

file-type.lisp.

Methods
Method: make-grower ((type (eql hash-table)) &rest args &key &allow-other-keys)

Create a grower for a hash-table. Any additional arguments will be passed through to MAKE-HASH-TABLE.

Source

file-type.lisp.

Method: make-grower ((type (eql string)) &key element-type)

Create a grower for a string. @cl:param(element-type) is the element type of the resulting string.

Source

file-type.lisp.

Method: make-grower ((type (eql vector)) &key size element-type adjustable)

Create a growable vector. @cl:param(size) is the initial size of the vector to grow, @cl:param(element-type) is the element-type of the vector. And if @cl:param(adjustable) is false, then the vector cannot be grown beyond SIZE.

The resulting vector will have a fill pointer.

Source

file-type.lisp.

Method: make-grower ((type (eql :alist)) &key)

Create a grower for an alist. Items should be added as cons cells.
This is basically just a shortcut for a list grower with prepend set to true.

Source

file-type.lisp.

Method: make-grower ((type (eql :plist)) &key default)

Create a grower that create a plist. Items should be added as a cons cell
with the key and value as the car and cdr respectively.

If an item is passed to FEED that isn’t a cons, then the output will use the item as a key and the default passed as DEFAULT as the value.

Source

file-type.lisp.

Method: make-grower ((type (eql list)) &key prepend)

Create a grower that creates a list.
By default items are added to the end of the list, and the list is built using a LIST-GROWER.

However, if PREPEND is true, then items are pushed onto the front of the list.

Source

file-type.lisp.

Generic Function: reset-grower (grower)

Reset a grower to an empty collection.

This can be used to recycle data structures if the result is no longer used.
But it is undefined whether it is safe to use the result of FRUIT after RESET-GROWER has been called on the grower that generated it.

It also may not be defined for all growers.

Package

garten/grower.

Source

file-type.lisp.

Methods
Method: reset-grower ((grower hash-table))
Source

file-type.lisp.

Method: reset-grower ((grower string-stream))
Source

file-type.lisp.

Method: reset-grower ((grower vector))
Source

file-type.lisp.

Method: reset-grower ((grower list-grower))
Source

file-type.lisp.

Method: reset-grower ((grower grower))
Generic Function: sdel (object key &key)

Generic delete function. Companion to sget and sset.

Like SSET it MUST return the object with changes.

Package

silo/protocol.

Source

file-type.lisp.

Methods
Method: sdel ((object hash-table) key &key)

Delete an object from a hash-table.

Source

file-type.lisp.

Generic Function: sget (object key &key default)

Generic get function. Provides a uniform way to
access properties of an object. The s stands for super, simple, or standard.

It is setfable as long as @c((setf sget)) is defined as well, which it should be for mutable objects.

Package

silo/protocol.

Source

file-type.lisp.

Methods
Method: sget ((object list) (key %alist-ref) &key)
Source

file-type.lisp.

Method: sget ((object list) (key %plist-ref) &key default)
Source

file-type.lisp.

Method: sget ((object list) (key integer) &key)
Source

file-type.lisp.

Method: sget ((object array) (subscripts list) &key)
Source

file-type.lisp.

Method: sget ((object vector) (index integer) &key)
Source

file-type.lisp.

Method: sget ((object hash-table) key &key default)
Source

file-type.lisp.

Method: sget ((object standard-object) key &key)
Source

file-type.lisp.

Generic Function: (setf sget) (object key &key default)

Generic set function. companion to sget.
SSET should mutate OBJECT.
Note that for some data types (ex lists, objects) this can’t be used to set new values. You may be able to use SUPDATE in those cases.

Package

silo/protocol.

Source

file-type.lisp.

Methods
Method: (setf sget) ((object list) (key %alist-ref) &key)
Source

file-type.lisp.

Method: (setf sget) ((object list) (key %plist-ref) &key default)
Source

file-type.lisp.

Method: (setf sget) ((object list) (key integer) &key)
Source

file-type.lisp.

Method: (setf sget) ((object array) (subscripts list) &key)
Source

file-type.lisp.

Method: (setf sget) ((object vector) (index integer) &key)
Source

file-type.lisp.

Method: (setf sget) ((object hash-table) key &key default)
Source

file-type.lisp.

Method: (setf sget) ((object standard-object) key &key)
Source

file-type.lisp.

Generic Function: sremove (object key &key)

SREMOVE is to SDEL what SUPDATE is to (SETF SGET):
It returns a collection with the item for KEY removed which may or may not be the same object as OBJECT, and which may or may not mutate OBJECT.

Package

silo/protocol.

Source

file-type.lisp.

Methods
Method: sremove (object key &rest key-args &key)
Generic Function: supdate (object key value &key)

Generic update function. Unlike (SETF SGET) it may or may not mutate
OBJECT. Data structures should define one or both of (SETF SGET) and SUPDATE.

SUPDATE MUST return the updated object.

For immutable data structures, SUPDATE can be used to create updated data structures. It also works for prepending to lists such as plists or alists.

Package

silo/protocol.

Source

file-type.lisp.

Methods
Method: supdate ((object list) (key %alist-ref) value &key)

For an ALIST supdate will either replace an existing value, or add a new cons pair to the front of the list if the associated key isn’t already in the list.

Source

file-type.lisp.

Method: supdate ((object list) (key %plist-ref) value &key)
Source

file-type.lisp.

Method: supdate (object key value &rest key-args &key)

Default implementation just calls SSET and returns OBJECT.


5.1.6 Standalone methods

Method: initialize-instance :after ((object iter-object) &key &allow-other-keys)
Source

file-type.lisp.


5.1.7 Conditions

Condition: iteration-ended

Condition signaled when an iterator has reached the end.

Package

liter/base.

Source

file-type.lisp.

Direct superclasses

simple-condition.

Direct subclasses

unhandled-iteration-end.


5.1.8 Classes

Class: file-iterator

An iterator object that represents the iteration state of iterating over a file stream.

Package

liter/file.

Source

file-type.lisp.

Direct superclasses

iter-object.

Direct methods
Direct slots
Slot: stream

The stream that the file-iterator is backed by.

Package

common-lisp.

Type

file-stream

Initargs

:file-stream

Readers

file-iterator-stream.

Writers

(setf file-iterator-stream).

Slot: reader

The function to use to read from the stream. The results of calling this function will be the elements of the iterator.

Type

(function (stream) t)

Initargs

:reader

Readers

file-iterator-reader.

Writers

(setf file-iterator-reader).

Class: grower

Base class for specialized growers.

Note that not all grower’s will be subclasses of GROWER.

Package

garten/grower.

Source

file-type.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: grower-state

The state of the grower. By default this is what is returned by FRUIT.

Initargs

:init-state

Readers

grower-state.

Writers

(setf grower-state).

Class: iter-object

A class to represent an iterator object.

It is a funcallable object that calls ITER-OBJECT-NEXT when called.

Subclasses should use a metaclass of CLOSER-MOP:FUNCALLABLE-STANDARD-CLASS.

Package

liter/iter-object.

Source

file-type.lisp.

Direct superclasses

funcallable-standard-object.

Direct subclasses

file-iterator.

Direct methods

initialize-instance.

Class: list-grower

A grower for a list that allows appending elements in constant time.

Package

garten/list.

Source

file-type.lisp.

Direct superclasses

grower.

Direct methods
Direct slots
Slot: grower-state

A queue of items added. This makes insertion at the end a constant time operation.

Package

garten/grower.

Initform

(serapeum:queue)

Class: plist-grower

A grower that creates a plist. Items added should be cons cells
of the key and value. If an item isn’t a cons cell it is treated as a key, with a value of DEFAULT-VALUE.

Package

garten/list.

Source

file-type.lisp.

Direct superclasses

grower.

Direct methods
Direct slots
Slot: default-value

The default value to store in the plist if the fed item isn’t a cons cell.

Initargs

:default

Readers

plist-grower-default.

Writers

This slot is read-only.

Class: prepend-list-grower

A List grower that prepends values rather than appending them.

Package

garten/list.

Source

file-type.lisp.

Direct superclasses

grower.

Direct methods

feed.


5.2 Internals


5.2.1 Special variables

Special Variable: *default-grower-size*

The default initial size to use when creating a grower that needs an initial size, such as a vector.

Package

garten/base.

Source

file-type.lisp.


5.2.2 Macros

Macro: clause-for-in-iterable-2 (&key for in-iterable generate)

Iterate over all items in an iterable.

Package

liter/base.

Source

file-type.lisp.

Macro: clause-for-in-iterator-1 (&key for in-iterator generate)

Iterate over all items in an iterator.

Package

liter/base.

Source

file-type.lisp.

Macro: clause-growing-from-3 (&key growing from into with)

Iterate clause similar to COLLECT but can grow any growable structure.

TYPE is the type of growable to create. If TYPE is a symbol it doesn’t need to be quoted.

If provided, GROWER-ARGS should be a plist of arguments to pass to MAKE-GROWER
after the TYPE parameter.

Note that VAR will contain the grower object, not the end result. If you store
the grower in a variable it is up to you to call FRUIT on the grower when needed.

EXPR is the actual expression to store in the grower.

Package

garten/tools.

Source

file-type.lisp.


5.2.3 Ordinary functions

Function: %get-read-function (element-type)
Package

liter/file.

Source

file-type.lisp.

Function: %plist-feed (grower key value)
Package

garten/list.

Source

file-type.lisp.

Function: ilist (&rest elements)

Iterate over the arguments passed in. Then terminate.

Package

liter/generate.

Source

file-type.lisp.


5.2.4 Generic functions

Generic Reader: file-iterator-reader (object)
Generic Writer: (setf file-iterator-reader) (object)
Package

liter/file.

Methods
Reader Method: file-iterator-reader ((file-iterator file-iterator))
Writer Method: (setf file-iterator-reader) ((file-iterator file-iterator))

The function to use to read from the stream. The results of calling this function will be the elements of the iterator.

Source

file-type.lisp.

Target Slot

reader.

Generic Reader: plist-grower-default (object)
Package

garten/list.

Methods
Reader Method: plist-grower-default ((plist-grower plist-grower))

The default value to store in the plist if the fed item isn’t a cons cell.

Source

file-type.lisp.

Target Slot

default-value.


5.2.5 Conditions

Condition: unhandled-iteration-end

Error signaled if an iterator is ended and the ITERATION-ENDED condition isn’t handled in some way.

Package

liter/base.

Source

file-type.lisp.

Direct superclasses

5.2.6 Classes

Class: %alist-ref
Package

silo/base.

Source

file-type.lisp.

Direct methods
Direct slots
Slot: item
Initargs

:item

Slot: key
Type

(or function symbol)

Initargs

:key

Slot: test
Type

(or function symbol)

Initform

(quote eql)

Initargs

:test

Class: %plist-ref
Package

silo/base.

Source

file-type.lisp.

Direct methods
Direct slots
Slot: key-item
Initargs

:key-item


Appendix A Indexes


A.1 Concepts


A.2 Functions

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

%
%get-read-function: Private ordinary functions
%plist-feed: Private ordinary functions

(
(setf file-iterator-reader): Private generic functions
(setf file-iterator-reader): Private generic functions
(setf file-iterator-stream): Public generic functions
(setf file-iterator-stream): Public generic functions
(setf grower-state): Public generic functions
(setf grower-state): Public generic functions
(setf sget): Public generic functions
(setf sget): Public generic functions
(setf sget): Public generic functions
(setf sget): Public generic functions
(setf sget): Public generic functions
(setf sget): Public generic functions
(setf sget): Public generic functions
(setf sget): Public generic functions
(setf slocation): Public setf expanders

A
alist-key: Public ordinary functions

C
clause-for-in-iterable-2: Private macros
clause-for-in-iterator-1: Private macros
clause-growing-from-3: Private macros
Compiler Macro, irepeat: Public compiler macros
contains-p: Public generic functions
contains-p: Public generic functions
contains-p: Public generic functions
contains-p: Public generic functions
contains-p: Public generic functions
contains-p: Public generic functions
contains-p: Public generic functions

D
define-sgetter: Public macros
do-iterable: Public macros
do-iterator: Public macros

E
end-iteration: Public ordinary functions

F
feed: Public generic functions
feed: Public generic functions
feed: Public generic functions
feed: Public generic functions
feed: Public generic functions
feed: Public generic functions
feed: Public generic functions
feed: Public generic functions
feed: Public generic functions
feed: Public generic functions
feed: Public generic functions
feed: Public generic functions
feed*: Public ordinary functions
feed-iterable: Public generic functions
feed-iterable: Public generic functions
feed-iterable: Public generic functions
feed-iterable: Public generic functions
file-iterator-reader: Private generic functions
file-iterator-reader: Private generic functions
file-iterator-stream: Public generic functions
file-iterator-stream: Public generic functions
fruit: Public generic functions
fruit: Public generic functions
fruit: Public generic functions
fruit: Public generic functions
fruit: Public generic functions
fruit: Public generic functions
Function, %get-read-function: Private ordinary functions
Function, %plist-feed: Private ordinary functions
Function, alist-key: Public ordinary functions
Function, end-iteration: Public ordinary functions
Function, feed*: Public ordinary functions
Function, grow-from-iterable: Public ordinary functions
Function, iaccumulate: Public ordinary functions
Function, ichain: Public ordinary functions
Function, icounter: Public ordinary functions
Function, icycle: Public ordinary functions
Function, icycle*: Public ordinary functions
Function, idrop: Public ordinary functions
Function, idrop-while: Public ordinary functions
Function, ifilter: Public ordinary functions
Function, ifold: Public ordinary functions
Function, ilist: Private ordinary functions
Function, inext: Public ordinary functions
Function, irepeat: Public ordinary functions
Function, itake: Public ordinary functions
Function, itake-while: Public ordinary functions
Function, itee: Public ordinary functions
Function, iterator-list: Public ordinary functions
Function, itransform: Public ordinary functions
Function, izip: Public ordinary functions
Function, izip-longest: Public ordinary functions
Function, izip-with-index: Public ordinary functions
Function, make-byte-stream-iterator: Public ordinary functions
Function, make-character-stream-iterator: Public ordinary functions
Function, make-file-iterator: Public ordinary functions
Function, make-hash-key-iterator: Public ordinary functions
Function, make-hash-value-iterator: Public ordinary functions
Function, make-line-iterator: Public ordinary functions
Function, make-state-iterator: Public ordinary functions
Function, plist-key: Public ordinary functions
Function, rget-apply: Public ordinary functions
Function, singleton-iterator: Public ordinary functions

G
Generic Function, (setf file-iterator-reader): Private generic functions
Generic Function, (setf file-iterator-stream): Public generic functions
Generic Function, (setf grower-state): Public generic functions
Generic Function, (setf sget): Public generic functions
Generic Function, contains-p: Public generic functions
Generic Function, feed: Public generic functions
Generic Function, feed-iterable: Public generic functions
Generic Function, file-iterator-reader: Private generic functions
Generic Function, file-iterator-stream: Public generic functions
Generic Function, fruit: Public generic functions
Generic Function, get-iterator: Public generic functions
Generic Function, grower-result: Public generic functions
Generic Function, grower-state: Public generic functions
Generic Function, iter-object-end-p: Public generic functions
Generic Function, iter-object-next: Public generic functions
Generic Function, iter-object-prev: Public generic functions
Generic Function, make-grower: Public generic functions
Generic Function, plist-grower-default: Private generic functions
Generic Function, reset-grower: Public generic functions
Generic Function, sdel: Public generic functions
Generic Function, sget: Public generic functions
Generic Function, sremove: Public generic functions
Generic Function, supdate: Public generic functions
get-iterator: Public generic functions
get-iterator: Public generic functions
get-iterator: Public generic functions
get-iterator: Public generic functions
get-iterator: Public generic functions
get-iterator: Public generic functions
get-iterator: Public generic functions
get-iterator: Public generic functions
grow-from-iterable: Public ordinary functions
grower-result: Public generic functions
grower-state: Public generic functions
grower-state: Public generic functions

I
iaccumulate: Public ordinary functions
ichain: Public ordinary functions
icounter: Public ordinary functions
icycle: Public ordinary functions
icycle*: Public ordinary functions
idrop: Public ordinary functions
idrop-while: Public ordinary functions
ifilter: Public ordinary functions
ifold: Public ordinary functions
ilist: Private ordinary functions
inext: Public ordinary functions
initialize-instance: Public standalone methods
irepeat: Public compiler macros
irepeat: Public ordinary functions
itake: Public ordinary functions
itake-while: Public ordinary functions
itee: Public ordinary functions
iter-object-end-p: Public generic functions
iter-object-end-p: Public generic functions
iter-object-next: Public generic functions
iter-object-next: Public generic functions
iter-object-prev: Public generic functions
iterator-list: Public ordinary functions
itransform: Public ordinary functions
izip: Public ordinary functions
izip-longest: Public ordinary functions
izip-with-index: Public ordinary functions

M
Macro, clause-for-in-iterable-2: Private macros
Macro, clause-for-in-iterator-1: Private macros
Macro, clause-growing-from-3: Private macros
Macro, define-sgetter: Public macros
Macro, do-iterable: Public macros
Macro, do-iterator: Public macros
Macro, make-iterator: Public macros
Macro, make-state-iterator*: Public macros
Macro, rget: Public macros
Macro, ssetf: Public macros
Macro, with-file-iterator: Public macros
Macro, with-grower: Public macros
make-byte-stream-iterator: Public ordinary functions
make-character-stream-iterator: Public ordinary functions
make-file-iterator: Public ordinary functions
make-grower: Public generic functions
make-grower: Public generic functions
make-grower: Public generic functions
make-grower: Public generic functions
make-grower: Public generic functions
make-grower: Public generic functions
make-grower: Public generic functions
make-hash-key-iterator: Public ordinary functions
make-hash-value-iterator: Public ordinary functions
make-iterator: Public macros
make-line-iterator: Public ordinary functions
make-state-iterator: Public ordinary functions
make-state-iterator*: Public macros
Method, (setf file-iterator-reader): Private generic functions
Method, (setf file-iterator-stream): Public generic functions
Method, (setf grower-state): Public generic functions
Method, (setf sget): Public generic functions
Method, (setf sget): Public generic functions
Method, (setf sget): Public generic functions
Method, (setf sget): Public generic functions
Method, (setf sget): Public generic functions
Method, (setf sget): Public generic functions
Method, (setf sget): Public generic functions
Method, contains-p: Public generic functions
Method, contains-p: Public generic functions
Method, contains-p: Public generic functions
Method, contains-p: Public generic functions
Method, contains-p: Public generic functions
Method, contains-p: Public generic functions
Method, feed: Public generic functions
Method, feed: Public generic functions
Method, feed: Public generic functions
Method, feed: Public generic functions
Method, feed: Public generic functions
Method, feed: Public generic functions
Method, feed: Public generic functions
Method, feed: Public generic functions
Method, feed: Public generic functions
Method, feed: Public generic functions
Method, feed: Public generic functions
Method, feed-iterable: Public generic functions
Method, feed-iterable: Public generic functions
Method, feed-iterable: Public generic functions
Method, file-iterator-reader: Private generic functions
Method, file-iterator-stream: Public generic functions
Method, fruit: Public generic functions
Method, fruit: Public generic functions
Method, fruit: Public generic functions
Method, fruit: Public generic functions
Method, fruit: Public generic functions
Method, get-iterator: Public generic functions
Method, get-iterator: Public generic functions
Method, get-iterator: Public generic functions
Method, get-iterator: Public generic functions
Method, get-iterator: Public generic functions
Method, get-iterator: Public generic functions
Method, get-iterator: Public generic functions
Method, grower-state: Public generic functions
Method, initialize-instance: Public standalone methods
Method, iter-object-end-p: Public generic functions
Method, iter-object-next: Public generic functions
Method, make-grower: Public generic functions
Method, make-grower: Public generic functions
Method, make-grower: Public generic functions
Method, make-grower: Public generic functions
Method, make-grower: Public generic functions
Method, make-grower: Public generic functions
Method, plist-grower-default: Private generic functions
Method, reset-grower: Public generic functions
Method, reset-grower: Public generic functions
Method, reset-grower: Public generic functions
Method, reset-grower: Public generic functions
Method, reset-grower: Public generic functions
Method, sdel: Public generic functions
Method, sget: Public generic functions
Method, sget: Public generic functions
Method, sget: Public generic functions
Method, sget: Public generic functions
Method, sget: Public generic functions
Method, sget: Public generic functions
Method, sget: Public generic functions
Method, sremove: Public generic functions
Method, supdate: Public generic functions
Method, supdate: Public generic functions
Method, supdate: Public generic functions

P
plist-grower-default: Private generic functions
plist-grower-default: Private generic functions
plist-key: Public ordinary functions

R
reset-grower: Public generic functions
reset-grower: Public generic functions
reset-grower: Public generic functions
reset-grower: Public generic functions
reset-grower: Public generic functions
reset-grower: Public generic functions
rget: Public macros
rget-apply: Public ordinary functions

S
sdel: Public generic functions
sdel: Public generic functions
Setf Expander, (setf slocation): Public setf expanders
sget: Public generic functions
sget: Public generic functions
sget: Public generic functions
sget: Public generic functions
sget: Public generic functions
sget: Public generic functions
sget: Public generic functions
sget: Public generic functions
singleton-iterator: Public ordinary functions
sremove: Public generic functions
sremove: Public generic functions
ssetf: Public macros
supdate: Public generic functions
supdate: Public generic functions
supdate: Public generic functions
supdate: Public generic functions

W
with-file-iterator: Public macros
with-grower: Public macros


A.4 Data types

Jump to:   %  
C   F   G   I   L   P   S   U  
Index Entry  Section

%
%alist-ref: Private classes
%plist-ref: Private classes

C
Class, %alist-ref: Private classes
Class, %plist-ref: Private classes
Class, file-iterator: Public classes
Class, grower: Public classes
Class, iter-object: Public classes
Class, list-grower: Public classes
Class, plist-grower: Public classes
Class, prepend-list-grower: Public classes
colliflower: The colliflower system
colliflower.asd: The colliflower/colliflower․asd file
colliflower/ext: The colliflower/ext system
colliflower/ext: The colliflower/ext package
colliflower/interface: The colliflower/interface system
colliflower/interface: The colliflower/interface package
Condition, iteration-ended: Public conditions
Condition, unhandled-iteration-end: Private conditions

F
File, colliflower.asd: The colliflower/colliflower․asd file
File, file-type.lisp: The liter/interface/file-type․lisp file
File, file-type.lisp: The liter/base/file-type․lisp file
File, file-type.lisp: The liter/generate/file-type․lisp file
File, file-type.lisp: The liter/tools/file-type․lisp file
File, file-type.lisp: The liter/iter-object/file-type․lisp file
File, file-type.lisp: The liter/file/file-type․lisp file
File, file-type.lisp: The garten/interface/file-type․lisp file
File, file-type.lisp: The garten/base/file-type․lisp file
File, file-type.lisp: The garten/grower/file-type․lisp file
File, file-type.lisp: The garten/list/file-type․lisp file
File, file-type.lisp: The garten/tools/file-type․lisp file
File, file-type.lisp: The colliflower/interface/file-type․lisp file
File, file-type.lisp: The silo/interface/file-type․lisp file
File, file-type.lisp: The silo/protocol/file-type․lisp file
File, file-type.lisp: The silo/base/file-type․lisp file
File, file-type.lisp: The colliflower/ext/file-type․lisp file
File, garten.asd: The garten/garten․asd file
File, liter.asd: The liter/liter․asd file
File, silo.asd: The silo/silo․asd file
file-iterator: Public classes
file-type.lisp: The liter/interface/file-type․lisp file
file-type.lisp: The liter/base/file-type․lisp file
file-type.lisp: The liter/generate/file-type․lisp file
file-type.lisp: The liter/tools/file-type․lisp file
file-type.lisp: The liter/iter-object/file-type․lisp file
file-type.lisp: The liter/file/file-type․lisp file
file-type.lisp: The garten/interface/file-type․lisp file
file-type.lisp: The garten/base/file-type․lisp file
file-type.lisp: The garten/grower/file-type․lisp file
file-type.lisp: The garten/list/file-type․lisp file
file-type.lisp: The garten/tools/file-type․lisp file
file-type.lisp: The colliflower/interface/file-type․lisp file
file-type.lisp: The silo/interface/file-type․lisp file
file-type.lisp: The silo/protocol/file-type․lisp file
file-type.lisp: The silo/base/file-type․lisp file
file-type.lisp: The colliflower/ext/file-type․lisp file

G
garten: The garten system
garten.asd: The garten/garten․asd file
garten/base: The garten/base system
garten/base: The garten/base package
garten/grower: The garten/grower system
garten/grower: The garten/grower package
garten/interface: The garten/interface system
garten/interface: The garten/interface package
garten/list: The garten/list system
garten/list: The garten/list package
garten/tools: The garten/tools system
garten/tools: The garten/tools package
grower: Public classes

I
iter-object: Public classes
iteration-ended: Public conditions

L
list-grower: Public classes
liter: The liter system
liter.asd: The liter/liter․asd file
liter/base: The liter/base system
liter/base: The liter/base package
liter/file: The liter/file system
liter/file: The liter/file package
liter/generate: The liter/generate system
liter/generate: The liter/generate package
liter/interface: The liter/interface system
liter/interface: The liter/interface package
liter/iter-object: The liter/iter-object system
liter/iter-object: The liter/iter-object package
liter/tools: The liter/tools system
liter/tools: The liter/tools package

P
Package, colliflower/ext: The colliflower/ext package
Package, colliflower/interface: The colliflower/interface package
Package, garten/base: The garten/base package
Package, garten/grower: The garten/grower package
Package, garten/interface: The garten/interface package
Package, garten/list: The garten/list package
Package, garten/tools: The garten/tools package
Package, liter/base: The liter/base package
Package, liter/file: The liter/file package
Package, liter/generate: The liter/generate package
Package, liter/interface: The liter/interface package
Package, liter/iter-object: The liter/iter-object package
Package, liter/tools: The liter/tools package
Package, silo/base: The silo/base package
Package, silo/interface: The silo/interface package
Package, silo/protocol: The silo/protocol package
plist-grower: Public classes
prepend-list-grower: Public classes

S
silo: The silo system
silo.asd: The silo/silo․asd file
silo/base: The silo/base system
silo/base: The silo/base package
silo/interface: The silo/interface system
silo/interface: The silo/interface package
silo/protocol: The silo/protocol system
silo/protocol: The silo/protocol package
System, colliflower: The colliflower system
System, colliflower/ext: The colliflower/ext system
System, colliflower/interface: The colliflower/interface system
System, garten: The garten system
System, garten/base: The garten/base system
System, garten/grower: The garten/grower system
System, garten/interface: The garten/interface system
System, garten/list: The garten/list system
System, garten/tools: The garten/tools system
System, liter: The liter system
System, liter/base: The liter/base system
System, liter/file: The liter/file system
System, liter/generate: The liter/generate system
System, liter/interface: The liter/interface system
System, liter/iter-object: The liter/iter-object system
System, liter/tools: The liter/tools system
System, silo: The silo system
System, silo/base: The silo/base system
System, silo/interface: The silo/interface system
System, silo/protocol: The silo/protocol system

U
unhandled-iteration-end: Private conditions