mirror of
https://github.com/justinethier/cyclone.git
synced 2025-05-21 14:49:17 +02:00
307 lines
6.9 KiB
Markdown
307 lines
6.9 KiB
Markdown
# SRFI 113 - Sets and bags
|
|
|
|
Sets and bags (also known as multisets) are unordered collections that can contain any Scheme object. Sets enforce the constraint that no two elements can be the same in the sense of the set's associated equality predicate; bags do not.
|
|
|
|
See the [SRFI document](http://srfi.schemers.org/srfi-113/srfi-113.html) for more information.
|
|
|
|
# Index
|
|
|
|
- Constructors:
|
|
[`set `](#set)
|
|
[`set-unfold `](#set-unfold)
|
|
[`bag`](#bag)
|
|
[`bag-unfold`](#bag-unfold)
|
|
|
|
- Predicates:
|
|
[`set? `](#set-1)
|
|
[`set-contains? `](#set-contains)
|
|
[`set-empty? `](#set-empty)
|
|
[`set-disjoint?`](#set-disjoint)
|
|
[`bag? `](#bag-1)
|
|
[`bag-contains? `](#bag-contains)
|
|
[`bag-empty? `](#bag-empty)
|
|
[`bag-disjoint?`](#bag-disjoint)
|
|
|
|
- Accessors:
|
|
[`set-member `](#set-member)
|
|
[`set-element-comparator`](#set-element-comparator)
|
|
[`bag-member `](#bag-member)
|
|
[`bag-element-comparator`](#bag-element-comparator)
|
|
|
|
- Updaters:
|
|
[`set-adjoin `](#set-adjoin)
|
|
[`set-adjoin! `](#set-adjoin-1)
|
|
[`set-replace `](#set-replace)
|
|
[`set-replace! `](#set-replace-1)
|
|
[`set-delete `](#set-delete)
|
|
[`set-delete! `](#set-delete-1)
|
|
[`set-delete-all `](#set-delete-all)
|
|
[`set-delete-all! `](#set-delete-all-1)
|
|
[`set-search! `](#set-search)
|
|
[`bag-adjoin `](#bag-adjoin)
|
|
[`bag-adjoin! `](#bag-adjoin-1)
|
|
[`bag-replace `](#bag-replace)
|
|
[`bag-replace! `](#bag-replace-1)
|
|
[`bag-delete `](#bag-delete)
|
|
[`bag-delete! `](#bag-delete-1)
|
|
[`bag-delete-all `](#bag-delete-all)
|
|
[`bag-delete-all! `](#bag-delete-all-1)
|
|
[`bag-search! `](#bag-search)
|
|
|
|
- The whole set:
|
|
[`set-size `](#set-size)
|
|
[`set-find `](#set-find)
|
|
[`set-count `](#set-count)
|
|
[`set-any? `](#set-any)
|
|
[`set-every?`](#set-every)
|
|
[`bag-size `](#bag-size)
|
|
[`bag-find `](#bag-find)
|
|
[`bag-count `](#bag-count)
|
|
[`bag-any? `](#bag-any)
|
|
[`bag-every?`](#bag-every)
|
|
|
|
- Mapping and folding:
|
|
[`set-map `](#set-map)
|
|
[`set-for-each `](#set-for-each)
|
|
[`set-fold `](#set-fold)
|
|
[`set-filter `](#set-filter)
|
|
[`set-filter! `](#set-filter-1)
|
|
[`set-remove `](#set-remove)
|
|
[`set-remove! `](#set-remove-1)
|
|
[`set-partition `](#set-partition)
|
|
[`set-partition!`](#set-partition-1)
|
|
[`bag-map `](#bag-map)
|
|
[`bag-for-each `](#bag-for-each)
|
|
[`bag-fold `](#bag-fold)
|
|
[`bag-filter `](#bag-filter)
|
|
[`bag-filter! `](#bag-filter-1)
|
|
[`bag-remove `](#bag-remove)
|
|
[`bag-remove! `](#bag-remove-1)
|
|
[`bag-partition `](#bag-partition)
|
|
[`bag-partition!`](#bag-partition-)
|
|
|
|
- Copying and conversion:
|
|
[`set-copy `](#set-copy)
|
|
[`set->list `](#set-list)
|
|
[`list->set `](#list-set)
|
|
[`list->set!`](#list-set-1)
|
|
[`bag-copy `](#bag-copy)
|
|
[`bag->list `](#bag-list)
|
|
[`list->bag `](#list-bag)
|
|
[`list->bag!`](#list-bag-1)
|
|
|
|
- Subsets:
|
|
[`set=? `](#set-2)
|
|
[`set<? `](#set-3)
|
|
[`set>? `](#set-4)
|
|
[`set<=?`](#set-5)
|
|
[`set>=?`](#set-6)
|
|
[`bag=? `](#bag-2)
|
|
[`bag<? `](#bag-3)
|
|
[`bag>? `](#bag-4)
|
|
[`bag<=?`](#bag-5)
|
|
[`bag>=?`](#bag-6)
|
|
|
|
- Set theory operations:
|
|
[`set-union `](#set-union)
|
|
[`set-intersection `](#set-intersection)
|
|
[`set-difference `](#set-difference)
|
|
[`set-xor `](#set-xor)
|
|
[`set-union! `](#set-union-1)
|
|
[`set-intersection!`](#set-intersection-1)
|
|
[`set-difference! `](#set-difference-1)
|
|
[`set-xor! `](#set-xor-1)
|
|
[`bag-union `](#bag-union)
|
|
[`bag-intersection `](#bag-intersection)
|
|
[`bag-difference `](#bag-difference)
|
|
[`bag-xor `](#bag-xor)
|
|
[`bag-union! `](#bag-union-1)
|
|
[`bag-intersection!`](#bag-intersection-1)
|
|
[`bag-difference! `](#bag-difference-1)
|
|
[`bag-xor! `](#bag-xor-1)
|
|
|
|
- Additional bag procedures:
|
|
[`bag-sum `](#bag-sum)
|
|
[`bag-sum! `](#bag-sum-1)
|
|
[`bag-product `](#bag-product)
|
|
[`bag-product! `](#bag-product-1)
|
|
[`bag-unique-size `](#bag-unique-size)
|
|
[`bag-element-count `](#bag-element-count)
|
|
[`bag-for-each-unique`](#bag-for-each-unique)
|
|
[`bag-fold-unique `](#bag-fold-unique)
|
|
[`bag-increment! `](#bag-increment)
|
|
[`bag-decrement! `](#bag-decrement)
|
|
[`bag->set `](#bag-set)
|
|
[`set->bag `](#set-bag)
|
|
[`set->bag! `](#set-bag-1)
|
|
[`bag->alist `](#bag-alist)
|
|
[`alist->bag `](#alist-bag)
|
|
|
|
- Comparators:
|
|
[`set-comparator`](#set-comparator)
|
|
[`bag-comparator`](#bag-comparator)
|
|
|
|
# set
|
|
|
|
(set comparator element ...)
|
|
|
|
Returns a newly allocated empty set. The comparator argument is a SRFI 114 comparator, which is used to control and distinguish the elements of the set. The elements are used to initialize the set.
|
|
|
|
# set-unfold
|
|
|
|
(set-unfold comparator stop? mapper successor seed)
|
|
|
|
Create a newly allocated set as if by set using `comparator`. If the result of applying the predicate `stop?` to `seed` is true, return the set. Otherwise, apply the procedure `mapper` to `seed`. The value that `mapper` returns is added to the set. Then get a new seed by applying the procedure `successor` to `seed`, and repeat this algorithm.
|
|
|
|
# bag
|
|
|
|
# bag-unfold
|
|
|
|
# set?
|
|
|
|
(set? obj)
|
|
|
|
Returns `#t` if `obj` is a set, and `#f` otherwise.
|
|
|
|
# set-contains?
|
|
|
|
(set-contains? set element)
|
|
|
|
Returns `#t` if `element` is a member of `set` and `#f` otherwise.
|
|
|
|
# set-empty?
|
|
|
|
(set-empty? set)
|
|
|
|
Returns `#t` if `set` has no elements and `#f` otherwise.
|
|
|
|
# set-disjoint?
|
|
|
|
(set-disjoint? set1 set2)
|
|
|
|
Returns `#t` if `set1` and `set2` have no elements in common and `#f` otherwise.
|
|
|
|
# bag?
|
|
# bag-contains?
|
|
# bag-empty?
|
|
# bag-disjoint?
|
|
|
|
# set-member
|
|
|
|
(set-member set element default)
|
|
|
|
Returns the element of `set` that is equal, in the sense of `set's` equality predicate, to `element`. If `element` is not a member of `set`, `default` is returned.
|
|
|
|
# set-element-comparator
|
|
|
|
(set-element-comparator set)
|
|
|
|
Returns the comparator used to compare the elements of `set`.
|
|
|
|
# bag-member
|
|
# bag-element-comparator
|
|
|
|
#set-adjoin
|
|
#set-adjoin!
|
|
#set-replace
|
|
#set-replace!
|
|
#set-delete
|
|
#set-delete!
|
|
#set-delete-all
|
|
#set-delete-all!
|
|
#set-search!
|
|
#bag-adjoin
|
|
#bag-adjoin!
|
|
#bag-replace
|
|
#bag-replace!
|
|
#bag-delete
|
|
#bag-delete!
|
|
#bag-delete-all
|
|
#bag-delete-all!
|
|
#bag-search!
|
|
|
|
#set-size
|
|
#set-find
|
|
#set-count
|
|
#set-any?
|
|
#set-every?
|
|
#bag-size
|
|
#bag-find
|
|
#bag-count
|
|
#bag-any?
|
|
#bag-every?
|
|
|
|
#set-map
|
|
#set-for-each
|
|
#set-fold
|
|
#set-filter
|
|
#set-filter!
|
|
#set-remove
|
|
#set-remove!
|
|
#set-partition
|
|
#set-partition!
|
|
#bag-map
|
|
#bag-for-each
|
|
#bag-fold
|
|
#bag-filter
|
|
#bag-remove
|
|
#bag-partition
|
|
#bag-filter!
|
|
#bag-remove!
|
|
#bag-partition!
|
|
|
|
#set-copy
|
|
#set->list
|
|
#list->set
|
|
#list->set!
|
|
#bag-copy
|
|
#bag->list
|
|
#list->bag
|
|
#list->bag!
|
|
|
|
#set=?
|
|
#set<?
|
|
#set>?
|
|
#set<=?
|
|
#set>=?
|
|
#bag=?
|
|
#bag<?
|
|
#bag>?
|
|
#bag<=?
|
|
#bag>=?
|
|
|
|
#set-union
|
|
#set-intersection
|
|
#set-difference
|
|
#set-xor
|
|
#set-union!
|
|
#set-intersection!
|
|
#set-difference!
|
|
#set-xor!
|
|
#bag-union
|
|
#bag-intersection
|
|
#bag-difference
|
|
#bag-xor
|
|
#bag-union!
|
|
#bag-intersection!
|
|
#bag-difference!
|
|
#bag-xor!
|
|
|
|
#bag-sum
|
|
#bag-sum!
|
|
#bag-product
|
|
#bag-product!
|
|
#bag-unique-size
|
|
#bag-element-count
|
|
#bag-for-each-unique
|
|
#bag-fold-unique
|
|
#bag-increment!
|
|
#bag-decrement!
|
|
#bag->set
|
|
#set->bag
|
|
#set->bag!
|
|
#bag->alist
|
|
#alist->bag
|
|
|
|
#set-comparator
|
|
#bag-comparator
|