Integers types which cannot be their minimum/maximum value.
The standard library contains a collection of std::num::NonZeroX
types: integer types which
cannot be zero. This crate extends this idea further by providing NonMinX
/NonMaxX
: integer
types which cannot be their minimum/maximum value.
// Create a regular NonMinU32
let x = 123 as i32;
let y = new.unwrap;
assert_eq!;
// -2147483648 is the minimum value for a 32-bit integer.
let z = new;
assert_eq!;
Memory optimization
Similar to NonZeroX
types, these NonMinX
/NonMaxX
types allow for the niche filling
optimization. This means that types such as Option<NonMinX>
/Option<NonMaxX>
takes up the
same amount of space as X
, while a regular Option<X>
takes up twice the size of X
due to
the need of storing the variant tag.
// Option<u32> is larger than a regular u32
assert!;
// Option<NonMinU32>/Option<NonMaxU32> is the same size as a regular u32.
assert!;
assert!;
While this may seem like a micro-optimization, it becomes important when frequently passing an
Option<X>
around or when creating a large array of Option<X>
.
// 1000 x u32 takes up 4000 bytes
assert!;
// 1000 x Option<u32> takes up 8000 bytes, ouch
assert!;
// 1000 x Option<NonMaxU32> takes up only 4000 bytes
assert!;
Internal details
Internally, these types work by wrapping the existing NonZeroX
types and xor-ing with a mask when
accessing the inner value. This means that there is the cost of a single xor
instruction each
time get
is called.
Supported types
The following types are supported
i8
/u8
i16
/u16
i32
/u32
i64
/u64
i128
/u128
isize
/usize