Unit data-structures

This unit contains a collection of procedures related to data structures. This unit is used by default, unless the program is compiled with the -explicit-use option.

Lists

alist-ref

[procedure] (alist-ref KEY ALIST [TEST [DEFAULT]])

Looks up KEY in ALIST using TEST as the comparison function (or eqv? if no test was given) and returns the cdr of the found pair, or DEFAULT (which defaults to #f).

alist-update!

[procedure] (alist-update! KEY VALUE ALIST [TEST])

If the list ALIST contains a pair of the form (KEY . X), then this procedure replaces X with VALUE and returns ALIST. If ALIST contains no such item, then alist-update! returns ((KEY . VALUE) . ALIST). The optional argument TEST specifies the comparison procedure to search a matching pair in ALIST and defaults to eqv?.

atom?

[procedure] (atom? X)

Returns #t if X is not a pair. This is identical to not-pair? from Unit srfi-1 but kept for historical reasons.

rassoc

[procedure] (rassoc KEY LIST [TEST])

Similar to assoc, but compares KEY with the cdr of each pair in LIST using TEST as the comparison procedures (which defaults to eqv?.

butlast

[procedure] (butlast LIST)

Returns a fresh list with all elements but the last of LIST.

chop

[procedure] (chop LIST N)

Returns a new list of sublists, where each sublist contains N elements of LIST. If LIST has a length that is not a multiple of N, then the last sublist contains the remaining elements.

shuffle

Returns LIST with its elements sorted in a random order given by procedure RANDOM.

tail?

[procedure] (tail? X LIST)

Returns true if X is one of the tails (cdr's) of LIST.

Queues

list->queue

[procedure] (list->queue LIST)

Returns LIST converted into a queue, where the first element of the list is the same as the first element of the queue. The resulting queue may share memory with the list and the list should not be modified after this operation.

make-queue

[procedure] (make-queue)

Returns a newly created queue.

queue?

[procedure] (queue? X)

Returns #t if X is a queue, or #f otherwise.

queue->list

[procedure] (queue->list QUEUE)

Returns QUEUE converted into a list, where the first element of the list is the same as the first element of the queue. The resulting list may share memory with the queue object and should not be modified.

queue-add!

[procedure] (queue-add! QUEUE X)

Adds X to the rear of QUEUE.

queue-empty?

[procedure] (queue-empty? QUEUE)

Returns #t if QUEUE is empty, or #f otherwise.

queue-first

[procedure] (queue-first QUEUE)

Returns the first element of QUEUE. If QUEUE is empty an error is signaled

queue-last

[procedure] (queue-last QUEUE)

Returns the last element of QUEUE. If QUEUE is empty an error is signaled

queue-remove!

[procedure] (queue-remove! QUEUE)

Removes and returns the first element of QUEUE. If QUEUE is empty an error is signaled

queue-push-back!

[procedure] (queue-push-back! QUEUE ITEM)

Pushes an item into the first position of a queue, i.e. the next queue-remove! will return ITEM.

queue-push-back-list!

[procedure] (queue-push-back-list! QUEUE LIST)

Pushes the items in item-list back onto the queue, so that (car LIST) becomes the next removable item.

Sorting

merge

Joins two lists in sorted order. merge! is the destructive version of merge. LESS? should be a procedure of two arguments, that returns true if the first argument is to be ordered before the second argument.

sort

[procedure] (sort SEQUENCE LESS?)
[procedure] (sort! SEQUENCE LESS?)

Sort SEQUENCE, which should be a list or a vector. sort! is the destructive version of sort.

sorted?

[procedure] (sorted? SEQUENCE LESS?)

Returns true if the list or vector SEQUENCE is already sorted.

Random numbers

random-seed

[procedure] (random-seed [SEED])

Seeds the random number generator with SEED (an exact integer) or (current-seconds) if SEED is not given.

Strings

conc

[procedure] (conc X ...)

Returns a string with the string-represenation of all arguments concatenated together. conc could be implemented as

(define(conc . args)(apply string-append (map ->string args)))

->string

[procedure] (->string X)

Returns a string-representation of X.

string-chop

[procedure] (string-chop STRING LENGTH)

Returns a list of substrings taken by choppingSTRING every LENGTH characters:

(string-chop "one two three" 4) ==> ("one ""two ""thre""e")

string-chomp

[procedure] (string-chomp STRING [SUFFIX])

If STRING ends with SUFFIX, then this procedure returns a copy of its first argument with the suffix removed, otherwise returns STRING unchanged. SUFFIX defaults to "\n".

string-compare3

Perform a three-way comparison between the STRING1 and STRING2, returning either -1 if STRING1 is lexicographically less than STRING2, 0 if it is equal, or 1 if it s greater. string-compare3-ci performs a case-insensitive comparison.

string-intersperse

[procedure] (string-intersperse LIST [STRING])

Returns a string that contains all strings in LIST concatenated together. STRING is placed between each concatenated string and defaults to " ".

(string-intersperse '("one""two")"three")

is equivalent to

(apply string-append (intersperse '("one""two")"three"))

string-split

[procedure] (string-split STRING [DELIMITER-STRING [KEEPEMPTY]])

Split string into substrings separated by the given delimiters. If no delimiters are specified, a string comprising the tab, newline and space characters is assumed. If the parameter KEEPEMPTY is given and not #f, then empty substrings are retained:

string-translate

[procedure] (string-translate STRING FROM [TO])

Returns a fresh copy of STRING with characters matching FROM translated to TO. If TO is omitted, then matching characters are removed. FROM and TO may be a character, a string or a list. If both FROM and TO are strings, then the character at the same position in TO as the matching character in FROM is substituted.

string-translate*

[procedure] (string-translate* STRING SMAP)

Substitutes elements of STRING according to SMAP. SMAP should be an association-list where each element of the list is a pair of the form (MATCH \. REPLACEMENT). Every occurrence of the string MATCH in STRING will be replaced by the string REPLACEMENT:

substring=?

Returns #t if the strings STRING1 and STRING2 are equal, or #f otherwise. The comparison starts at the positions START1 and START2 (which default to 0), comparing LENGTH characters (which defaults to the minimum of the remaining length of both strings).

substring-index

[procedure] (substring-index WHICH WHERE [START])
[procedure] (substring-index-ci WHICH WHERE [START])

Searches for first index in string WHERE where string WHICH occurs. If the optional argument START is given, then the search starts at that index. substring-index-ci is a case-insensitive version of substring-index.

Combinators

any?

[procedure] (any? X)

Ignores its argument and always returns #t. This is actually useful sometimes.

none?

[procedure] (none? X)

Ignores its argument and always returns #f. This is actually useful sometimes.

always?

[procedure] (always? X)

Ignores its arguments and always returns #t. This is actually useful sometimes.

never?

[procedure] (never? X)

Ignores its arguments and always returns #f. This is actually useful sometimes.

constantly

[procedure] (constantly X ...)

Returns a procedure that always returns the values X ... regardless of the number and value of its arguments.

(constantly X) <=> (lambda args X)

complement

[procedure] (complement PROC)

Returns a procedure that returns the boolean inverse of PROC.

(complement PROC) <=> (lambda(x)(not (PROC x)))

compose

[procedure] (compose PROC1 PROC2 ...)

Returns a procedure that represents the composition of the argument-procedures PROC1 PROC2 ....

noop

o

A single value version of compose (slightly faster). (o) is equivalent to identity.

left-section

[procedure] (left-section PROC ARG0 ...)

Returns a procedure that partially applies some of its arguments starting from the left.

PROC a procedure.

ARG0 ... some prefix of the arguments for PROC.

right-section

[procedure] (right-section PROC ARG0 ...)

Returns a procedure that partially applies some of its arguments starting from the right.

PROC a procedure.

ARG0 ... some reversed suffix of the arguments for PROC.

Binary searching

binary-search

[procedure] (binary-search SEQUENCE PROC)

Performs a binary search in SEQUENCE, which should be a sorted list or vector. PROC is called to compare items in the sequence, should accept a single argument and return an exact integer: zero if the searched value is equal to the current item, negative if the searched value is less than the current item, and positive otherwise. Returns the index of the found value or #f otherwise.