TinyBuf

Optimised container of immutable owned bytes. Stores Arc<dyn AsRef<[u8]>>, Box<[u8]>, Box<dyn AsRef<[u8]>>, Vec<u8>, and [u8; N] for small N values in one single type (no generics) with a direct move—no additional heap allocation or copying.

All TinyBuf values are slices, so you get all of the standard slice methods directly. TinyBuf also implements:

• AsRef<[u8]>
• Clone
• Hash
• PartialEq and Eq
• PartialOrd and Ord
• serde::Serialize and serde::Deserialize (with optional serde feature)

Use case

TinyBuf is optimised for these scenarios:

• You want to provide or accept immutable owned bytes of varying types and lengths.
• You want to provide or accept immutable [u8; N], where N <= 23.

Here are some examples to demonstrate the use case for TinyBuf. For illustration purposes, let's assume we're building an in-memory key-value store, and focus on the values.

Accepting data

Normally, if you wish to accept some owned bytes, you would use a Vec:

```rust struct MyKV { entries: HashMap<&'static str, Vec>, }

impl MyKV { pub fn set(&mut self, key: &'static str, value: Vec) { self.entries.insert(key, value); } } ```

However, this is not optimal for callers who have their bytes in an array, boxed slice, etc. They'd have to reallocate into a new Vec:

rust let kv: MyKV = MyKV::new(); // Fast, direct move, no reallocation or copying. kv.set("vec", vec![0, 4, 2]); // Requires allocating a new Vec and copying into it. kv.set("boxslice", Box::new(&[0, 4, 2]).to_vec()); // Requires allocating a new Vec and copying into it. kv.set("array", [0, 4, 2].to_vec());

So the next approach might be to use generics:

```rust struct MyKV, }

impl { pub fn set(&mut self, key: &'static str, value: V) { self.entries.insert(key, value); } } ```

This works if the value type is always the same. But perhaps you want to accept different types of bytes—maybe different users or subsystems use different types, or sometimes arrays are used for small data to avoid heap allocation. If so, this isn't possible using the above generics approach. Instead, another approach might be to instead use boxed traits:

```rust struct MyKV { entries: HashMap<&'static str, Box

impl MyKV { pub fn get(&self, key: &'static str) -> Option

pub fn set(&mut self, key: &'static str, value: impl AsRef<[u8]>) { self.entries.insert(key, Box::new(value)); } } ```

While this approach allows storing different types of bytes without copying to a Vec, the boxing essentially reverses that optimisation, since calling Box::new will always move it to the heap, even for Box<[u8]> values. This may not be too bad for data already on the heap, since it's only the struct itself, not the data, that is heap allocated, but it still requires a heap allocation of a relatively small size.

This is where TinyBuf comes in:

```rust struct MyKV { entries: HashMap<&'static str, TinyBuf>, }

impl MyKV { pub fn get(&self, key: &'static str) -> Option<&TinyBuf> { self.entries.get(key) }

pub fn set>(&mut self, key: &'static str, value: D) { self.entries.insert(key, value); } }

let kv: MyKV = MyKV::new(); // Fast, direct move, stored inline in TinyBuf, no heap allocation or copying of data. kv.set("boxslice", Box::new(&[0, 4, 2])); kv.set("static", b"my static value"); kv.set("vec", vec![0, 4, 2]); // For small arrays: fast, direct move, stored inline in TinyBuf, no heap allocation or copying of data. kv.set("smallarray", [0, 4, 2]); // If an array is too big, heap allocation is required, so you must explicitly opt in. kv.set("largearray", TinyBuf::fromslice(&[0u8; 24])); // If you already have a Boxboxedasref); kv.set("arc", myarcedasref); // If you have some other type that TinyBuf doesn't support and cannot convert it to one of the supported types, you can created a boxed trait value, which will require heap allocation. kv.set("custom", Box::asrefable_value)); ```