Struct TinyStr 

pub struct TinyStr<T: TinyStrInt>(/* private fields */);

A short string packed into a big-endian NonZero integer.

TinyStr stores up to N bytes in a single value that fits in a register, enabling single-instruction equality and ordering comparisons. The big-endian layout means normal integer comparisons result in lexicographic order.

Strings are NUL-padded. Trailing NUL bytes are indistinguishable from padding, so two inputs only differing in trailing NULs will be equal.

Empty strings or strings containing all NUL bytes are not representable.

Examples

let s4 = TinyStr4::new(b"abc").unwrap();
assert_eq!(s4.len(), 3);
assert_eq!(format!("{s4}"), "abc");
assert!(s4 < TinyStr4::from_const(b"abd"));
assert!(s4 > TinyStr4::from_const(b"abb"));

let s8 = TinyStr8::new(b"abcdefg").unwrap();
assert_eq!(s8.len(), 7);
assert_eq!(format!("{s8}"), "abcdefg");
assert_eq!(s8, const { TinyStr8::from_const(b"abcdefg") });

Implementations

impl<T: TinyStrInt> TinyStr<T>

pub fn new(s: &[u8]) -> Option<Self>

Creates a new TinyStr from a byte slice.

Returns None if the slice is empty, only contains NUL bytes, or is too long.

Examples

let s = TinyStr4::new(b"abc").unwrap();
assert_eq!(s.len(), 3);
assert_eq!(format!("{s}"), "abc");

assert!(TinyStr4::new(b"").is_none());
assert!(TinyStr4::new(b"abcde").is_none());

pub const fn from_raw(raw: T) -> Self

Creates a new TinyStr from a raw NonZero integer.

Examples

let raw = NonZero::new(0x61626300).unwrap();
let s = TinyStr4::from_raw(raw);
assert_eq!(s.len(), 3);
assert_eq!(format!("{s}"), "abc");

pub fn len(self) -> usize

Returns the number of bytes in the string.

Examples

assert_eq!(TinyStr4::new(b"a").unwrap().len(), 1);
assert_eq!(TinyStr4::new(b"ab").unwrap().len(), 2);
assert_eq!(TinyStr4::new(b"abc").unwrap().len(), 3);
assert_eq!(TinyStr4::new(b"abcd").unwrap().len(), 4);

impl TinyStr<NonZero<u16>>

pub const fn from_const(s: &[u8]) -> Self

Creates a TinyStr from a byte slice at compile time, panicking if the string is invalid.

Examples

const S: TinyStr<NonZero<u16>> = TinyStr::<NonZero<u16>>::from_const(b"ab");
assert_eq!(S, TinyStr::new(b"ab").unwrap());
assert_eq!(S.to_string(), "ab");
assert_eq!(S.len(), 2);

impl TinyStr<NonZero<u32>>

pub const fn from_const(s: &[u8]) -> Self

Creates a TinyStr from a byte slice at compile time, panicking if the string is invalid.

Examples

const S: TinyStr<NonZero<u32>> = TinyStr::<NonZero<u32>>::from_const(b"ab");
assert_eq!(S, TinyStr::new(b"ab").unwrap());
assert_eq!(S.to_string(), "ab");
assert_eq!(S.len(), 2);

impl TinyStr<NonZero<u64>>

pub const fn from_const(s: &[u8]) -> Self

Creates a TinyStr from a byte slice at compile time, panicking if the string is invalid.

Examples

const S: TinyStr<NonZero<u64>> = TinyStr::<NonZero<u64>>::from_const(b"ab");
assert_eq!(S, TinyStr::new(b"ab").unwrap());
assert_eq!(S.to_string(), "ab");
assert_eq!(S.len(), 2);

Trait Implementations

impl<T: Clone + TinyStrInt> Clone for TinyStr<T>

fn clone(&self) -> TinyStr<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: TinyStrInt> Debug for TinyStr<T>

Writes a debug representation of the string.

Examples

let s = TinyStr4::new(b"abc").unwrap();
assert_eq!(format!("{s:?}"), "TinyStr(\"abc\")");

let invalid = TinyStr4::from_raw(std::num::NonZero::new(0x61FF6200).unwrap());
assert_eq!(format!("{invalid:?}"), "TinyStr([97, 255, 98])");

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: TinyStrInt> Display for TinyStr<T>

Writes the string, replacing any invalid UTF-8 sequences with the replacement character.

This is a comparatively expensive operation, requiring the value to be copied onto the stack and UTF-8 validation.

Examples

let s = TinyStr4::new(b"abc").unwrap();
assert_eq!(format!("{s}"), "abc");

let invalid = TinyStr4::from_raw(std::num::NonZero::new(0x61FF6200).unwrap());
assert_eq!(format!("{invalid}"), "a\u{FFFD}b");

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Hash + TinyStrInt> Hash for TinyStr<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Ord + TinyStrInt> Ord for TinyStr<T>

fn cmp(&self, other: &TinyStr<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq + TinyStrInt> PartialEq for TinyStr<T>

fn eq(&self, other: &TinyStr<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd + TinyStrInt> PartialOrd for TinyStr<T>

fn partial_cmp(&self, other: &TinyStr<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Copy + TinyStrInt> Copy for TinyStr<T>

impl<T: Eq + TinyStrInt> Eq for TinyStr<T>

impl<T: TinyStrInt> StructuralPartialEq for TinyStr<T>