The sequence-utilities Module

Overview

The sequence-utilities module implements some useful methods on sequences.

Reference

TODO: These docs are just an auto-generated skeleton so far. https://github.com/dylan-lang/collection-extensions/issues/2

alist-copy Function
Signature:

alist-copy (alist #key key datum cons) => (new-alist)

Parameters:
Values:
alist-delete Function
Signature:

alist-delete (elt alist #key key test) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

apair Function
Signature:

apair (key datum aseq #key cons add) => (new-aseq)

Parameters:
Values:
assoc Function
Signature:

assoc (elt seq #key key test) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

choose-map Generic function
Signature:

choose-map (pred func seq #rest seqs) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

choose-map(<function>, <function>, <sequence>) Method
choose-map(<function>, <function>, <list>) Method
concatenate-map Generic function
Signature:

concatenate-map (func seq #rest seqs) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

concatenate-map(<function>, <sequence>) Method
concatenate-map(<function>, <list>) Method
drop Open Generic function
Signature:

drop (collection k) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

drop(<sequence>, <integer>) Method
find Generic function
Signature:

find (pred seq #key failure) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

find-tail Generic function
Signature:

find-tail (pred seq) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

find-tail(<function>, <sequence>) Method
find-tail(<function>, <pair>) Method
find-tail(<function>, <empty-list>) Method
foldl Function
Signature:

foldl (cons nil lst) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

foldr Function
Signature:

foldr (cons nil lst) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

heads Function
Signature:

heads (lists) => (new-list)

Parameters:

  • lists – An instance of <list>.

Values:

  • new-list – An instance of <list>.

index Generic function
Signature:

index (elt seq #key test failure) => (index)

Parameters:
Values:
last-pair Function
Signature:

last-pair (lst) => (last-pair)

Parameters:

  • lst – An instance of <pair>.

Values:

  • last-pair – An instance of <pair>.

list* Function
Signature:

list* (#rest rest) => (new-list)

Parameters:

  • rest (#rest) – An instance of <object>.

Values:

  • new-list – An instance of <list>.

list? Generic function
Signature:

list? (arg) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

list?(<list>) Method
list?(<object>) Method
null? Generic function
Signature:

null? (arg) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

null?(<empty-list>) Method
null?(<object>) Method
pair-do Function
Signature:

pair-do (func lst #rest lists) => (false)

Parameters:
Values:
pair-foldl Function
Signature:

pair-foldl (cons nil lst) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

pair-foldr Function
Signature:

pair-foldr (cons nil lst) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

pair? Generic function
Signature:

pair? (arg) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

pair?(<pair>) Method
pair?(<object>) Method
partition Function
Signature:

partition (pred seq) => (winners losers)

Parameters:
Values:

  • winners – An instance of <list>.

  • losers – An instance of <list>.

pop! Macro
precedes? Generic function
Signature:

precedes? (elt-1 elt-2 seq #key test not-found) => (precedes?)

Parameters:
Values:
push! Macro
reduce-l Function
Signature:

reduce-l (cons nil lst) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

reduce-r Function
Signature:

reduce-r (cons nil lst) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

reverse-append Open Generic function
Signature:

reverse-append (reversed-head tail) => (new-sequence)

Parameters:
Values:
reverse-append(<sequence>, <sequence>) Method
reverse-append(<list>, <list>) Method
satisfies Generic function
Signature:

satisfies (pred seq #key failure) => (index)

Parameters:
Values:
tabulate Function
Signature:

tabulate (length func #key type) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

tails Function
Signature:

tails (lists) => (#rest results)

Parameters:

  • lists – An instance of <list>.

Values:

  • #rest results – An instance of <object>.

take Open Generic function
Signature:

take (collection k) => (#rest results)

Parameters:
Values:

  • #rest results – An instance of <object>.

take(<sequence>, <integer>) Method
unfold Function
Signature:

unfold (pred f g seed) => (new-list)

Parameters:
Values:

  • new-list – An instance of <list>.

unfold/tail Function
Signature:

unfold/tail (pred f g e seed) => (new-list)

Parameters:
Values:

  • new-list – An instance of <list>.

xpair Function
Signature:

xpair (list elt) => (new-list)

Parameters:
Values:

  • new-list – An instance of <list>.

zip

zip Function

The zip function combines multiple iterables element-wise into tuples, stopping at the shortest iterable.

Signature:

zip (sequence1 sequence2 #key key1 key2) => (zipped)

Parameters:
Values:
Discussion:

The zip function is often classified as a high-order function and a sequence transformation function.

The function operates on two sequences (like range, array, list, deque or string) and transforms them in a <sequence> of pairs, each element from one of the sequences.

If key1 or key2 are not provided, they default to the function identity returning the object. If provided, this function transforms the element before collecting it.

If the sequences provided have different lengths, func:zip automatically truncates the output to the length of the shorter sequence.

Example:

let a = #(1, 2);
let b = #('a', 'b');

let zipped = zip(a, b);
format-out("%=", zipped); // Output: #(#(1, 'a'), #(2, 'b'))
Example:

let a = #('a', 'b');
let b = #(3, 4);

let zipped = zip(a, b, key2: odd?);
format-out("%=", zipped); // Output: #(#('a', #t), ('b', #f))

zip-with

zip-with Function
Signature:

zip-with (function collection #rest more-collections) ⇒ new-collection

Parameters:
Values:
Example:

let a = #(100, 200, 300);
let b = #(1, 2, 3);

let zipped = zip-with(\+, a, b);
format-out("%=", zipped); // Output: #(101, 202, 303)
See also:

map

zip-all

zip-all Function

A zip function that can take any number of iterables as parameters.

Signature:

zip-all (sequences) => (zipped)

Parameters:
Values:
Example:

let a = #(1, 2, 3);
let b = #('a', 'b', 'c');
let c = #(#t, #f, #t);

let zipped = zip-all(a, b, c);

format-out("%=", zipped); // Output: #(#(1, 'a', #t), #(2, 'b', #f), #(3, 'c', #t))