The colliflower Reference Manual

Exported Definitions

file-iterator (class)
file-iterator-stream (method)
(setf file-iterator-stream) (method)
iter-object-end-p (method)
iter-object-next (method)
make-file-iterator (function)
with-file-iterator (macro)

Internal Definitions

%get-read-function (function)
file-iterator-reader (method)
(setf file-iterator-reader) (method)

3.1.11 `liter/iter-object/lisp.lisp`

Parent

liter/iter-object (system)

Location

liter/iter-object.lisp

Packages

liter/iter-object

Exported Definitions

iter-object (class)
iter-object-end-p (generic function)
iter-object-next (generic function)
iter-object-prev (generic function)

3.1.12 `silo/interface/lisp.lisp`

Parent: silo/interface (system)
Location: silo/interface.lisp
Packages: silo/interface

3.1.13 `silo/base/lisp.lisp`

Parent

silo/base (system)

Location

silo/base.lisp

Packages

silo/base

Exported Definitions

alist-key (function)
contains-p (method)
contains-p (method)
contains-p (method)
contains-p (method)
contains-p (method)
contains-p (method)
plist-key (function)
sdel (method)
sget (method)
(setf sget) (method)
sget (method)
(setf sget) (method)
sget (method)
(setf sget) (method)
sget (method)
(setf sget) (method)
sget (method)
(setf sget) (method)
sget (method)
(setf sget) (method)
sget (method)
(setf sget) (method)
supdate (method)
supdate (method)

Internal Definitions

%alist-ref (class)
%plist-ref (class)

3.1.14 `silo/protocol/lisp.lisp`

Parent

silo/protocol (system)

Location

silo/protocol.lisp

Packages

Exported Definitions

contains-p (generic function)
define-sgetter (macro)
rget (macro)
rget-apply (function)
sdel (generic function)
sget (generic function)
(setf sget) (generic function)
sremove (generic function)
sremove (method)
ssetf (macro)
supdate (generic function)
supdate (method)

3.1.15 `garten/interface/lisp.lisp`

Parent: garten/interface (system)
Location: garten/interface.lisp
Packages: garten/interface

3.1.16 `garten/base/lisp.lisp`

Parent

garten/base (system)

Location

garten/base.lisp

Packages

garten/base

Exported Definitions

feed (method)
feed (method)
feed (method)
feed (method)
feed (method)
feed (method)
feed-iterable (method)
fruit (method)
fruit (method)
grower-result (method)
grower-result (method)
make-grower (method)
make-grower (method)
make-grower (method)
reset-grower (method)
reset-grower (method)
reset-grower (method)

Internal Definitions

*default-grower-size* (special variable)

3.1.17 `garten/list/lisp.lisp`

Parent

garten/list (system)

Location

garten/list.lisp

Packages

Exported Definitions

feed (method)
feed (method)
feed (method)
feed (method)
feed (method)
feed-iterable (method)
fruit (method)
grower-result (method)
list-grower (class)
make-grower (method)
make-grower (method)
make-grower (method)
plist-grower (class)
prepend-list-grower (class)
reset-grower (method)

Internal Definitions

%plist-feed (function)
plist-grower-default (method)

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)

3.1.19 `garten/grower/lisp.lisp`

Parent

garten/grower (system)

Location

garten/grower.lisp

Packages

Exported Definitions

feed (generic function)
feed* (function)
feed-iterable (generic function)
feed-iterable (method)
fruit (generic function)
fruit (method)
fruit (method)
grower (class)
grower-result (generic function)
grower-result (method)
grower-result (method)
grower-state (method)
(setf grower-state) (method)
make-grower (generic function)
reset-grower (generic function)
reset-grower (method)

3.1.20 `liter/base/lisp.lisp`

Parent

liter/base (system)

Location

liter/base.lisp

Packages

liter/base

Exported Definitions

do-iterable (macro)
do-iterator (macro)
end-iteration (function)
get-iterator (generic function)
get-iterator (method)
get-iterator (method)
get-iterator (method)
get-iterator (method)
get-iterator (method)
get-iterator (method)
get-iterator (method)
inext (function)
iteration-ended (condition)
iterator-list (function)
make-byte-stream-iterator (function)
make-character-stream-iterator (function)
make-hash-key-iterator (function)
make-hash-value-iterator (function)
make-line-iterator (function)

Internal Definitions

clause-for-in-iterable-2 (macro)
clause-for-in-iterator-1 (macro)
unhandled-iteration-end (condition)

4 Packages

Packages are listed by definition order.

4.1 `colliflower/interface`

Combination of the LITER, SILO, and GARTEN packages.

Source

lisp.lisp (file)

Nicknames

cf
colliflower

Use List

colliflower/ext
garten/interface
silo/interface
liter/interface

4.2 `colliflower/ext`

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

Source

lisp.lisp (file)

Use List

garten/interface
silo/interface
liter/interface
common-lisp

Used By List

colliflower/interface

Exported Definitions

grow-from-iterable (function)

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

iterator
liter

Use List

liter/file
liter/iter-object
liter/tools
liter/generate
liter/base

Used By List

colliflower/interface
colliflower/ext

4.4 `liter/tools`

Source

lisp.lisp (file)

Use List

iterate
liter/generate
liter/base
common-lisp

Used By List

liter/interface

Exported Definitions

iaccumulate (function)
ichain (function)
idrop (function)
idrop-while (function)
ifilter (function)
ifold (function)
itake (function)
itake-while (function)
itee (function)
itransform (function)
izip (function)
izip-longest (function)
izip-with-index (function)

4.5 `liter/generate`

Source

lisp.lisp (file)

Use List

liter/base
common-lisp

Used By List

liter/interface
liter/tools

Exported Definitions

icounter (function)
icycle (function)
icycle* (function)
irepeat (compiler macro)
irepeat (function)
make-iterator (macro)
make-state-iterator (function)
make-state-iterator* (macro)
singleton-iterator (function)

Internal Definitions

ilist (function)

4.6 `liter/file`

Source

lisp.lisp (file)

Use List

liter/iter-object
liter/base
common-lisp

Used By List

liter/interface

Exported Definitions

file-iterator (class)
file-iterator-stream (generic function)
file-iterator-stream (method)
(setf file-iterator-stream) (method)
(setf file-iterator-stream) (generic function)
make-file-iterator (function)
with-file-iterator (macro)

Internal Definitions

%get-read-function (function)
file-iterator-reader (generic function)
file-iterator-reader (method)
(setf file-iterator-reader) (method)
(setf file-iterator-reader) (generic function)

4.7 `liter/iter-object`

Source

lisp.lisp (file)

Nickname

liter-object

Use List

common-lisp

Used By List

liter/interface
liter/file

Exported Definitions

iter-object (class)
iter-object-end-p (generic function)
iter-object-end-p (method)
iter-object-next (generic function)
iter-object-next (method)
iter-object-prev (generic function)

4.8 `silo/interface`

Source

lisp.lisp (file)

Nicknames

s
silo

Use List

silo/base
silo/protocol
common-lisp

Used By List

colliflower/interface
colliflower/ext

4.9 `silo/base`

Source

lisp.lisp (file)

Use List

silo/protocol
common-lisp

Used By List

silo/interface

Exported Definitions

alist-key (function)
plist-key (function)

Internal Definitions

%alist-ref (class)
%plist-ref (class)

4.10 `silo/protocol`

Source

lisp.lisp (file)

Use List

common-lisp

Used By List

silo/interface
silo/base

Exported Definitions

contains-p (generic function)
contains-p (method)
contains-p (method)
contains-p (method)
contains-p (method)
contains-p (method)
contains-p (method)
define-sgetter (macro)
rget (macro)
rget-apply (function)
sdel (generic function)
sdel (method)
sget (generic function)
sget (method)
(setf sget) (method)
sget (method)
(setf sget) (method)
sget (method)
(setf sget) (method)
sget (method)
(setf sget) (method)
sget (method)
(setf sget) (method)
sget (method)
(setf sget) (method)
sget (method)
(setf sget) (method)
(setf sget) (generic function)
sremove (generic function)
sremove (method)
ssetf (macro)
supdate (generic function)
supdate (method)
supdate (method)
supdate (method)

4.11 `garten/interface`

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

Source

lisp.lisp (file)

Nicknames

grow
garten

Use List

garten/tools
garten/base

Used By List

colliflower/interface
colliflower/ext

4.12 `garten/base`

Source

lisp.lisp (file)

Use List

garten/list
garten/grower
liter/base
common-lisp

Used By List

garten/interface

Internal Definitions

*default-grower-size* (special variable)

4.13 `garten/list`

Source

lisp.lisp (file)

Use List

iterate
garten/grower
common-lisp

Used By List

garten/base

Exported Definitions

list-grower (class)
plist-grower (class)
prepend-list-grower (class)

Internal Definitions

%plist-feed (function)
plist-grower-default (generic function)
plist-grower-default (method)

4.14 `garten/tools`

Source

lisp.lisp (file)

Use List

iterate
garten/grower
common-lisp

Used By List

garten/interface

Exported Definitions

with-grower (macro)

Internal Definitions

clause-growing-from-3 (macro)

4.15 `garten/grower`

Source

lisp.lisp (file)

Use List

liter/base
common-lisp

Used By List

garten/tools
garten/base
garten/list

Exported Definitions

feed (generic function)
feed (method)
feed (method)
feed (method)
feed (method)
feed (method)
feed (method)
feed (method)
feed (method)
feed (method)
feed (method)
feed (method)
feed* (function)
feed-iterable (generic function)
feed-iterable (method)
feed-iterable (method)
feed-iterable (method)
fruit (generic function)
fruit (method)
fruit (method)
fruit (method)
fruit (method)
fruit (method)
grower (class)
grower-result (generic function)
grower-result (method)
grower-result (method)
grower-result (method)
grower-result (method)
grower-result (method)
grower-state (generic function)
grower-state (method)
(setf grower-state) (method)
(setf grower-state) (generic function)
make-grower (generic function)
make-grower (method)
make-grower (method)
make-grower (method)
make-grower (method)
make-grower (method)
make-grower (method)
reset-grower (generic function)
reset-grower (method)
reset-grower (method)
reset-grower (method)
reset-grower (method)
reset-grower (method)

4.16 `liter/base`

Source

lisp.lisp (file)

Use List

iterate
common-lisp

Used By List

garten/base
garten/grower
liter/interface
liter/file
liter/tools
liter/generate

Exported Definitions

do-iterable (macro)
do-iterator (macro)
end-iteration (function)
get-iterator (generic function)
get-iterator (method)
get-iterator (method)
get-iterator (method)
get-iterator (method)
get-iterator (method)
get-iterator (method)
get-iterator (method)
inext (function)
iteration-ended (condition)
iterator-list (function)
make-byte-stream-iterator (function)
make-character-stream-iterator (function)
make-hash-key-iterator (function)
make-hash-value-iterator (function)
make-line-iterator (function)

Internal Definitions

clause-for-in-iterable-2 (macro)
clause-for-in-iterator-1 (macro)
unhandled-iteration-end (condition)

5 Definitions

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

5.1 Exported definitions

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)

5.1.2 Compiler macros

Compiler Macro: irepeat V &optional N

Package: liter/generate
Source: lisp.lisp (file)

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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)

5.1.6 Classes

Class: file-iterator ()

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

Package

Source

lisp.lisp (file)

Direct superclasses

iter-object (class)

Direct methods

iter-object-end-p (method)
iter-object-next (method)
file-iterator-reader (method)
file-iterator-reader (method)
file-iterator-stream (method)
file-iterator-stream (method)

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

Source

lisp.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

list-grower (class)
prepend-list-grower (class)
plist-grower (class)

Direct methods

reset-grower (method)
fruit (method)
grower-state (method)
grower-state (method)

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

Source

lisp.lisp (file)

Direct superclasses

grower (class)

Direct methods

fruit (method)
reset-grower (method)
feed-iterable (method)
feed (method)

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

Source

lisp.lisp (file)

Direct superclasses

grower (class)

Direct methods

feed (method)
feed (method)
plist-grower-default (method)

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)

5.2 Internal definitions

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)

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)

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)

5.2.4 Generic functions

Generic Function: file-iterator-reader OBJECT

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

Package

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