This is an egg for CHICKEN 4, the unsupported old release. You're almost certainly looking for the CHICKEN 5 version of this egg, if it exists.
If it does not exist, there may be equivalent functionality provided by another egg; have a look at the egg index. Otherwise, please consider porting this egg to the current version of CHICKEN.
- Outdated egg!
- Basic sequence operations
- Predicates over sequence types
- Sequence constructors
- Iteration constructs
- Other operations
- SRFI-42 comprehensions
- Version History
Operations over generic or user-defined sequences.
Note: this is currently under review - the API might still change
This extension requires CHICKEN 4.6.3 or newer.
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.
- size Sprocedure
Returns the number of elements in the sequence S. For linear sequences, this operation traverses all elements.
- elt S Iprocedure
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 Sprocedure
Returns a new sequence of the same type with the elements of S in reverse order.
- foldl PROC SEED Sprocedure
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 PROC SEED Sprocedure
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 S START #!optional ENDprocedure
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 PRED Sprocedure
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 PRED Sprocedure
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 PRED Sprocedure
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 PRED Sprocedure
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 PRED Sprocedure
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! PROC S #!optional START ENDprocedure
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? PROC Sprocedure
Returns true if PROC returns true for all elements of S.
- thereis? PROC Sprocedure
Returns #t if S contains an element for which PROC returns true.
- empty? Sprocedure
Returns true if S is of size 0.
- peek Sprocedure
Returns the first element of S.
- pop Sprocedure
Returns all but the first element of S.
- filter PROTO PROC Sprocedure
Returns a new sequence of the same type as PROTO with all elements of S for which PROC returns true.
- intersection PROTO COMPARE S1 ...procedure
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 PROTO COMPARE S1 S2 ...procedure
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 PROTO COMPARE S1 ...procedure
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.
- sequence? Xprocedure
Returns #t if X is a sequence or #f otherwise.
- linear-sequence? Xprocedure
Reurns #t if X is a list or a sequence created with make-linear-sequence or #f otherwise.
- random-access-sequence? Xprocedure
Returns #t if X is a vector, a string or a sequence created with make-random-access-sequence, or #f otherwise.
- make-random-access-sequence MAKE ELT SIZEprocedure
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 MAKE ELT NEXTprocedure
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 S LENGTH INITprocedure
Creates a sequence of the same type as S with LENGTH elements that have the initial value INIT.
- sequence S X1 ...procedure
Creates a sequence of the same type as S with X1, ... as its initial elements.
- iterator? Xprocedure
Returns #t if X is an iterator object or #f otherwise.
- linear-iterator? Xprocedure
Returns #t if X is an iterator on a linear sequence or #f otherwise.
- random-access-iterator? Xprocedure
Returns #t if X is an iterator on a random-access sewuence or #f otherwise.
- iterator S #!optional INDEXprocedure
Returns an iterator object over sequence S, optionally starting at osition INDEX (an exact integer).
- at-end? ITERATORprocedure
Returns #t if ITERATOR points past the lat element of its associated sequence or #f otherwise.
- advance ITERATOR #!optional STEPSprocedure
- advance! ITERATOR #!optional STEPSprocedure
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 ITERATORprocedure
Returns the exact integer index of the position to which ITERATOR points to.
- for PROC Sprocedure
- for* PROC Sprocedure
- smap S1 PROC S2procedure
- smap S1 PROC S2procedure
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.
- coerce S1 S2procedure
Returns a new sequence of the same type as S1 containing the elements of S2.
- copy Sprocedure
Returns a copy of the sequence S.
- is? Xprocedure
Returns a single-argument procedure that returns #t if the argument is equal? to X or #f otherwise.
(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"
To use this feature, execute
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.
- removed replicate, renamed contains? to thereis?, performance tuning
- added replicate, various bugfixes
- added set-operations and some more
- initial release