The colliflower Reference Manual

Table of Contents

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

The colliflower Reference Manual

This is the colliflower Reference Manual, version 0.2.1, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 11:37:26 2018 GMT+0.


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

1 Introduction

colliflower

Colliflower is a set of generic interfaces for lisp collections.

The full documentation can be found here.

Colliflower has four components:

  1. liter
  2. garten
  3. silo
  4. colliflower

Each of these components are described below.

liter

Liter provides an abstraction and tools for iterators.

A liter iterator is simply a function which returns the next value with each invocation and signals and end of iteration with an ITERATION-ENDED condition.

A liter iterable is any object for which there is a method defined for the GET-ITERATOR generic function. An iterator (or more generally a function) is an iterable whose iterator is itself. The LITER package provides GET-ITERATOR methods for lists, vectors, hash-tables, streams, and arrays, as well as functions to get iterators over those structures in different ways (such as treating lists as plists or alists, or iterating over the lines of a character stream).

Liter also provides:

garten

Garten provides a generic abstraction for building new data structures. It is a more generic form of the COLLECTING macro.

The core of garten is the concept of a "grower". A grower is an object that stores the state of a collection while it is being built. The grower itself may or may not be the final result. For example: the grower for a list may keep handles for both the head and tail of the list to efficiently append elements, or the grower for an immutable data structure may itself be mutable.

The basic interface for garten consists of three generic functions:

  1. MAKE-GROWER creates a new grower for some type. Note that the TYPE argument is the type of the final data structure, not the type of the grower.
  2. FEED adds an item to the grower, which will eventually be part of the final structure.
  3. FRUIT retrieves the final result of the grower. In general it is not safe to call FRUIT, FEED, or RESET-GROWER after FRUIT has been called for a grower, as doing so may mutate the result returned by previous calls to FRUIT.

Garten defines the above interface for lists, plists, vectors, hash-tables, strings, etc. Garten also provides WITH-GROWER which is similar to the oft-implemented COLLECTING macro, and a GROWING directive for the iterate library.

silo

Silo provides a generic way to access and set values of data structures by a key. The key may be a normal key, or an index.

colliflower

Colliflower is brings the four above components together. The colliflower package exports all of the public symbols from liter, garten, and silo and provides a few additional tools that combine functionality from the packages.


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

2 Systems

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


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

2.1 colliflower

Author

Thayne McCombs <bytecurry.software@gmail.com>

License

MIT

Description

Generic interfaces for collections and iterators.

Version

0.2.1

Defsystem Dependency

asdf-package-system

Dependencies
Source

colliflower.asd (file)


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

2.2 colliflower/interface

Dependencies
Source

colliflower.asd (file)

Component

lisp.lisp (file)


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

2.3 colliflower/ext

Dependencies
Source

colliflower.asd (file)

Component

lisp.lisp (file)


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

2.4 liter

Author

Thayne McCombs <bytecurry.software@gmail.com>

License

MIT

Description

Collection of tools for basic iterators

Version

0.2.0

Dependency

liter/interface (system)

Source

liter.asd (file)


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

2.5 liter/interface

Dependencies
Source

liter.asd (file)

Component

lisp.lisp (file)


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

2.6 liter/tools

Dependencies
Source

liter.asd (file)

Component

lisp.lisp (file)


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

2.7 liter/generate

Dependencies
Source

liter.asd (file)

Component

lisp.lisp (file)


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

2.8 liter/file

Dependencies
Source

liter.asd (file)

Component

lisp.lisp (file)


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

2.9 liter/iter-object

Dependency

closer-mop

Source

liter.asd (file)

Component

lisp.lisp (file)


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

2.10 silo

Author

Thayne McCombs <bytecurry.software@gmail.com

License

MIT

Description

Generic getters and setters for data structures.

Version

0.2.0

Dependency

silo/interface (system)

Source

silo.asd (file)


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

2.11 silo/interface

Dependencies
Source

silo.asd (file)

Component

lisp.lisp (file)


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

2.12 silo/base

Dependency

silo/protocol (system)

Source

silo.asd (file)

Component

lisp.lisp (file)


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

2.13 silo/protocol

Source

silo.asd (file)

Component

lisp.lisp (file)


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

2.14 garten

Author

Thayne McCombs <bytecurry.software@gmail.com

Description

Generic interface for "growing" data structures/collections.

Version

0.1.0

Dependency

garten/interface (system)

Source

garten.asd (file)


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

2.15 garten/interface

Dependencies
Source

garten.asd (file)

Component

lisp.lisp (file)


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

2.16 garten/base

Dependencies
Source

garten.asd (file)

Component

lisp.lisp (file)


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

2.17 garten/list

Dependencies
Source

garten.asd (file)

Component

lisp.lisp (file)


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

2.18 garten/tools

Dependencies
Source

garten.asd (file)

Component

lisp.lisp (file)


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

2.19 garten/grower

Dependencies
Source

garten.asd (file)

Component

lisp.lisp (file)


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

2.20 liter/base

Dependencies
Source

liter.asd (file)

Component

lisp.lisp (file)


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

3 Files

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


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

3.1 Lisp


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

3.1.1 colliflower.asd

Location

colliflower.asd

Systems

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

3.1.2 silo.asd

Location

silo/silo.asd

Systems

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

3.1.3 garten.asd

Location

garten/garten.asd

Systems

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

3.1.4 liter.asd

Location

liter/liter.asd

Systems

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

3.1.5 colliflower/interface/lisp.lisp

Parent

colliflower/interface (system)

Location

interface.lisp

Packages

colliflower/interface


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

3.1.6 colliflower/ext/lisp.lisp

Parent

colliflower/ext (system)

Location

ext.lisp

Packages

colliflower/ext

Exported Definitions

grow-from-iterable (function)


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

3.1.7 liter/interface/lisp.lisp

Parent

liter/interface (system)

Location

liter/interface.lisp

Packages

liter/interface


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

3.1.8 liter/tools/lisp.lisp

Parent

liter/tools (system)

Location

liter/tools.lisp

Packages

liter/tools

Exported Definitions

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

3.1.9 liter/generate/lisp.lisp

Parent

liter/generate (system)

Location

liter/generate.lisp

Packages

liter/generate

Exported Definitions
Internal Definitions

ilist (function)


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

3.1.10 liter/file/lisp.lisp

Parent

liter/file (system)

Location

liter/file.lisp

Packages

liter/file

Exported Definitions
Internal Definitions

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

3.1.11 liter/iter-object/lisp.lisp

Parent

liter/iter-object (system)

Location

liter/iter-object.lisp

Packages

liter/iter-object

Exported Definitions

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

3.1.12 silo/interface/lisp.lisp

Parent

silo/interface (system)

Location

silo/interface.lisp

Packages

silo/interface


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

3.1.13 silo/base/lisp.lisp

Parent

silo/base (system)

Location

silo/base.lisp

Packages

silo/base

Exported Definitions
Internal Definitions

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

3.1.14 silo/protocol/lisp.lisp

Parent

silo/protocol (system)

Location

silo/protocol.lisp

Packages

silo/protocol

Exported Definitions

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

3.1.15 garten/interface/lisp.lisp

Parent

garten/interface (system)

Location

garten/interface.lisp

Packages

garten/interface


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

3.1.16 garten/base/lisp.lisp

Parent

garten/base (system)

Location

garten/base.lisp

Packages

garten/base

Exported Definitions
Internal Definitions

*default-grower-size* (special variable)


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

3.1.17 garten/list/lisp.lisp

Parent

garten/list (system)

Location

garten/list.lisp

Packages

garten/list

Exported Definitions
Internal Definitions

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

3.1.18 garten/tools/lisp.lisp

Parent

garten/tools (system)

Location

garten/tools.lisp

Packages

garten/tools

Exported Definitions

with-grower (macro)

Internal Definitions

clause-growing-from-3 (macro)


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

3.1.19 garten/grower/lisp.lisp

Parent

garten/grower (system)

Location

garten/grower.lisp

Packages

garten/grower

Exported Definitions

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

3.1.20 liter/base/lisp.lisp

Parent

liter/base (system)

Location

liter/base.lisp

Packages

liter/base

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 colliflower/interface

Combination of the LITER, SILO, and GARTEN packages.

Source

lisp.lisp (file)

Nicknames
Use List

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

4.2 colliflower/ext

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

Source

lisp.lisp (file)

Use List
Used By List

colliflower/interface

Exported Definitions

grow-from-iterable (function)


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

4.3 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

lisp.lisp (file)

Nicknames
Use List
Used By List

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

4.4 liter/tools

Source

lisp.lisp (file)

Use List
Used By List

liter/interface

Exported Definitions

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

4.5 liter/generate

Source

lisp.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

ilist (function)


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

4.6 liter/file

Source

lisp.lisp (file)

Use List
Used By List

liter/interface

Exported Definitions
Internal Definitions

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

4.7 liter/iter-object

Source

lisp.lisp (file)

Nickname

liter-object

Use List

common-lisp

Used By List
Exported Definitions

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

4.8 silo/interface

Source

lisp.lisp (file)

Nicknames
Use List
Used By List

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

4.9 silo/base

Source

lisp.lisp (file)

Use List
Used By List

silo/interface

Exported Definitions
Internal Definitions

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

4.10 silo/protocol

Source

lisp.lisp (file)

Use List

common-lisp

Used By List
Exported Definitions

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

4.11 garten/interface

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

Source

lisp.lisp (file)

Nicknames
Use List
Used By List

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

4.12 garten/base

Source

lisp.lisp (file)

Use List
Used By List

garten/interface

Internal Definitions

*default-grower-size* (special variable)


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

4.13 garten/list

Source

lisp.lisp (file)

Use List
Used By List

garten/base

Exported Definitions
Internal Definitions

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

4.14 garten/tools

Source

lisp.lisp (file)

Use List
Used By List

garten/interface

Exported Definitions

with-grower (macro)

Internal Definitions

clause-growing-from-3 (macro)


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

4.15 garten/grower

Source

lisp.lisp (file)

Use List
Used By List
Exported Definitions

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

4.16 liter/base

Source

lisp.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Macros

Macro: 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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

Macro: ssetf PLACE KEY VALUE &rest KEY-ARGS

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

Package

silo/protocol

Source

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)


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

5.1.2 Compiler macros

Compiler Macro: irepeat V &optional N
Package

liter/generate

Source

lisp.lisp (file)


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

5.1.3 Functions

Function: alist-key ITEM &key KEY TEST

Create a key to access values in alists with sget

Package

silo/base

Source

lisp.lisp (file)

Function: end-iteration ()

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

Package

liter/base

Source

lisp.lisp (file)

Function: feed* GROWER &rest ITEMS

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

Package

garten/grower

Source

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

Function: icycle* &rest ARGS

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

Package

liter/generate

Source

lisp.lisp (file)

Function: idrop ITERABLE N

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

Package

liter/tools

Source

lisp.lisp (file)

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

lisp.lisp (file)

Function: ifilter ITERABLE PREDICATE

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

Package

liter/tools

Source

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

Function: itake ITERABLE N

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

Package

liter/tools

Source

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

Function: iterator-list ITERATOR

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

Package

liter/base

Source

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

Function: make-byte-stream-iterator STREAM

Get an iterator for a binary input stream.

Package

liter/base

Source

lisp.lisp (file)

Function: make-character-stream-iterator STREAM

Get an iterator for a character input stream

Package

liter/base

Source

lisp.lisp (file)

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

lisp.lisp (file)

Function: make-hash-key-iterator H

Get an iterator over the keys of H.

Package

liter/base

Source

lisp.lisp (file)

Function: make-hash-value-iterator H

Get an iterator over the values of H.

Package

liter/base

Source

lisp.lisp (file)

Function: make-line-iterator STREAM

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

Package

liter/base

Source

lisp.lisp (file)

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

lisp.lisp (file)

Function: plist-key KEY-ITEM

Create a key to access an item in a plist

Package

silo/base

Source

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)


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

5.1.4 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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

Method: contains-p (CONTAINER list) ELEMENT
Source

lisp.lisp (file)

Method: contains-p (CONTAINER vector) ELEMENT
Source

lisp.lisp (file)

Method: contains-p (TABLE hash-table) KEY
Source

lisp.lisp (file)

Method: contains-p (OBJECT standard-object) KEY
Source

lisp.lisp (file)

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

lisp.lisp (file)

Methods
Method: feed (GROWER hash-table) (ITEM cons)
Source

lisp.lisp (file)

Method: feed (GROWER stream) (ITEM sequence)
Source

lisp.lisp (file)

Method: feed (GROWER stream) (ITEM integer)
Source

lisp.lisp (file)

Method: feed (GROWER stream) (ITEM character)
Source

lisp.lisp (file)

Method: feed (GROWER stream) (ITEM string)
Source

lisp.lisp (file)

Method: feed (GROWER vector) ITEM
Source

lisp.lisp (file)

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

lisp.lisp (file)

Method: feed (GROWER plist-grower) ITEM
Source

lisp.lisp (file)

Method: feed (GROWER plist-grower) (ITEM cons)
Source

lisp.lisp (file)

Method: feed (GROWER prepend-list-grower) ITEM
Source

lisp.lisp (file)

Method: feed (GROWER list-grower) ITEM
Source

lisp.lisp (file)

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

lisp.lisp (file)

Methods
Method: feed-iterable (GROWER stream) (SEQ vector)
Source

lisp.lisp (file)

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

lisp.lisp (file)

Method: feed-iterable GROWER ITERABLE
Generic Function: file-iterator-stream OBJECT
Generic Function: (setf file-iterator-stream) NEW-VALUE OBJECT
Package

liter/file

Methods
Method: file-iterator-stream (FILE-ITERATOR file-iterator)
Method: (setf file-iterator-stream) NEW-VALUE (FILE-ITERATOR file-iterator)

The stream that the file-iterator is backed by.

Source

lisp.lisp (file)

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

lisp.lisp (file)

Methods
Method: fruit (GROWER stream) after

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

Source

lisp.lisp (file)

Method: fruit (GROWER string-stream)
Source

lisp.lisp (file)

Method: fruit (GROWER list-grower)
Source

lisp.lisp (file)

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

lisp.lisp (file)

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

Source

lisp.lisp (file)

Methods
Method: grower-result (GROWER stream) after

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

Source

lisp.lisp (file)

Method: grower-result (GROWER string-stream)
Source

lisp.lisp (file)

Method: grower-result (GROWER list-grower)
Source

lisp.lisp (file)

Method: grower-result (GROWER grower)

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

Method: grower-result GROWER

Default implementation is to just return the grower itself.

Generic Function: grower-state OBJECT
Generic Function: (setf grower-state) NEW-VALUE OBJECT
Package

garten/grower

Methods
Method: grower-state (GROWER grower)
Method: (setf grower-state) NEW-VALUE (GROWER grower)

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

Source

lisp.lisp (file)

Generic Function: iter-object-end-p ITER-OJBECT

Predicate to test if the iterator has ended.

Package

liter/iter-object

Source

lisp.lisp (file)

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

lisp.lisp (file)

Generic Function: iter-object-next ITER-OBJECT &rest ARGS

Get the next object in the iter-object iterator.

Package

liter/iter-object

Source

lisp.lisp (file)

Methods
Method: iter-object-next (OBJ file-iterator) &rest ARGS
Source

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

Method: reset-grower (GROWER vector)
Source

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

Methods
Method: sdel (OBJECT hash-table) KEY &key

Delete an object from a hash-table.

Source

lisp.lisp (file)

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

lisp.lisp (file)

Writer

(setf sget) (generic function)

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

lisp.lisp (file)

Method: sget (OBJECT list) (KEY %plist-ref) &key DEFAULT
Source

lisp.lisp (file)

Method: sget (OBJECT list) (KEY integer) &key
Source

lisp.lisp (file)

Method: sget (OBJECT array) (SUBSCRIPTS list) &key
Source

lisp.lisp (file)

Method: sget (OBJECT vector) (INDEX integer) &key
Source

lisp.lisp (file)

Method: sget (OBJECT hash-table) KEY &key DEFAULT
Source

lisp.lisp (file)

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

lisp.lisp (file)

Generic Function: (setf sget) VALUE 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

lisp.lisp (file)

Reader

sget (generic function)

Methods
Method: (setf sget) G0 (OBJECT list) (KEY %alist-ref) &key
Source

lisp.lisp (file)

Method: (setf sget) G0 (OBJECT list) (KEY %plist-ref) &key DEFAULT
Source

lisp.lisp (file)

Method: (setf sget) G0 (OBJECT list) (KEY integer) &key
Source

lisp.lisp (file)

Method: (setf sget) G0 (OBJECT array) (SUBSCRIPTS list) &key
Source

lisp.lisp (file)

Method: (setf sget) G0 (OBJECT vector) (INDEX integer) &key
Source

lisp.lisp (file)

Method: (setf sget) G0 (OBJECT hash-table) KEY &key DEFAULT
Source

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

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

lisp.lisp (file)

Method: supdate (OBJECT list) (KEY %plist-ref) VALUE &key
Source

lisp.lisp (file)

Method: supdate OBJECT KEY VALUE &rest KEY-ARGS &key

Default implementation just calls SSET and returns OBJECT.


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

5.1.5 Conditions

Condition: iteration-ended ()

Condition signaled when an iterator has reached the end.

Package

liter/base

Source

lisp.lisp (file)

Direct superclasses

simple-condition (condition)

Direct subclasses

unhandled-iteration-end (condition)


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

5.1.6 Classes

Class: file-iterator ()

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

Package

liter/file

Source

lisp.lisp (file)

Direct superclasses

iter-object (class)

Direct methods
Direct slots
Slot: stream

The stream that the file-iterator is backed by.

Type

file-stream

Initargs

:file-stream

Readers

file-iterator-stream (generic function)

Writers

(setf file-iterator-stream) (generic function)

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 (generic function)

Writers

(setf file-iterator-reader) (generic function)

Class: grower ()

Base class for specialized growers.

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

Package

garten/grower

Source

lisp.lisp (file)

Direct superclasses

standard-object (class)

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 (generic function)

Writers

(setf grower-state) (generic function)

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

lisp.lisp (file)

Direct superclasses

funcallable-standard-object (class)

Direct subclasses

file-iterator (class)

Direct methods

initialize-instance (method)

Class: list-grower ()

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

Package

garten/list

Source

lisp.lisp (file)

Direct superclasses

grower (class)

Direct methods
Direct slots
Slot: grower-state

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

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

lisp.lisp (file)

Direct superclasses

grower (class)

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 (generic function)

Class: prepend-list-grower ()

A List grower that prepends values rather than appending them.

Package

garten/list

Source

lisp.lisp (file)

Direct superclasses

grower (class)

Direct methods

feed (method)


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

5.2 Internal definitions


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

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

lisp.lisp (file)


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

5.2.2 Macros

Macro: clause-for-in-iterable-2 &key (FOR VAR) (IN-ITERABLE IT) GENERATE

Iterate over all items in an iterable.

Package

liter/base

Source

lisp.lisp (file)

Macro: clause-for-in-iterator-1 &key (FOR VAR) (IN-ITERATOR IT) GENERATE

Iterate over all items in an iterator.

Package

liter/base

Source

lisp.lisp (file)

Macro: clause-growing-from-3 &key (GROWING TYPE) (FROM EXPR) (INTO VAR) (WITH GROWER-ARGS)

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

lisp.lisp (file)


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

5.2.3 Functions

Function: %get-read-function ELEMENT-TYPE
Package

liter/file

Source

lisp.lisp (file)

Function: %plist-feed GROWER KEY VALUE
Package

garten/list

Source

lisp.lisp (file)

Function: ilist &rest ELEMENTS

Iterate over the arguments passed in. Then terminate.

Package

liter/generate

Source

lisp.lisp (file)


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

5.2.4 Generic functions

Generic Function: file-iterator-reader OBJECT
Generic Function: (setf file-iterator-reader) NEW-VALUE OBJECT
Package

liter/file

Methods
Method: file-iterator-reader (FILE-ITERATOR file-iterator)
Method: (setf file-iterator-reader) NEW-VALUE (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

lisp.lisp (file)

Generic Function: plist-grower-default OBJECT
Package

garten/list

Methods
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

lisp.lisp (file)


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

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

lisp.lisp (file)

Direct superclasses

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

5.2.6 Classes

Class: %alist-ref ()
Package

silo/base

Source

lisp.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: item
Initargs

:item

Slot: key
Type

(or function symbol)

Initargs

:key

Slot: test
Type

(or function symbol)

Initargs

:test

Initform

(quote eql)

Class: %plist-ref ()
Package

silo/base

Source

lisp.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: key-item
Initargs

:key-item


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   G   L   S  
Index Entry  Section

C
colliflower.asd: The colliflower<dot>asd file
colliflower/ext/lisp.lisp: The colliflower/ext/lisp<dot>lisp file
colliflower/interface/lisp.lisp: The colliflower/interface/lisp<dot>lisp file

F
File, Lisp, colliflower.asd: The colliflower<dot>asd file
File, Lisp, colliflower/ext/lisp.lisp: The colliflower/ext/lisp<dot>lisp file
File, Lisp, colliflower/interface/lisp.lisp: The colliflower/interface/lisp<dot>lisp file
File, Lisp, garten.asd: The garten<dot>asd file
File, Lisp, garten/base/lisp.lisp: The garten/base/lisp<dot>lisp file
File, Lisp, garten/grower/lisp.lisp: The garten/grower/lisp<dot>lisp file
File, Lisp, garten/interface/lisp.lisp: The garten/interface/lisp<dot>lisp file
File, Lisp, garten/list/lisp.lisp: The garten/list/lisp<dot>lisp file
File, Lisp, garten/tools/lisp.lisp: The garten/tools/lisp<dot>lisp file
File, Lisp, liter.asd: The liter<dot>asd file
File, Lisp, liter/base/lisp.lisp: The liter/base/lisp<dot>lisp file
File, Lisp, liter/file/lisp.lisp: The liter/file/lisp<dot>lisp file
File, Lisp, liter/generate/lisp.lisp: The liter/generate/lisp<dot>lisp file
File, Lisp, liter/interface/lisp.lisp: The liter/interface/lisp<dot>lisp file
File, Lisp, liter/iter-object/lisp.lisp: The liter/iter-object/lisp<dot>lisp file
File, Lisp, liter/tools/lisp.lisp: The liter/tools/lisp<dot>lisp file
File, Lisp, silo.asd: The silo<dot>asd file
File, Lisp, silo/base/lisp.lisp: The silo/base/lisp<dot>lisp file
File, Lisp, silo/interface/lisp.lisp: The silo/interface/lisp<dot>lisp file
File, Lisp, silo/protocol/lisp.lisp: The silo/protocol/lisp<dot>lisp file

G
garten.asd: The garten<dot>asd file
garten/base/lisp.lisp: The garten/base/lisp<dot>lisp file
garten/grower/lisp.lisp: The garten/grower/lisp<dot>lisp file
garten/interface/lisp.lisp: The garten/interface/lisp<dot>lisp file
garten/list/lisp.lisp: The garten/list/lisp<dot>lisp file
garten/tools/lisp.lisp: The garten/tools/lisp<dot>lisp file

L
Lisp File, colliflower.asd: The colliflower<dot>asd file
Lisp File, colliflower/ext/lisp.lisp: The colliflower/ext/lisp<dot>lisp file
Lisp File, colliflower/interface/lisp.lisp: The colliflower/interface/lisp<dot>lisp file
Lisp File, garten.asd: The garten<dot>asd file
Lisp File, garten/base/lisp.lisp: The garten/base/lisp<dot>lisp file
Lisp File, garten/grower/lisp.lisp: The garten/grower/lisp<dot>lisp file
Lisp File, garten/interface/lisp.lisp: The garten/interface/lisp<dot>lisp file
Lisp File, garten/list/lisp.lisp: The garten/list/lisp<dot>lisp file
Lisp File, garten/tools/lisp.lisp: The garten/tools/lisp<dot>lisp file
Lisp File, liter.asd: The liter<dot>asd file
Lisp File, liter/base/lisp.lisp: The liter/base/lisp<dot>lisp file
Lisp File, liter/file/lisp.lisp: The liter/file/lisp<dot>lisp file
Lisp File, liter/generate/lisp.lisp: The liter/generate/lisp<dot>lisp file
Lisp File, liter/interface/lisp.lisp: The liter/interface/lisp<dot>lisp file
Lisp File, liter/iter-object/lisp.lisp: The liter/iter-object/lisp<dot>lisp file
Lisp File, liter/tools/lisp.lisp: The liter/tools/lisp<dot>lisp file
Lisp File, silo.asd: The silo<dot>asd file
Lisp File, silo/base/lisp.lisp: The silo/base/lisp<dot>lisp file
Lisp File, silo/interface/lisp.lisp: The silo/interface/lisp<dot>lisp file
Lisp File, silo/protocol/lisp.lisp: The silo/protocol/lisp<dot>lisp file
liter.asd: The liter<dot>asd file
liter/base/lisp.lisp: The liter/base/lisp<dot>lisp file
liter/file/lisp.lisp: The liter/file/lisp<dot>lisp file
liter/generate/lisp.lisp: The liter/generate/lisp<dot>lisp file
liter/interface/lisp.lisp: The liter/interface/lisp<dot>lisp file
liter/iter-object/lisp.lisp: The liter/iter-object/lisp<dot>lisp file
liter/tools/lisp.lisp: The liter/tools/lisp<dot>lisp file

S
silo.asd: The silo<dot>asd file
silo/base/lisp.lisp: The silo/base/lisp<dot>lisp file
silo/interface/lisp.lisp: The silo/interface/lisp<dot>lisp file
silo/protocol/lisp.lisp: The silo/protocol/lisp<dot>lisp file

Jump to:   C   F   G   L   S  

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

A.2 Functions

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

%
%get-read-function: Internal functions
%plist-feed: Internal functions

(
(setf file-iterator-reader): Internal generic functions
(setf file-iterator-reader): Internal generic functions
(setf file-iterator-stream): Exported generic functions
(setf file-iterator-stream): Exported generic functions
(setf grower-state): Exported generic functions
(setf grower-state): Exported generic functions
(setf sget): Exported generic functions
(setf sget): Exported generic functions
(setf sget): Exported generic functions
(setf sget): Exported generic functions
(setf sget): Exported generic functions
(setf sget): Exported generic functions
(setf sget): Exported generic functions
(setf sget): Exported generic functions

A
alist-key: Exported functions

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

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

E
end-iteration: Exported functions

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

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

I
iaccumulate: Exported functions
ichain: Exported functions
icounter: Exported functions
icycle: Exported functions
icycle*: Exported functions
idrop: Exported functions
idrop-while: Exported functions
ifilter: Exported functions
ifold: Exported functions
ilist: Internal functions
inext: Exported functions
irepeat: Exported compiler macros
irepeat: Exported functions
itake: Exported functions
itake-while: Exported functions
itee: Exported functions
iter-object-end-p: Exported generic functions
iter-object-end-p: Exported generic functions
iter-object-next: Exported generic functions
iter-object-next: Exported generic functions
iter-object-prev: Exported generic functions
iterator-list: Exported functions
itransform: Exported functions
izip: Exported functions
izip-longest: Exported functions
izip-with-index: Exported functions

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

P
plist-grower-default: Internal generic functions
plist-grower-default: Internal generic functions
plist-key: Exported functions

R
reset-grower: Exported generic functions
reset-grower: Exported generic functions
reset-grower: Exported generic functions
reset-grower: Exported generic functions
reset-grower: Exported generic functions
reset-grower: Exported generic functions
rget: Exported macros
rget-apply: Exported functions

S
sdel: Exported generic functions
sdel: Exported generic functions
sget: Exported generic functions
sget: Exported generic functions
sget: Exported generic functions
sget: Exported generic functions
sget: Exported generic functions
sget: Exported generic functions
sget: Exported generic functions
sget: Exported generic functions
singleton-iterator: Exported functions
sremove: Exported generic functions
sremove: Exported generic functions
ssetf: Exported macros
supdate: Exported generic functions
supdate: Exported generic functions
supdate: Exported generic functions
supdate: Exported generic functions

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

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

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

A.3 Variables

Jump to:   *  
D   G   I   K   R   S   T  
Index Entry  Section

*
*default-grower-size*: Internal special variables

D
default-value: Exported classes

G
grower-state: Exported classes
grower-state: Exported classes

I
item: Internal classes

K
key: Internal classes
key-item: Internal classes

R
reader: Exported classes

S
Slot, default-value: Exported classes
Slot, grower-state: Exported classes
Slot, grower-state: Exported classes
Slot, item: Internal classes
Slot, key: Internal classes
Slot, key-item: Internal classes
Slot, reader: Exported classes
Slot, stream: Exported classes
Slot, test: Internal classes
Special Variable, *default-grower-size*: Internal special variables
stream: Exported classes

T
test: Internal classes

Jump to:   *  
D   G   I   K   R   S   T  

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

A.4 Data types

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

%
%alist-ref: Internal classes
%plist-ref: Internal classes

C
Class, %alist-ref: Internal classes
Class, %plist-ref: Internal classes
Class, file-iterator: Exported classes
Class, grower: Exported classes
Class, iter-object: Exported classes
Class, list-grower: Exported classes
Class, plist-grower: Exported classes
Class, prepend-list-grower: Exported classes
colliflower: The colliflower system
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: Exported conditions
Condition, unhandled-iteration-end: Internal conditions

F
file-iterator: Exported classes

G
garten: The garten system
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: Exported classes

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

L
list-grower: Exported classes
liter: The liter system
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: Exported classes
prepend-list-grower: Exported classes

S
silo: The silo system
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: Internal conditions

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