(
alist->bag
[
comparator?
comparator
]
[
list?
alist
]
)
⟹
bag?

(
alist->hash-table
[
list?
alist
]
[
comparator?
comparator
]
arg
...
)
⟹
hash-table?

(
alist->hash-table
[
list?
alist
]
[
comparator?
comparator
]
arg
...
)
⟹
hash-table?
(
alist->hash-table
[
list?
alist
]
[
procedure?
equality-predicate
]
arg
...
)
⟹
hash-table?
(
alist->hash-table
[
list?
alist
]
[
procedure?
equality-predicate
]
[
procedure?
hash-function
]
arg
...
)
⟹
hash-table?

equality-predicate
⟹
(
λ
a
b
)
⟹
boolean?

hash-function
⟹
(
λ
obj
)
⟹
integer?

(
alist->hashmap
[
comparator?
comparator
]
[
list?
alist
]
)
⟹
hashmap?

(
alist->mapping
[
comparator?
comparator
]
[
list?
alist
]
)
⟹
mapping?

(
alist->mapping/ordered
[
comparator?
comparator
]
[
list?
alist
]
)
⟹
mapping?

(lambda (key datum alist) (cons (cons key datum) alist)) Cons a new alist entry mapping key -> datum onto alist.

Make a fresh copy of alist. This means copying each pair that forms an association as well as the spine of the list.

(
alist-delete
key
[
list?
alist
]
)
⟹
list?
(
alist-delete
key
[
list?
alist
]
[
procedure?
=
]
)
⟹
list?

=
⟹
(
λ
a
b
)
⟹
*

alist-delete, alist-delete! alist-delete deletes all associations from alist with the given key, using key-comparison procedure =, which defaults to equal?. The dynamic order in which the various applications of = are made is not specified. Return values may share common tails with the alist argument. The alist is not disordered -- elements that appear in the result alist occur in the same order as they occur in the argument alist. The comparison procedure is used to compare the element keys ki of alist's entries to the key parameter in this way: (= key ki). Thus, one can reliably remove all entries of alist whose key is greater than five with (alist-delete 5 alist <). alist-delete! is the linear-update variant of alist-delete. It is allowed, but not required, to alter cons cells from the alist parameter to construct the result.

(
alist-delete!
key
[
list?
alist
]
)
⟹
list?
(
alist-delete!
key
[
list?
alist
]
[
procedure?
=
]
)
⟹
list?

=
⟹
(
λ
a
b
)
⟹
*

alist-delete, alist-delete! alist-delete deletes all associations from alist with the given key, using key-comparison procedure =, which defaults to equal?. The dynamic order in which the various applications of = are made is not specified. Return values may share common tails with the alist argument. The alist is not disordered -- elements that appear in the result alist occur in the same order as they occur in the argument alist. The comparison procedure is used to compare the element keys ki of alist's entries to the key parameter in this way: (= key ki). Thus, one can reliably remove all entries of alist whose key is greater than five with (alist-delete 5 alist <). alist-delete! is the linear-update variant of alist-delete. It is allowed, but not required, to alter cons cells from the alist parameter to construct the result.

(
and
⟨
test1
⟩
...
)

(
and
⟨
test1
⟩
...
)

Semantics: The test expressions are evaluated from left to right, and if any expression evaluates to #f (see section 6.3), then #f is returned. Any remaining expressions are not evaluated. If all the expressions evaluate to true values, the values of the last expression are returned. If there are no expressions, then #t is returned.

(
and
⟨
test1
⟩
...
)

(
and-let*
(
⟨
claw
⟩
...
)
⟨
body
⟩
)

⟨claw⟩:=

(
⟨
variable
⟩
⟨
expression
⟩
)
(
⟨
expression
⟩
)
⟨
bound-variable
⟩

(
any
[
procedure?
pred
]
[
list?
clist1
]
[
list?
clist2
]
...
)
⟹
*

pred
⟹
(
λ
obj1
obj2
...
)
⟹
*

Applies the predicate across the lists, returning true if the predicate returns true on any application. If there are n list arguments clist1 ... clistn, then pred must be a procedure taking n arguments and returning a single value, interpreted as a boolean (that is, #f means false, and any other value means true). any applies pred to the first elements of the clisti parameters. If this application returns a true value, any immediately returns that value. Otherwise, it iterates, applying pred to the second elements of the clisti parameters, then the third, and so forth. The iteration stops when a true value is produced or one of the lists runs out of values; in the latter case, any returns #f. The application of pred to the last element of the lists is a tail call. Note the difference between find and any -- find returns the element that satisfied the predicate; any returns the true value that the predicate produced. Like every, any's name does not end with a question mark -- this is to indicate that it does not return a simple boolean (#t or #f), but a general value.

(
any?-ec
⟨
qualifier
⟩
...
⟨
test
⟩
)
⟹
boolean?

generator
⟹
generator-macro

⟨qualifier⟩:=

⟨
generator
⟩
(
if
⟨
test
⟩
)
(
not
⟨
test
⟩
)
(
and
⟨
test
⟩
...
)
(
or
⟨
test
⟩
...
)
(
begin
⟨
command
⟩
...
⟨
expression
⟩
)
(
nested
⟨
qualifier
⟩
...
)

Returns a list consisting of the elements of the first list followed by the elements of the other list s. If there are no arguments, the empty list is returned. If there is exactly one argument, it is returned. Otherwise the resulting list is always newly allocated, except that it shares structure with the last argument. An improper list results if the last argument is not a proper list.

append, append! append returns a list consisting of the elements of list1 followed by the elements of the other list parameters. The resulting list is always newly allocated, except that it shares structure with the final listi argument. This last argument may be any value at all; an improper list results if it is not a proper list. All other arguments must be proper lists. append! is the "linear-update" variant of append -- it is allowed, but not required, to alter cons cells in the argument lists to construct the result list. The last argument is never altered; the result list shares structure with this parameter.

(
append-ec
⟨
qualifier
⟩
...
⟨
expression
⟩
)
⟹
list?

generator
⟹
generator-macro

expression
⟹
list?

⟨
generator
⟩
(
if
⟨
test
⟩
)
(
not
⟨
test
⟩
)
(
and
⟨
test
⟩
...
)
(
or
⟨
test
⟩
...
)
(
begin
⟨
command
⟩
...
⟨
expression
⟩
)
(
nested
⟨
qualifier
⟩
...
)

(
append-map
[
procedure?
proc
]
[
list?
list1
]
[
list?
list2
]
...
)
⟹
list?

proc
⟹
(
λ
obj1
obj2
...
)
⟹
list?

append-map, append-map! Equivalent to (apply append (map f clist1 clist2 ...)) and (apply append! (map f clist1 clist2 ...)). Map f over the elements of the lists, just as in the map function. However, the results of the applications are appended together to make the final result. append-map uses append to append the results together; append-map! uses append!. The dynamic order in which the various applications of f are made is not specified.

(
append-map!
[
procedure?
proc
]
[
list?
list1
]
[
list?
list2
]
...
)
⟹
list?

proc
⟹
(
λ
obj1
objs2
...
)
⟹
list?

append-map, append-map! Equivalent to (apply append (map f clist1 clist2 ...)) and (apply append! (map f clist1 clist2 ...)). Map f over the elements of the lists, just as in the map function. However, the results of the applications are appended together to make the final result. append-map uses append to append the results together; append-map! uses append!. The dynamic order in which the various applications of f are made is not specified.

(
append-reverse
[
list?
rev-head
]
[
list?
tail
]
)
⟹
list?
(
append-reverse
[
list?
rev-head
]
tail
)
⟹
*

append-reverse, append-reverse! append-reverse returns (append (reverse rev-head) tail). It is provided because it is a common operation -- a common list-processing style calls for this exact operation to transfer values accumulated in reverse order onto the front of another list, and because the implementation is significantly more efficient than the simple composition it replaces. (But note that this pattern of iterative computation followed by a reverse can frequently be rewritten as a recursion, dispensing with the reverse and append-reverse steps, and shifting temporary, intermediate storage from the heap to the stack, which is typically a win for reasons of cache locality and eager storage reclamation.) append-reverse! is just the linear-update variant -- it is allowed, but not required, to alter rev-head's cons cells to construct the result.

(
append-reverse!
[
list?
rev-head
]
[
list?
tail
]
)
⟹
list?
(
append-reverse!
[
list?
rev-head
]
tail
)
⟹
*

(
apply
[
procedure?
proc
]
arg1
...
[
list?
args
]
)
⟹
*