Faster, more compact implementation of std::borrow::Cow
Faster, more compact implementation of Cow.
Changelog - Documentation - Cargo - Repository
use beef::Cow;
let borrowed: Cow = Cow::borrowed("Hello");
let owned: Cow = Cow::owned(String::from("World"));
assert_eq!(
format!("{} {}!", borrowed, owned),
"Hello World!",
);There are two versions of Cow exposed by this crate:
beef::Cow is 3 words wide: pointer, length, and capacity. It stores the ownership tag in capacity.beef::lean::Cow is 2 words wide, storing length, capacity, and the ownership tag all in one word.Both versions are leaner than the std::borrow::Cow:
use std::mem::size_of;
const WORD: usize = size_of::();
assert_eq!(size_of::>(), 4 * WORD);
assert_eq!(size_of::>(), 3 * WORD);
assert_eq!(size_of::>(), 2 * WORD);The standard library Cow is an enum with two variants:
pub enum Cow where
B: 'a + ToOwned + ?Sized,
{
Borrowed(&'a B),
Owned(::Owned),
}For the most common pairs of values - &str and String, or &[u8] and Vec - this
means that the entire enum is 4 words wide:
Padding
|
v
+-----------+-----------+-----------+-----------+
Borrowed: | Tag | Pointer | Length | XXXXXXXXX |
+-----------+-----------+-----------+-----------+
+-----------+-----------+-----------+-----------+
Owned: | Tag | Pointer | Length | Capacity |
+-----------+-----------+-----------+-----------+Instead of being an enum with a tag, beef::Cow uses capacity to determine whether the
value it's holding is owned (capacity is greater than 0), or borrowed (capacity is 0).
beef::lean::Cow goes even further and puts length and capacity on a single 64 word.
+-----------+-----------+-----------+
beef::Cow | Pointer | Length | Capacity? |
+-----------+-----------+-----------+
+-----------+-----------+
beef::lean::Cow | Pointer | Cap | Len |
+-----------+-----------+Any owned Vec or String that has 0 capacity is effectively treated as a borrowed
value. Since having no capacity means there is no actual allocation behind the pointer,
this is safe.
cargo +nightly benchMicrobenchmarking obtaining a &str reference is rather flaky and you can have widely different results. In general the following seems to hold true:
beef::Cow and beef::lean::Cow are faster than std::borrow::Cow at obtaining a reference &T. This makes sense since we avoid the enum tag branching.beef::Cow is faster at creating borrowed variants, but slower at creating owned variants than std::borrow::Cow.beef::lean::Cow is faster at both.…This crate is distributed under the terms of both the MIT license and the Apache License (Version 2.0). Choose whichever one works best for you.
See LICENSE-APACHE and LICENSE-MIT for details.
No open issues yet, or sync has not completed.