#bitvec search results

As such, I (myrrlyn) have written a draft version of a 1.0 release using `cfg(target_has_atomic)`. It also introduces two newtypes, `Atom<T>` and `Isotope<T>`, that should make its use in projects such as #bitvec easier. Check it out here: crates.io/crates/radium/…

As part of the greater #bitvec project, we maintain a crate called #radium. This abstracts over shared-mutability, allowing code to be generic over whether a memory location is accessed through atomics or not. crates.io/crates/radium

moving into that house, and then unpacking boxes both real and imaginary that have been packed up for about as long as #bitvec itself has existed. But today, I have version 1.0.1! This release is maintenance and complaint fixes only. It includes:

I know Rust's rules and #bitvec's additional demands fairly well, so I instinctively obey them, and don't really push boundaries in user code rather than in my implementation's edge cases. So *to me*, `bits![static mut]` was fine, because I always used it correctly. But.

I have published version 1.0.0 of #bitvec 🎉🎉🎉 crates.io/crates/bitvec/…

It’s done. With the Serde support module reëngineered, the #bitvec 1.0.0 release candidate is API-complete. I need to finish restoring code coverage in the test suite, and write a *lot* of documentation. But we’re on track to end this.

And both of them have defaults (`<O: BitOrder = Lsb0, T: BitStore = usize>`), so it's fine to simply not specify them. But Rust does implicit arguments from the right: see `HashMap<K, V, S = RandomState>`, or `Vec<T, A = Global>`. …#bitvec should be `<T, O>`, not `<O, T>`.

Lastly, the #radium API has been unchanged for some time, and its usage in #bitvec is satisfactory. We are beginning discussions of a 1.0 release. If you use `radium`, we would love to hear from you at the tracker: github.com/bitvecto-rs/ra…

I understand *why* C, C++, and D forbid taking the address of a bitfield. (I don't know offhand if Zig allows it or not.) But the ability to take a bit's address is an immensely powerful capability in #bitvec and one I hope I can impart to other languages as I mature the project.

2. This discusses the rules that enable #bitvec to have the capability of type-level alias awareness, and the algorithm that allows runtime deäliasing upon request. myrrlyn.net/blog/bitvec/al…

I’ve published two articles about some of #bitvec’s engineering core

This bug is impossible to produce in #bitvec, and has been since early 2019. After requests and concept drafts by users, since early 2020 bitvec has been able to eliminate both the original bug and the cost of the fix described here. No wariness needed. hacks.mozilla.org/2021/04/elimin…

#bitvec 0.21 is published. It contains a few small new APIs; the main reason for the minor bump rather than a patch bump is that `bitarr!` no longer produces typenames; `BitArr!` produces types and `bitarr!` produces values.

#bitvec implements the bitwise arithmetic operators against `Iterator<Item = bool>`. My users are basically always combining two bitvec data structures, not one data structure and one arbitrary source, so bit-wise crawl is slow and can be accelerated.

In May I will do a final pass over the book and associated support material. In June I will do a final review. On June 28th, 2021, #bitvec will turn three years old, and I will publish 1.0.

Today I released 0.20.0, the last step in the minor series. #bitvec is feature-complete, API-compatible with today's standard library, and performant. This begins the final countdown to 1.0. The 0.20 series is the release candidate for 1.0.

I have just published #bitvec 0.20.0. This took me a while to do, and touched some more of the core components of the crate. This completes the last features needed for 1.0

I get a lot of user stories from people who use #bitvec to view bit-patterns in memory, which is cool, but this is the first I've seen from someone using it to create a data structure, which is a pattern I have sought to support since the beginning.

If you ignore the custom pointer encoding, #bitvec acts similarly to what I think you're asking: `BitSlice` is a newtype over `[integers]`, passable only by reference, and `BitVec` is an owning handle that points to a `BitSlice` buffer.

My favorite kind of user is the kind I met today: somebody emailed me asking if I could check their work; they were having a bug, weren't sure why. and wondered if I could make sure it wasn't a #bitvec internal error.

This bug is impossible to produce in #bitvec, and has been since early 2019. After requests and concept drafts by users, since early 2020 bitvec has been able to eliminate both the original bug and the cost of the fix described here. No wariness needed. hacks.mozilla.org/2021/04/elimin…

I get this question a lot, so it appears that I need to write out explicitly how #bitvec can and cannot be used. The shortest way to describe the crate is that it is a jeweler's glass Picture: you, a user, wearing magnifying glasses, my crate.