no-std cbitset

A bit set, being able to hold a fixed amount of booleans in an array of integers

2 unstable releases

0.2.0 May 26, 2019
0.1.0 Sep 22, 2018

#118 in No standard library

Download history 64/week @ 2020-03-16 101/week @ 2020-03-23 74/week @ 2020-03-30 85/week @ 2020-04-06 131/week @ 2020-04-13 104/week @ 2020-04-20 123/week @ 2020-04-27 138/week @ 2020-05-04 120/week @ 2020-05-11 141/week @ 2020-05-18 107/week @ 2020-05-25 120/week @ 2020-06-01 69/week @ 2020-06-08 111/week @ 2020-06-15 149/week @ 2020-06-22 80/week @ 2020-06-29

500 downloads per month
Used in 4 crates (2 directly)

MIT license

334 lines

cbitset Crates.io

A bit set, being able to hold a fixed amount of booleans in an array of integers.


There are already quite a few libraries out there for bit sets, but I can't seem to find a #![no_std] one that works with fixed-sized arrays. Most of them seem to want to be dynamic.

cbitset also is repr(transparent), meaning the representation of the struct is guaranteed to be the same as the inner array, making it usable from stuff where the struct representation is important, such as relibc.


I think this is a relatively common thing to do in C, for I stumbled upon the concept in the MUSL standard library. An example is its usage in strspn.

While it's a relatively easy concept, the implementation can be pretty unreadable. So maybe it should be abstracted away with some kind of... zero cost abstraction?


Bit sets are extremely cheap. You can store any number from 0 to 255 in an array of 4x 64-bit numbers. Lookup should in theory be O(1). An example usage of this is once again strspn. Here it is in rust, using this library:

/// The C standard library function strspn, reimplemented in rust. It works by
/// placing all allowed values in a bit set, and returning on the first
/// character not on the list. A BitSet256 uses no heap allocations and only 4
/// 64-bit integers in stack memory.
fn strspn(s: &[u8], accept: &[u8]) -> usize {
    let mut allow = BitSet256::new();

    for &c in accept {
        allow.insert(c as usize);

    for (i, &c) in s.iter().enumerate() {
        if !allow.contains(c as usize) {
            return i;