(rapid set)

Sets and bags compatible with SRFI 113.

(set comparator . elements)

(bag comparator . elements)

(set-unfold stop? mapper successor seed comparator)

(bag-unfold stop? mapper successor seed comparator)

(set-contains? set element)

(bag-contains? bag element)

(set-empty? set)

(bag-empty? bag)

(set-disjoint? set1 set2)

(bag-disjoint? bag1 bag2)

(set-member set element default)

(bag-member bag element default)

(set-element-comparator set)

(bag-element-comparator bag)

(set-adjoin set . elements)

(bag-adjoin bag . elements)

set-adjoin!

bag-adjoin!

(set-replace set element)

(bag-replace bag element)

set-replace!

bag-replace!

(set-delete set . elements)

(bag-delete bag . elements)

set-delete!

bag-delete!

(set-delete-all set elements)

(bag-delete-all bag elements)

set-delete-all!

bag-delete-all!

(set-search! set element failure success)

(bag-search! bag element failure success)

(set-size set)

(bag-size bag)

(set-find predicate set failure)

(bag-find predicate bag failure)

(set-count predicate set)

(bag-count predicate bag)

(set-any? predicate set)

(bag-any? predicate bag)

(set-every? predicate set)

(bag-every? predicate bag)

(set-map proc comparator set)

(bag-map proc comparator bag)

(set-for-each proc set)

(bag-for-each proc bag)

(set-fold proc nil set)

(bag-fold proc nil bag)

(set-filter predicate set)

(bag-filter predicate bag)

set-filter!

bag-filter!

(set-remove predicate set)

(bag-remove predicate bag)

set-remove!

bag-remove!

(set-partition predicate set)

(bag-partition predicate bag)

set-partition!

bag-partition!

(set-copy set)

(bag-copy bag)

(set->list set)

(bag->list bag)

(list->set comparator lst)

(list->bag comparator lst)

(list->set! set lst)

(list->bag! bag lst)

(set=? set . sets)

(bag=? bag . bags)

(set<? set . sets)

(set>? set . sets)

(set<=? set . sets)

(set>=? set . sets)

(bag<=? . args)

(bag>? . args)

(bag<? . args)

(bag>=? . args)

(set-union set . sets)

(set-intersection set . sets)

(set-difference set . sets)

(set-xor set1 set2)

set-union!

set-intersection!

set-difference!

set-xor!

(bag-union bag . bags)

(bag-intersection bag . bags)

(bag-difference bag . bags)

(bag-xor bag1 bag2)

bag-union!

bag-intersection!

bag-difference!

bag-xor!

(bag-sum bag . bags)

bag-sum!

(bag-product n bag)

bag-product!

(bag-unique-size bag)

(bag-element-count bag element)

(bag-for-each-unique proc bag)

(bag-fold-unique proc nil bag)

bag-increment!

(bag-decrement! bag element count)

(bag->set bag)

(set->bag set)

(set->bag! bag set)

(bag->alist bag)

(alist->bag comparator alist)

set-comparator

bag-comparator