Crate optional

Space-efficient optional values

Booleans

Type OptionBool represents an optional boolean value, similar to Option<bool>. Most function implementations are similar or equal. Note that the map_bool(..) and_bool(..), and_then_bool(..), or_bool(..) and or_else_bool(..) functions are working similar to the methods without the _bool suffix, but require and return OptionBool instead of Option<bool>. This allows people to stay within the type.

The OptionBool type is expected to require only 1 byte of storage:

assert!(1 == std::mem::size_of::<optional::OptionBool>());

However, since this crate was originally authored, improvements in the compiler have built in this optimization for Option<bool> as well. The OptionBool type remains however because it may still perform faster in some bench marks.

assert!(1 == std::mem::size_of::<Option<bool>>());

Any type can be optional

Then there is the Optioned<T> type which wraps a type T as an optional value of T where one particular value represents None. Optioned<T> requires the exact same space as T:

assert!(std::mem::size_of::<optional::Optioned<i64>>() ==
    std::mem::size_of::<i64>());
assert!(std::mem::size_of::<optional::Optioned<f32>>() ==
    std::mem::size_of::<f32>());
assert!(std::mem::size_of::<optional::Optioned<u8>>() ==
    std::mem::size_of::<u8>());

There are implementations for u8..64,usize with std::u..::MAX representing None, also for i8..64,isize with std::i..::MIN representing None, and for f32, f64 with std::f..::NAN representing None.

Using Optioned for your own types is as simple as implementing Noned for your type, provided that your type is already Copy and Sized.

Structs

IterBool

iterate over an OptionBool

Optioned

An Option<T>-like structure that takes only as much space as the enclosed value, at the cost of removing one particular None value from the value domain (see Noned)

OptionedIter

iterate over an Optioned

Enums

OptionBool

The OptionBool type, a space-efficient Option replacement

Traits

Noned

A trait whose implementation for any type T allows the use of Optioned<T> where T is bound by both Sized and Copy.

OptEq

Equality within Optioned

OptOrd

Ordering within Optioned

Functions

none

Create a None Optioned<T>. Note that the type must be inferrible from the context, or you’d need to call with ::<T> where T is the specific type.

some

Create an Optioned<T> that is some(t).

wrap

Wrap a T into an Optioned<T>, regardless of its None-ness.