You are looking at historical revision 21532 of this page. It may differ significantly from its current revision.

• egg

sequences

Introduction

Operations over generic or user-defined sequences.

Note: this is currently under review - the API might still change

Usage

`(require-extension sequences)`

Requirements

fast-generic

This extension requires CHICKEN 4.6.3 or newer.

Documentation

A sequence is a collection of objects and may be either one of the built-in types vector, list or string, or the result of the sequence-constructors make-linear-sequence and make-random-access-sequences. A linear sequence is a sequence that only allows element-by-element access (i.e. a list), a random access sequences allows access to arbitrary elements through an index (i.e. vectors or strings).

An iterator is an object that designates a particular position in a linear or random-access sequence.

Basic sequence operations

size
[procedure] (size S)

Returns the number of elements in the sequence S. For linear sequences, this operation traverses all elements.

elt
[procedure] (elt S I)

Returns the I-th element of S. I may be an exact integer or an iterator (see below).

A sequence-element can be modified with (set! (elt S I) X).

If I is an iterator, then S must be the same sequence that had been used to construct the iterator.

rev
[procedure] (rev S)

Returns a new sequence of the same type with the elements of S in reverse order.

foldl
[procedure] (foldl PROC SEED S)

Performs a left "fold" over the sequence S, where the procedure PROC is applied to its previous result (or SEED for the first element) and each sequence-element.

foldr
[procedure] (foldr PROC SEED S)

A right "fold" over sequence S, PROC is applied to each sequence element and the result of its last invocation (or SEED for the first element).

sub
[procedure] (sub S START [END])

Returns a new sequence with the elements of S, starting at position START up to but not including the element at position END. If END is not given, all remaining elements are returned. START and END may be exact integers or iterators.

A range of elements may be modified by executing (set! (sub S1 START [END]) S2), which assigns the elements of S2 to the designated locations of sequence S1.

Predicates

sequence?
[procedure] (sequence? X)

Returns #t if X is a sequence or #f otherwise.

linear-sequence?
[procedure] (linear-sequence? X)

Reurns #t if X is a list or a sequence created with make-linear-sequence or #f otherwise.

random-access-sequence?
[procedure] (random-access-sequence? X)

Returns #t if X is a vector, a string or a sequence created with make-random-access-sequence, or #f otherwise.

Sequence constructors

make-random-access-sequence
[procedure] (make-random-access-sequence MAKE ELT SIZE)

Returns an object representing a sequence that allows random access to its elements. MAKE should be a procedure of two arguments, a size count and an initial value and should return a collection of elements which will be stored as "data" in the sequence object. ELT should be a procedure of two arguments receiving the "data" and an exact integer index and should return the element inside the data collection at the given position. SIZE should be a procedure that receives the data and returns the number of elements in that collection.

Note that the "data" may be anything - the operators fully define how it is interpreted.

make-linear-sequence
[procedure] (make-linear-sequence MAKE ELT NEXT)

Returns an object representing a sequence that only allows sequential "on-at-a-time" access to its elements. MAKE should be a procedure of two arguments, a size count and an initial value and should return a collection of elements which will be stored as "state" in the sequence object. ELT should be a procedure of one argument receiving the "state" and should return the element inside the collection that is represented by the currently stored state. NEXT should be a procedure that receives the current state and returns a new state representing the underlying collection that will make the next element accessible via ELT. If the collection has run out of elements, NEXT should return #f.

make
[procedure] (make S LENGTH INIT)

Creates a sequence of the same type as S with LENGTH elements that have the initial value INIT.

sequence
[procedure] (sequence S X1 ...)

Creates a sequence of the same type as S with X1, ... as its initial elements.

Iterators

iterator?
[procedure] (iterator? X)

Returns #t if X is an iterator object or #f otherwise.

linear-iterator?
[procedure] (linear-iterator? X)

Returns #t if X is an iterator on a linear sequence or #f otherwise.

random-access-iterator?
[procedure] (random-access-iterator? X)

Returns #t if X is an iterator on a random-access sewuence or #f otherwise.

iterator
[procedure] (iterator S [INDEX])

Returns an iterator object over sequence S, optionally starting at osition INDEX (an exact integer).

at-end?
[procedure] (at-end? ITERATOR)

Returns #t if ITERATOR points past the lat element of its associated sequence or #f otherwise.

[procedure] (advance ITERATOR [STEPS])
[procedure] (advance! ITERATOR [STEPS])

Returns a new iterator (or modifies the given iterator in case of advance!) pointing to the next element of the associated sequence or to the element at the position I + STEPS, where I is the current index of ITERATOR.

index
[procedure] (index ITERATOR)

Returns the exact integer index of the position to which ITERATOR points to.

Iteration constructs

for*
[procedure] (for PROC S)
[procedure] (for* PROC S)

Invokes PROC for each element in sequence and returns an undefined result. for* operates as for but invokes PROC with the sequence S and an iterator pointing to the current element.

smap*
[procedure] (smap S1 PROC S2)
[procedure] (smap S1 PROC S2)

Applies PROC to each element in the sequence S2 and returns a new sequence of the same type as S1 constructed of the results returned by PROC.

Other operations

coerce
[procedure] (coerce S1 S2)

Returns a new sequence of the same type as S1 containing the elements of S2.

copy
[procedure] (copy S)

Returns a copy of the sequence S.

Author

felix

```Copyright (c) 2010, Felix L. Winkelmann

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.```

0.1
initial release