## 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

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`.

##### pos

*[procedure]*

`(pos PRED S)`

Returns the index of the first element in `S` that for which the one argument procedure `PRED` returns true. If `PRED` returns false for all arguments, `#f` is returned.

##### take

*[procedure]*

`(take PRED S)`

Returns a new sequence of the same type as `S` with the elements up to but not including the first element for which the one-argument procedure `PRED` returns `#f`.

##### drop

*[procedure]*

`(drop PRED S)`

Returns a new sequence of the same type as `S` with the elements from the first element for which the one-argument procedure `PRED` returns `#f`.

##### split

*[procedure]*

`(split PRED S)`

Returns two sequences of the same type as `S` holding the elements split at the first position for which the one-argument procedure `PRED` returns `#f`.

##### partition

*[procedure]*

`(partition PRED S)`

Returns two sequences of the same type as `S` holding those elements for which the one-argument procedure `PRED` returns true and false, respectively.

##### fill!

*[procedure]*

`(fill! PROC S [START [END]])`

Calls `PROC` with the sequence `S` and an iterator object over the elements in `S` starting at position `START` up to but not including `END` and returns the modified sequence.

##### all?

*[procedure]*

`(all? PROC S)`

Returns true if `PROC` returns true for all elements of `S`.

##### thereis?

*[procedure]*

`(thereis? PROC S)`

Returns `#t` if `S` contains an element for which `PROC` returns true.

##### empty?

*[procedure]*

`(empty? S)`

Returns true if `S` is of size 0.

##### peek

*[procedure]*

`(peek S)`

Returns the first element of `S`.

##### pop

*[procedure]*

`(pop S)`

Returns all but the first element of `S`.

##### filter

*[procedure]*

`(filter PROTO PROC S)`

Returns a new sequence of the same type as `PROTO` with all elements of `S` for which `PROC` returns true.

#### Set-operations

##### intersection

*[procedure]*

`(intersection PROTO COMPARE S1 ...)`

Returns the intersection of sequences `S1 ...` using the two-argument procedure `COMPARE` to compare the elements. The returned sequence is of the same type as `PROTO`.

##### difference

*[procedure]*

`(difference PROTO COMPARE S1 S2 ...)`

Returns the set-difference of sequences `S2 ...` taken from `S1` using the two-argument procedure `COMPARE` to compare the elements. The returned sequence is of the same type as `PROTO`.

##### union

*[procedure]*

`(union PROTO COMPARE S1 ...)`

Returns the union of sequences `S1 ...` using the two-argument procedure `COMPARE` to compare the elements. The returned sequence is of the same type as `PROTO`.

#### Predicates over sequence types

##### 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.

##### advance

##### advance!

*[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

##### 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

##### 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`.

##### is?

*[procedure]*

`(is? X)`

Returns a single-argument procedure that returns `#t` if the argument is `equal?` to `X` or `#f` otherwise.

#### SRFI-42 comprehensions

(This code was kindly contributed by Thomas Chust)

SRFI-42 comprehensions for sequences are provided using the `:seq` generator, here an example:

(string-ec (:seq x "aAbBcC") (if (char-lower-case? x)) x) ==> "abc"

This is mostly useful with user-defined sequences created by `make-linear-sequence` and `make-random-access-sequence`.

To use this feature, execute

(require-extension sequence-comprehensions)

### Author

### License

Copyright (c) 2010-2011, Felix L. Winkelmann and Thomas Chust All rights reserved. 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.

### Version History

- 0.5
- ported to CHICKEN 5
- 0.4
- removed
`replicate`, renamed`contains?`to`thereis?`, performance tuning - 0.3
- added
`replicate`, various bugfixes - 0.2
- added set-operations and some more
- 0.1
- initial release