# (lispkit bitset)
Library `(lispkit bitset)` implements bit sets of arbitrary size. Bit sets are mutable objects. The API of library `(lispkit bitset)` provides functionality to create, to inspect, to compose, and to mutate bit sets efficiently.
**bitset-type-tag** 
Symbol representing the `bitset` type. The `type-for` procedure of library `(lispkit type)` returns this symbol for all bitset objects.
**(bitset? *****obj*****)** 
Returns `#t` if *obj* is a bit set, `#f` otherwise.
**(bitset *****i ...*****)**
Returns a new bit set with bits *i ...* set. Each *i* is a fixnum referring to one bit in the bit set by its ordinality.
**(list->bitset *****list*****)**
Returns a new bit set with bits specified by *list*. Each element in *list* is a fixnum referring to one bit in the bit set by its ordinality.
**(bitset-copy *****bs*****)**
Returns a copy of bit set *bs*.
**(bitset-size *****bs*****)**
Returns the number of bits set in bit set *bs*.
**(bitset-next *****bs*****)** \
\&#xNAN;**(bitset-next *****bs i*****)**
Returns the next bit set in *bs* following bit *i*. If *i* is not provided, the first bit set in *bs* is returned.
**(bitset-empty? *****bs*****)**
Returns `#t` if bit set *bs* is empty, `#f` otherwise.
**(bitset-disjoint? *****bs1 bs2*****)**
Returns `#t` if bit sets *bs1* and *bs2* are disjoint, `#f` otherwise.
**(bitset-subset? *****bs1 bs2*****)**
Returns `#t` if bit set *bs2* is a subset of bit set *bs2*, `#f` otherwise.
**(bitset-contains? *****bs i ...*****)**
Returns `#t` if all bits *i ...* are set in bit set *bs*, `#f` otherwise.
**(bitset-adjoin! *****bs i ...*****)**
Inserts the bits *i ...* into bit set *bs*. `bitset-adjoin!` returns *bs*.
**(bitset-adjoin-all! *****bs list*****)**
Inserts all the bits specified by *list* into bit set *bs*. Each element in *list* is a fixnum referring to one bit in the bit set by its ordinality. `bitset-adjoin-all!` returns *bs*.
**(bitset-delete! *****bs i ...*****)**
Removes the bits *i ...* from bit set *bs*. `bitset-delete!` returns *bs*.
**(bitset-delete-all! *****bs list*****)**
Removes all the bits specified by *list* from bit set *bs*. Each element in *list* is a fixnum referring to one bit in the bit set by its ordinality. `bitset-delete-all!` returns *bs*.
**(bitset-union! *****bs bs1 ...*****)**
Computes the union of bit sets *bs*, *bs1 ...* and stores the result in *bs*. `bitset-union!` returns *bs*.
**(bitset-intersection! *****bs bs1 ...*****)**
Computes the intersection of bit sets *bs*, *bs1 ...* and stores the result in *bs*. `bitset-intersection!` returns *bs*.
**(bitset-difference! *****bs bs1 ...*****)**
Computes the difference between bit sets *bs* and *bs1 ...* and stores the result in *bs*. `bitset-difference!` returns *bs*.
**(bitset-xor! *****bs bs1 ...*****)**
Computes the exclusive disjunction of bit sets *bs*, *bs1 ...* and stores the result in *bs*. `bitset-xor!` returns *bs*.
**(bitset=? *****bs bs1 ...*****)**
Returns `#t` if the bit sets *bs*, *bs1 ...* are all equal, i.e. have the same bits set. Otherwise `#f` is returned.
**(bitset\
Returns `#t` if *bs* is a proper subset of *bs1*, and *bs1* is a proper subset of *bs2*, etc. Otherwise `#f` is returned.
**(bitset>? *****bs bs1 ...*****)**
Returns `#t` if *bs* is a proper superset of *bs1*, and *bs1* is a proper superset of *bs2*, etc. Otherwise `#f` is returned.
**(bitset<=? *****bs bs1 ...*****)**
Returns `#t` if *bs* is a subset of *bs1*, and *bs1* is a subset of *bs2*, etc. Otherwise `#f` is returned.
**(bitset>=? *****bs bs1 ...*****)**
Returns `#t` if *bs* is a superset of *bs1*, and *bs1* is a superset of *bs2*, etc. Otherwise `#f` is returned.
**(bitset->list *****bs*****)**
Returns a list of all bits set in *bs*.
**(bitset-for-each *****proc bs*****)**
Invokes *proc* on each bit set in *bs* in increasing ordinal order.
**(bitset-fold *****proc z bs*****)**
The current state is initialized to z, and *proc* is invoked on each bit of *bs* in increasing ordinal order and the current state, setting the current state to the result. The algorithm is repeated until all the bits of *bs* have been processed. Then the current state is returned.
**(bitset-any? *****pred bs*****)**
Returns `#t` if any application of *pred* to the bits of *bs* returns true, and `#f` otherwise.
**(bitset-every? *****pred bs*****)**
Returns `#t` if every application of *pred* to the bits of *bs* returns true, and `#f` otherwise.
**(bitset-filter *****pred bs*****)**
Returns a new bit set containing the bits from *bs* that satisfy *pred*.
**(bitset-filter! *****pred bs*****)**
Removes all bits from *bs* for which *pred* returns `#f`.
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://www.lisppad.app/libraries/lispkit/lispkit-bitset.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.