Sets and bags (multisets) are mutable collections that can contain any Scheme object. Integer sets are mutable collections that can contain non-negative exact integers from 0 to a maximum value that is specified when the integer set is created.
Sets and bags (multisets) are intended to be a thin veneer over hashtables, and integer sets are a thin veneer over bit vectors. Consequently, the -member?, -add!, and -remove! procedures are required to have an amortized cost of O(1).
Sets, bags, and integer sets are mutually disjoint and disjoint from other types of Scheme objects.
(make-set =)
Constructs and returns a new empty set. = is the equality procedure for the set, which must be consistent with eq?. If = is other than eq?, equal, string=?, or string-ci=?, the implementation MAY signal an error. Issue: possibly add eqv? to this list if hash tables support it.
(set = element ...)
Constructs and returns a new set with equality procedure = and containing the elements.
(set-copy set)
Constructs and returns a new set containing the elements of set, with the same equality procedure.
(set? obj)
Returns #t if obj is a set, and #f otherwise.
(set-length? set)
Returns the number of elements in set.
(set-member? set element)
Returns #t if element is a member of set and #f otherwise.
(set-add! set element)
Adds element to set unless it is already a member. Returns unspecified values.
(set-remove! set element)
Removes element from set unless it is not a member. Returns unspecified values.
(set-map proc set)
Applies proc to each element of set in arbitrary order and constructs and returns a new set with the same equality predicate containing the values of the applications. Issue: Should we provide this at all? The fold is sufficient.
(set-for-each proc set)
Applies proc to set in arbitrary order, discarding the returned values. Returns unspecified results.
(set-fold proc nil set)
Invokes proc on each member of set in arbitrary order, passing the result of the previous invocation as a second argument. For the first invocation, nil is used as the second argument. Returns the result of the last invocation.
(set->list set)
Constructs and returns a new list containing the members of set in unspecified order.
(list->set list)
Constructs and returns a new set containing the elements of list.
(set=? set ...)
Returns #t if each set contains the same elements.
(set<? set ...)
Returns #t if each set other than the last is a proper subset of the following set, and #f otherwise.
(set>? set ...)
Returns #t if each set other than the last is a proper superset of the following set, and #f otherwise.
(set<=? set ...)
Returns #t if each set other than the last is a subset of the following set, and #f otherwise.
(set>=? set ...)
Returns #t if each set other than the last is a superset of the following set, and #f otherwise.
(set-union set' other-set'' ...)
Constructs and returns a new set that is the union of set and the other-sets.
(set-intersection set' other-set'' ...)
Constructs and returns a new set that is the intersection of set and the other-sets.
(set-difference set' other-set'' ...)
Constructs and returns a new set that is the difference of set and the union of the other-sets.
(set-xor set other-set ...)
Constructs and returns a new set that is the xor (symmetric difference) of the sets.
(set-union! set other-set ...)
Mutates set to a new set that is the union of set and the other-sets.
(set-intersection! set other-set ...)
Mutates set to a new set that is the intersection of set and the other-sets.
(set-difference! set other-set ...)
Mutates set to a new set that is the difference of set and the union of the other-sets.
(set-xor! set other-set ...)
Mutates set to a new set that is the xor (symmetric difference) of set and the other-sets.
The procedures for creating and manipulating bags are the same as those for sets, except that set is replaced by bag in their names, and that adding an element to a bag is effective even if the bag already contains the element.
(bag-count bag element)
Returns an exact integer representing the number of times that element appears in bag.
(make-integer-set limit)
Constructs and returns a new empty integer set. The possible elements of the set are the exact integers from 0 to limit - 1, where limit is an exact non-negative integer.
(integer-set limit element ...)
Constructs and returns a new integer set. The possible elements of the set are the exact integers from 0 to limit - 1. The set is initialized to contain the elements.
(list->integer-set limit list)
Constructs and returns a new integer set. The possible elements of the set are the exact integers from 0 to limit - 1. The set is initialized to contain the elements of list.
The other integer set procedures are the same as those for sets, except that set is replaced by integer-set in their names. Wherever a newly constructed integer set is returned, it has the same limit as the source set.
set->bag, bag->set, integer-set->bag, and integer-set->set take one argument and do the obvious thing. bag->integer-set and set->integer-set take two arguments, limit and the set or bag, and also do the obvious thing.