The generic-sequences Reference Manual

This is the generic-sequences Reference Manual, version 0.1.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 04:41:07 2022 GMT+0.

1 Introduction

GENERIC-SEQUENCES -- Generic sequences for Common Lisp

GENERIC-SEQUENCES-CONT -- Generic sequence comprehension for Common Lisp

GENERIC-SEQUENCES-ITERATE -- Generic sequence iteration for Common Lisp

GENERIC-SEQUENCES-STREAM -- Lazy streams for Common Lisp

GENERIC-SEQUENCES-TEST -- Unit tests for the generic sequences

Generic Sequences is a library for Common Lisp. It introduces the generic sequences, which are a hybrid between the ordinary lists, lazy streams and iterable sequences that can be found in other programming languages such as C#, F#, Java and Scala.

Each sequence returns an enumerator or NIL. The NIL value means that the sequence is empty. The enumerator is a cons cell, which CAR part has the ordinary meaning for Common Lisp, i.e. it returns the current element, while the CDR-part is different. That part is already a function that returns either the next enumerator or NIL in case of reaching the end of the sequence. In other words, there is a delay before receiving the next element of the sequence, which actually makes many sequences lazy.

Unlike the lazy streams, the enumerator always returns a new continuation of the sequence through the CDR part. It recalculates the next element anew, while the stream would memoize it. When iterating, this makes the enumerator more efficient computationally as the memoization would require some kind of locking in the multi-threaded environment.

At the same time, unlike the C# enumerators, our enumerator is like a list cell, which allows defining the sequence in a more easy and declarative way as if we defined an ordinary list. Macros introduced below simplify this process. There exists even the sequence comprehension similar to the F# sequence expression syntax and the yield construction from C#.

Unfortunately, the approach has a drawback. When iterating the sequence, it allocates a lot of small short-term objects on the heap. But the tests show that the modern List-machines have efficient garbage collectors and sometimes the consing is relatively fast, at least in comparison with calling the generic functions. Along with simplicity of defining the sequences, it was the second reason why I decided to apply the described representation to the enumerators. They are not just as slow as they might seem!

Please read the Generic Sequences Manual in the doc directory for more information.

2 Systems

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

generic-sequences

2.1 `generic-sequences`

Generic sequences for Common Lisp.

Author: David Sorokin
License: MIT
Version: 0.1.1
Source: generic-sequences.asd.
Child Component: src (module).

3 Modules

Modules are listed depth-first from the system components tree.

generic-sequences/src

3.1 `generic-sequences/src`

Source

generic-sequences.asd.

Parent Component

generic-sequences (system).

Child Components

generic-seq-pkg.lisp (file).
generic-seq.lisp (file).
readme (file).
license (file).

4 Files

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

Lisp
Static

4.1 Lisp

generic-sequences/generic-sequences.asd
generic-sequences/src/generic-seq-pkg.lisp
generic-sequences/src/generic-seq.lisp

4.1.1 `generic-sequences/generic-sequences.asd`

Source: generic-sequences.asd.
Parent Component: generic-sequences (system).
ASDF Systems: generic-sequences.

4.1.2 `generic-sequences/src/generic-seq-pkg.lisp`

Source: generic-sequences.asd.
Parent Component: src (module).
Packages: generic-seq.

4.1.3 `generic-sequences/src/generic-seq.lisp`

Dependency

generic-seq-pkg.lisp (file).

Source

generic-sequences.asd.

Parent Component

src (module).

Public Interface

delay-seq (macro).
enum-append (macro).
enum-car (macro).
enum-cdr (macro).
enum-cons (macro).
make-seq (macro).
seq (type).
seq->list (function).
seq->vector (function).
seq-append (function).
seq-car (function).
seq-cdr (function).
seq-compare (function).
seq-cons (function).
seq-count (function).
seq-count-if (function).
seq-count-if-not (function).
seq-cycle (function).
seq-drop (function).
seq-drop-while (function).
seq-drop-while-not (function).
seq-elt (function).
seq-enum (generic function).
seq-equal (function).
seq-every (function).
seq-find (function).
seq-find-if (function).
seq-find-if-not (function).
seq-foreach (function).
seq-interpose (function).
seq-iterate (function).
seq-length (function).
seq-map (function).
seq-mappend (function).
seq-member (function).
seq-member-if (function).
seq-member-if-not (function).
seq-notany (function).
seq-notevery (function).
seq-null (function).
seq-position (function).
seq-position-if (function).
seq-position-if-not (function).
seq-range (function).
seq-reduce (function).
seq-remove (function).
seq-remove-if (function).
seq-remove-if-not (function).
seq-repeat (function).
seq-repeatedly (function).
seq-some (function).
seq-split (function).
seq-split-if (function).
seq-split-if-not (function).
seq-take (function).
seq-take-nth (function).
seq-take-while (function).
seq-take-while-not (function).
seq-zip (function).
seqp (generic function).

Internals

basic-seq (structure).
basic-seq-delayed-enum (reader).
(setf basic-seq-delayed-enum) (writer).
basic-seq-p (function).
copy-basic-seq (function).
copy-delayed-seq (function).
delayed-seq (structure).
delayed-seq-delayed-seq (reader).
(setf delayed-seq-delayed-seq) (writer).
delayed-seq-p (function).
enum-append-2 (function).
enum-reduce (function).
make-basic-seq (function).
make-delayed-seq (function).
seq-every-1 (function).
seq-foreach-1 (function).
seq-map-1 (function).
seq-mappend-1 (function).
seq-notany-1 (function).
seq-notevery-1 (function).
seq-some-1 (function).

4.2.1 `generic-sequences/src/README`

Dependency: generic-seq.lisp (file).
Source: generic-sequences.asd.
Parent Component: src (module).

4.2.2 `generic-sequences/src/LICENSE`

Dependency: readme (file).
Source: generic-sequences.asd.
Parent Component: src (module).

5 Packages

Packages are listed by definition order.

generic-seq

5.1 `generic-seq`

Source

generic-seq-pkg.lisp.

Nickname

gen-seq

Use List

common-lisp.

Public Interface

delay-seq (macro).
enum-append (macro).
enum-car (macro).
enum-cdr (macro).
enum-cons (macro).
make-seq (macro).
seq (type).
seq->list (function).
seq->vector (function).
seq-append (function).
seq-car (function).
seq-cdr (function).
seq-compare (function).
seq-cons (function).
seq-count (function).
seq-count-if (function).
seq-count-if-not (function).
seq-cycle (function).
seq-drop (function).
seq-drop-while (function).
seq-drop-while-not (function).
seq-elt (function).
seq-enum (generic function).
seq-equal (function).
seq-every (function).
seq-find (function).
seq-find-if (function).
seq-find-if-not (function).
seq-foreach (function).
seq-interpose (function).
seq-iterate (function).
seq-length (function).
seq-map (function).
seq-mappend (function).
seq-member (function).
seq-member-if (function).
seq-member-if-not (function).
seq-notany (function).
seq-notevery (function).
seq-null (function).
seq-position (function).
seq-position-if (function).
seq-position-if-not (function).
seq-range (function).
seq-reduce (function).
seq-remove (function).
seq-remove-if (function).
seq-remove-if-not (function).
seq-repeat (function).
seq-repeatedly (function).
seq-some (function).
seq-split (function).
seq-split-if (function).
seq-split-if-not (function).
seq-take (function).
seq-take-nth (function).
seq-take-while (function).
seq-take-while-not (function).
seq-zip (function).
seqp (generic function).

Internals

basic-seq (structure).
basic-seq-delayed-enum (reader).
(setf basic-seq-delayed-enum) (writer).
basic-seq-p (function).
copy-basic-seq (function).
copy-delayed-seq (function).
delayed-seq (structure).
delayed-seq-delayed-seq (reader).
(setf delayed-seq-delayed-seq) (writer).
delayed-seq-p (function).
enum-append-2 (function).
enum-reduce (function).
make-basic-seq (function).
make-delayed-seq (function).
seq-every-1 (function).
seq-foreach-1 (function).
seq-map-1 (function).
seq-mappend-1 (function).
seq-notany-1 (function).
seq-notevery-1 (function).
seq-some-1 (function).

6 Definitions

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

Public Interface
Internals

6.1 Public Interface

Macros
Ordinary functions
Generic functions
Types

6.1.1 Macros

Macro: delay-seq (seq) ¶

Delay the sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Macro: enum-append (&rest enums) ¶

Append the specified enumerators.

Package: generic-seq.
Source: generic-seq.lisp.

Macro: enum-car (enum) ¶

Return the CAR part.

Package: generic-seq.
Source: generic-seq.lisp.

Macro: enum-cdr (enum) ¶

Return the CDR part.

Package: generic-seq.
Source: generic-seq.lisp.

Macro: enum-cons (item enum) ¶

Construct a new enumerator.

Package: generic-seq.
Source: generic-seq.lisp.

Macro: make-seq (&body enum) ¶

Create a sequence by specifying its enumerator.

Package: generic-seq.
Source: generic-seq.lisp.

6.1.2 Ordinary functions

Function: seq->list (seq) ¶

Convert the sequence to a list.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq->vector (seq) ¶

Convert the sequence to a vector.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-append (&rest seqs) ¶

Append the specified sequences.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-car (seq) ¶

Return the head of sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-cdr (seq) ¶

Return the tail of sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-compare (seq-1 seq-2 test &key key) ¶

Compare two sequences where the test function for items must return <0, >0 or 0.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-cons (item seq) ¶

Construct a new sequence that begins with the specified item and ends with the sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-count (item seq &key test key) ¶

Count and return the number of elements in the sequence that satisfy the test.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-count-if (predicate seq &key key) ¶

Count and return the number of elements in the sequence that satisfy the test.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-count-if-not (predicate seq &key key) ¶

Count and return the number of elements in the sequence that satisfy the test.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-cycle (seq) ¶

It returns a lazy infinite sequence obtained by successively repeating the values in the supplied sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-drop (n seq) ¶

Drop the first N elements of the sequence and return the rest.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-drop-while (predicate seq &key key) ¶

SEQ-DROP-WHILE takes a predicate function taking a single argument
and a sequence. It returns a sequence of all items in the original sequence, starting from the first item for which the predicate function returns NIL.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-drop-while-not (predicate seq &key key) ¶

SEQ-DROP-WHILE-NOT takes a predicate function taking a single argument
and a sequence. It returns a sequence of all items in the original sequence, starting from the first item for which the predicate function returns T.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-elt (seq index) ¶

Access the element of the sequence specified by index.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-equal (seq-1 seq-2 &key test key) ¶

Test two sequences for equality.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-every (predicate &rest seqs) ¶

Like the EVERY function but applied to generic sequences.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-find (item seq &key test key) ¶

Search a sequence for an item and return this element; otherwise NIL is returned.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-find-if (predicate seq &key key) ¶

Search a sequence for an item for which the predicate returns T and return this element; otherwise NIL is returned.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-find-if-not (predicate seq &key key) ¶

Search a sequence for an item for which the predicate returns NIL and return this element; otherwise NIL is returned.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-foreach (function &rest seqs) ¶

Apply the specified function to the sequences.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-interpose (value seq) ¶

SEQ-INTERPOSE takes two arguments, a value and a sequence. It returns
a lazy sequence obtained by inserting the supplied value between the values in the sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-iterate (function initial-value) ¶

It returns an infinite lazy sequence obtained by starting with the supplied value, and then by calling the supplied function passing the previous item in the sequence as its argument.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-length (seq) ¶

Return the length of the specified sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-map (function &rest seqs) ¶

Like the MAPCAR function but applied to generic sequences.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-mappend (function &rest seqs) ¶

Like SEQ-MAP but the specified function must return a sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-member (item seq &key test key) ¶

Search a sequence for an item and return the tail of the sequence beginning with this element; otherwise NIL is returned.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-member-if (predicate seq &key key) ¶

Search a sequence for a top-level item for which the predicate returns T and
return the tail of the sequence beginning with this element; otherwise NIL is returned.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-member-if-not (predicate seq &key key) ¶

Search a sequence for a top-level item for which the predicate returns NIL and return the tail of the sequence beginning with this element; otherwise NIL is returned.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-notany (predicate &rest seqs) ¶

Like the NOTANY function but applied to generic sequences.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-notevery (predicate &rest seqs) ¶

Like the NOTEVERY function but applied to generic sequences.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-null (seq) ¶

Test whether the sequence is empty.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-position (item seq &key test key) ¶

Search a sequence for an element and return the index within the sequence; otherwise, NIL is returned.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-position-if (predicate seq &key key) ¶

Search a sequence for an element for which the predicate returns T and return the index within the sequence; otherwise, NIL is returned.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-position-if-not (predicate seq &key key) ¶

Search a sequence for an element for which the predicate returns NIL and return the index within the sequence; otherwise, NIL is returned.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-range (&key start end step) ¶

SEQ-RANGE returns a lazy sequence of numbers from the start (inclusive, 0 by default) to the end (exclusive, nil by default) incremented by the step (1 by default).

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-reduce (function seq &key key initial-value) ¶

Like REDUCE but applied to the generic sequences.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-remove (item seq &key test key) ¶

Like the REMOVE function but applied to the generic sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-remove-if (test seq &key key) ¶

Like the REMOVE-IF function but applied to the generic sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-remove-if-not (test seq &key key) ¶

Like the REMOVE-IF-NOT function but applied to the generic sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-repeat (value) ¶

It returns an infinite lazy sequence consisting of the argument value repeated endlessly.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-repeatedly (function) ¶

Return an infinite lazy sequence obtained by calling the function repeatedly.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-some (predicate &rest seqs) ¶

Like the SOME function but applied to generic sequences.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-split (n seq) ¶

Split the sequence at the N-th element and return the both parts as a list.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-split-if (predicate seq &key key) ¶

SEQ-SPLIT-IF takes a predicate function taking a single argument
and a sequence. It splits the sequence at the first item for which the predicate function returns T and and then SEQ-SPLIT-IF returns the both parts as a list.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-split-if-not (predicate seq &key key) ¶

SEQ-SPLIT-IF-NOT takes a predicate function taking a single argument
and a sequence. It splits the sequence at the first item for which the predicate function returns NIL and then SEQ-SPLIT-IF-NOT returns the both parts as a list.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-take (n seq) ¶

Take the first N elements of the sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-take-nth (n seq) ¶

TAKE-NTH takes two arguments, a number and a sequence. It returns a sequence of items from the supplied sequence, taking the first item and every Nth item, where N is the supplied number.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-take-while (predicate seq &key key) ¶

SEQ-TAKE-WHILE takes a predicate function taking a single argument
and a sequence. It returns a sequence of all items in the original sequence, up until the first item for which the predicate function returns NIL.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-take-while-not (predicate seq &key key) ¶

SEQ-TAKE-WHILE-NOT takes two arguments, a predicate function taking a single argument and a sequence. It returns a sequence of all items in the original sequence, up until the first item for which the predicate function returns T.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-zip (&rest seqs) ¶

Return a sequence that returns lists of items from the provided sequences.

Package: generic-seq.
Source: generic-seq.lisp.

6.1.3 Generic functions

Generic Function: seq-enum (seq) ¶

Returns either NIL or an enumerator.

Package

generic-seq.

Source

generic-seq.lisp.

Methods

Method: seq-enum ((seq vector)) ¶

Method: seq-enum ((seq list)) ¶

Method: seq-enum ((seq delayed-seq)) ¶

Method: seq-enum ((seq basic-seq)) ¶

Generic Function: seqp (seq) ¶

Test whether this is a sequence.

Package

generic-seq.

Source

generic-seq.lisp.

Methods

Method: seqp ((seq vector)) ¶

Method: seqp ((seq list)) ¶

Method: seqp ((seq delayed-seq)) ¶

Method: seqp ((seq basic-seq)) ¶

Method: seqp (seq) ¶

6.1.4 Types

Type: seq () ¶

The generic sequence type.

Package: generic-seq.
Source: generic-seq.lisp.

6.2 Internals

Ordinary functions
Structures

6.2.1 Ordinary functions

Reader: basic-seq-delayed-enum (instance) ¶

Writer: (setf basic-seq-delayed-enum) (instance) ¶

Package: generic-seq.
Source: generic-seq.lisp.
Target Slot: delayed-enum.

Function: basic-seq-p (object) ¶

Package: generic-seq.
Source: generic-seq.lisp.

Function: copy-basic-seq (instance) ¶

Package: generic-seq.
Source: generic-seq.lisp.

Function: copy-delayed-seq (instance) ¶

Package: generic-seq.
Source: generic-seq.lisp.

Reader: delayed-seq-delayed-seq (instance) ¶

Writer: (setf delayed-seq-delayed-seq) (instance) ¶

Package: generic-seq.
Source: generic-seq.lisp.
Target Slot: delayed-seq.

Function: delayed-seq-p (object) ¶

Package: generic-seq.
Source: generic-seq.lisp.

Function: enum-append-2 (enum-1 delayed-enum-2) ¶

Append two enumerators.

Package: generic-seq.
Source: generic-seq.lisp.

Function: enum-reduce (function enum &key key initial-value) ¶

Like REDUCE but applied to the enumerators.

Package: generic-seq.
Source: generic-seq.lisp.

Function: make-basic-seq (&key delayed-enum) ¶

Package: generic-seq.
Source: generic-seq.lisp.

Function: make-delayed-seq (&key delayed-seq) ¶

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-every-1 (predicate seq) ¶

Like EVERY but applied to one generic sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-foreach-1 (function seq) ¶

Apply the specified function to the sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-map-1 (function seq) ¶

Like the MAPCAR function but applied to a single generic sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-mappend-1 (function seq) ¶

Like SEQ-MAP-1 but the specified function must return a sequence. In other words, this is a monadic bind function.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-notany-1 (predicate seq) ¶

Like NOTANY but applied to one generic sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-notevery-1 (predicate seq) ¶

Like NOTEVERY but applied to one generic sequence.

Package: generic-seq.
Source: generic-seq.lisp.

Function: seq-some-1 (predicate seq) ¶

Like SOME but applied to one generic sequence.

Package: generic-seq.
Source: generic-seq.lisp.

6.2.2 Structures

Structure: basic-seq ¶

Represents the basic sequence that is defined only by its enumerator.

Package

generic-seq.

Source

generic-seq.lisp.

Direct superclasses

structure-object.

Direct methods

seq-enum.
seqp.

Direct slots

Slot: delayed-enum ¶

Readers: basic-seq-delayed-enum.
Writers: (setf basic-seq-delayed-enum).

Structure: delayed-seq ¶

The delayed sequence.

Package

generic-seq.

Source

generic-seq.lisp.

Direct superclasses

structure-object.

Direct methods

seq-enum.
seqp.

Direct slots

Slot: delayed-seq ¶

Readers: delayed-seq-delayed-seq.
Writers: (setf delayed-seq-delayed-seq).

Appendix A Indexes

Concepts
Functions
Variables
Data types

A.1 Concepts

A.2 Functions

Jump to:	( B C D E F G M S

	Index Entry	Section

(
	`(setf basic-seq-delayed-enum)`:	Private ordinary functions
	`(setf delayed-seq-delayed-seq)`:	Private ordinary functions

B
	`basic-seq-delayed-enum`:	Private ordinary functions
	`basic-seq-p`:	Private ordinary functions

C
	`copy-basic-seq`:	Private ordinary functions
	`copy-delayed-seq`:	Private ordinary functions

D
	`delay-seq`:	Public macros
	`delayed-seq-delayed-seq`:	Private ordinary functions
	`delayed-seq-p`:	Private ordinary functions

E
	`enum-append`:	Public macros
	`enum-append-2`:	Private ordinary functions
	`enum-car`:	Public macros
	`enum-cdr`:	Public macros
	`enum-cons`:	Public macros
	`enum-reduce`:	Private ordinary functions

F
	`Function, (setf basic-seq-delayed-enum)`:	Private ordinary functions
	`Function, (setf delayed-seq-delayed-seq)`:	Private ordinary functions
	`Function, basic-seq-delayed-enum`:	Private ordinary functions
	`Function, basic-seq-p`:	Private ordinary functions
	`Function, copy-basic-seq`:	Private ordinary functions
	`Function, copy-delayed-seq`:	Private ordinary functions
	`Function, delayed-seq-delayed-seq`:	Private ordinary functions
	`Function, delayed-seq-p`:	Private ordinary functions
	`Function, enum-append-2`:	Private ordinary functions
	`Function, enum-reduce`:	Private ordinary functions
	`Function, make-basic-seq`:	Private ordinary functions
	`Function, make-delayed-seq`:	Private ordinary functions
	`Function, seq->list`:	Public ordinary functions
	`Function, seq->vector`:	Public ordinary functions
	`Function, seq-append`:	Public ordinary functions
	`Function, seq-car`:	Public ordinary functions
	`Function, seq-cdr`:	Public ordinary functions
	`Function, seq-compare`:	Public ordinary functions
	`Function, seq-cons`:	Public ordinary functions
	`Function, seq-count`:	Public ordinary functions
	`Function, seq-count-if`:	Public ordinary functions
	`Function, seq-count-if-not`:	Public ordinary functions
	`Function, seq-cycle`:	Public ordinary functions
	`Function, seq-drop`:	Public ordinary functions
	`Function, seq-drop-while`:	Public ordinary functions
	`Function, seq-drop-while-not`:	Public ordinary functions
	`Function, seq-elt`:	Public ordinary functions
	`Function, seq-equal`:	Public ordinary functions
	`Function, seq-every`:	Public ordinary functions
	`Function, seq-every-1`:	Private ordinary functions
	`Function, seq-find`:	Public ordinary functions
	`Function, seq-find-if`:	Public ordinary functions
	`Function, seq-find-if-not`:	Public ordinary functions
	`Function, seq-foreach`:	Public ordinary functions
	`Function, seq-foreach-1`:	Private ordinary functions
	`Function, seq-interpose`:	Public ordinary functions
	`Function, seq-iterate`:	Public ordinary functions
	`Function, seq-length`:	Public ordinary functions
	`Function, seq-map`:	Public ordinary functions
	`Function, seq-map-1`:	Private ordinary functions
	`Function, seq-mappend`:	Public ordinary functions
	`Function, seq-mappend-1`:	Private ordinary functions
	`Function, seq-member`:	Public ordinary functions
	`Function, seq-member-if`:	Public ordinary functions
	`Function, seq-member-if-not`:	Public ordinary functions
	`Function, seq-notany`:	Public ordinary functions
	`Function, seq-notany-1`:	Private ordinary functions
	`Function, seq-notevery`:	Public ordinary functions
	`Function, seq-notevery-1`:	Private ordinary functions
	`Function, seq-null`:	Public ordinary functions
	`Function, seq-position`:	Public ordinary functions
	`Function, seq-position-if`:	Public ordinary functions
	`Function, seq-position-if-not`:	Public ordinary functions
	`Function, seq-range`:	Public ordinary functions
	`Function, seq-reduce`:	Public ordinary functions
	`Function, seq-remove`:	Public ordinary functions
	`Function, seq-remove-if`:	Public ordinary functions
	`Function, seq-remove-if-not`:	Public ordinary functions
	`Function, seq-repeat`:	Public ordinary functions
	`Function, seq-repeatedly`:	Public ordinary functions
	`Function, seq-some`:	Public ordinary functions
	`Function, seq-some-1`:	Private ordinary functions
	`Function, seq-split`:	Public ordinary functions
	`Function, seq-split-if`:	Public ordinary functions
	`Function, seq-split-if-not`:	Public ordinary functions
	`Function, seq-take`:	Public ordinary functions
	`Function, seq-take-nth`:	Public ordinary functions
	`Function, seq-take-while`:	Public ordinary functions
	`Function, seq-take-while-not`:	Public ordinary functions
	`Function, seq-zip`:	Public ordinary functions

G
	`Generic Function, seq-enum`:	Public generic functions
	`Generic Function, seqp`:	Public generic functions

M
	`Macro, delay-seq`:	Public macros
	`Macro, enum-append`:	Public macros
	`Macro, enum-car`:	Public macros
	`Macro, enum-cdr`:	Public macros
	`Macro, enum-cons`:	Public macros
	`Macro, make-seq`:	Public macros
	`make-basic-seq`:	Private ordinary functions
	`make-delayed-seq`:	Private ordinary functions
	`make-seq`:	Public macros
	`Method, seq-enum`:	Public generic functions
	`Method, seq-enum`:	Public generic functions
	`Method, seq-enum`:	Public generic functions
	`Method, seq-enum`:	Public generic functions
	`Method, seqp`:	Public generic functions
	`Method, seqp`:	Public generic functions
	`Method, seqp`:	Public generic functions
	`Method, seqp`:	Public generic functions
	`Method, seqp`:	Public generic functions

S
	`seq->list`:	Public ordinary functions
	`seq->vector`:	Public ordinary functions
	`seq-append`:	Public ordinary functions
	`seq-car`:	Public ordinary functions
	`seq-cdr`:	Public ordinary functions
	`seq-compare`:	Public ordinary functions
	`seq-cons`:	Public ordinary functions
	`seq-count`:	Public ordinary functions
	`seq-count-if`:	Public ordinary functions
	`seq-count-if-not`:	Public ordinary functions
	`seq-cycle`:	Public ordinary functions
	`seq-drop`:	Public ordinary functions
	`seq-drop-while`:	Public ordinary functions
	`seq-drop-while-not`:	Public ordinary functions
	`seq-elt`:	Public ordinary functions
	`seq-enum`:	Public generic functions
	`seq-enum`:	Public generic functions
	`seq-enum`:	Public generic functions
	`seq-enum`:	Public generic functions
	`seq-enum`:	Public generic functions
	`seq-equal`:	Public ordinary functions
	`seq-every`:	Public ordinary functions
	`seq-every-1`:	Private ordinary functions
	`seq-find`:	Public ordinary functions
	`seq-find-if`:	Public ordinary functions
	`seq-find-if-not`:	Public ordinary functions
	`seq-foreach`:	Public ordinary functions
	`seq-foreach-1`:	Private ordinary functions
	`seq-interpose`:	Public ordinary functions
	`seq-iterate`:	Public ordinary functions
	`seq-length`:	Public ordinary functions
	`seq-map`:	Public ordinary functions
	`seq-map-1`:	Private ordinary functions
	`seq-mappend`:	Public ordinary functions
	`seq-mappend-1`:	Private ordinary functions
	`seq-member`:	Public ordinary functions
	`seq-member-if`:	Public ordinary functions
	`seq-member-if-not`:	Public ordinary functions
	`seq-notany`:	Public ordinary functions
	`seq-notany-1`:	Private ordinary functions
	`seq-notevery`:	Public ordinary functions
	`seq-notevery-1`:	Private ordinary functions
	`seq-null`:	Public ordinary functions
	`seq-position`:	Public ordinary functions
	`seq-position-if`:	Public ordinary functions
	`seq-position-if-not`:	Public ordinary functions
	`seq-range`:	Public ordinary functions
	`seq-reduce`:	Public ordinary functions
	`seq-remove`:	Public ordinary functions
	`seq-remove-if`:	Public ordinary functions
	`seq-remove-if-not`:	Public ordinary functions
	`seq-repeat`:	Public ordinary functions
	`seq-repeatedly`:	Public ordinary functions
	`seq-some`:	Public ordinary functions
	`seq-some-1`:	Private ordinary functions
	`seq-split`:	Public ordinary functions
	`seq-split-if`:	Public ordinary functions
	`seq-split-if-not`:	Public ordinary functions
	`seq-take`:	Public ordinary functions
	`seq-take-nth`:	Public ordinary functions
	`seq-take-while`:	Public ordinary functions
	`seq-take-while-not`:	Public ordinary functions
	`seq-zip`:	Public ordinary functions
	`seqp`:	Public generic functions
	`seqp`:	Public generic functions
	`seqp`:	Public generic functions
	`seqp`:	Public generic functions
	`seqp`:	Public generic functions
	`seqp`:	Public generic functions

Jump to:	( B C D E F G M S

A.3 Variables

Jump to:	D S

	Index Entry	Section

D
	`delayed-enum`:	Private structures
	`delayed-seq`:	Private structures

S
	`Slot, delayed-enum`:	Private structures
	`Slot, delayed-seq`:	Private structures

Jump to:	D S

A.4 Data types

Jump to:	B D F G L M P R S T

	Index Entry	Section

B
	`basic-seq`:	Private structures

D
	`delayed-seq`:	Private structures

F
	`File, generic-seq-pkg.lisp`:	The generic-sequences/src/generic-seq-pkg․lisp file
	`File, generic-seq.lisp`:	The generic-sequences/src/generic-seq․lisp file
	`File, generic-sequences.asd`:	The generic-sequences/generic-sequences․asd file
	`File, license`:	The generic-sequences/src/license file
	`File, readme`:	The generic-sequences/src/readme file

G
	`generic-seq`:	The generic-seq package
	`generic-seq-pkg.lisp`:	The generic-sequences/src/generic-seq-pkg․lisp file
	`generic-seq.lisp`:	The generic-sequences/src/generic-seq․lisp file
	`generic-sequences`:	The generic-sequences system
	`generic-sequences.asd`:	The generic-sequences/generic-sequences․asd file

L
	`license`:	The generic-sequences/src/license file

M
	`Module, src`:	The generic-sequences/src module

P
	`Package, generic-seq`:	The generic-seq package

R
	`readme`:	The generic-sequences/src/readme file

S
	`seq`:	Public types
	`src`:	The generic-sequences/src module
	`Structure, basic-seq`:	Private structures
	`Structure, delayed-seq`:	Private structures
	`System, generic-sequences`:	The generic-sequences system

T
	`Type, seq`:	Public types

Jump to:	B D F G L M P R S T

The generic-sequences Reference Manual

The generic-sequences Reference Manual

Table of Contents

1 Introduction

2 Systems

2.1 generic-sequences

3 Modules

3.1 generic-sequences/src

4 Files

4.1 Lisp

4.1.1 generic-sequences/generic-sequences.asd

4.1.2 generic-sequences/src/generic-seq-pkg.lisp

4.1.3 generic-sequences/src/generic-seq.lisp

4.2 Static

4.2.1 generic-sequences/src/README

4.2.2 generic-sequences/src/LICENSE

5 Packages

5.1 generic-seq

6 Definitions

6.1 Public Interface

6.1.1 Macros

6.1.2 Ordinary functions

6.1.3 Generic functions

6.1.4 Types

6.2 Internals

6.2.1 Ordinary functions

6.2.2 Structures

Appendix A Indexes

A.1 Concepts

A.2 Functions

A.3 Variables

A.4 Data types

2.1 `generic-sequences`

3.1 `generic-sequences/src`

4.1.1 `generic-sequences/generic-sequences.asd`

4.1.2 `generic-sequences/src/generic-seq-pkg.lisp`

4.1.3 `generic-sequences/src/generic-seq.lisp`

4.2.1 `generic-sequences/src/README`

4.2.2 `generic-sequences/src/LICENSE`

5.1 `generic-seq`