Struct UntaggedOption

pub struct UntaggedOption<T: Zeroable> { /* private fields */ }

A zero-optimized option type that uses no discriminant.

UntaggedOption<T> represents None by storing a zeroed value of T, and Some(value) by any non-zero T. This can save space, especially in FFI or low-level contexts.

Safety

T must be valid in its all-zero bit pattern. Implementing Zeroable for a type that cannot safely be all-zero invokes undefined behavior.

⚠️ Undefined Behavior example:

use core::num::NonZeroU32;
use std_fork::zeroable::Zeroable;

unsafe impl Zeroable for NonZeroU32 {} // ⚠️ Undefined Behavior!

✅ Safe example:

use std_fork::option::UntaggedOption;
use std_fork::zeroable::Zeroable;

#[derive(Debug, PartialEq, Clone, Copy)]
#[repr(C)]
struct MyInt(u32);

unsafe impl Zeroable for MyInt {}

let opt = UntaggedOption::some(MyInt(123));
assert!(opt.is_some());

Implementations

impl<T> UntaggedOption<T>

where T: Zeroable,

pub const T_SIZE: usize

Size of the inner type T.

pub const IS_ZST: bool

True if T is a zero-sized type (ZST).

pub const NONE: Self

A constant representing None.

pub const fn some(value: T) -> Self

Creates a new UntaggedOption containing a value.

Example

use std_fork::option::UntaggedOption;
use std_fork::zeroable::Zeroable;

#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(transparent)]
struct Wrapper(u32);

unsafe impl Zeroable for Wrapper {}

let opt = UntaggedOption::some(Wrapper(1));
assert!(opt.is_some());

pub const fn none() -> Self

Creates a new UntaggedOption representing None.

Example

use std_fork::option::UntaggedOption;

let none = UntaggedOption::<u32>::none();
assert!(none.is_none());

pub fn is_none(&self) -> bool

Returns true if the option is None.

Note

Zero-sized types (ZSTs) always return true.

Example

use std_fork::option::UntaggedOption;

let none = UntaggedOption::<u32>::none();
assert!(none.is_none());

let some = UntaggedOption::some(123u32);
assert!(!some.is_none());

pub fn is_some(&self) -> bool

Returns true if the option contains a value.

Example

use std_fork::option::UntaggedOption;

let opt = UntaggedOption::some(7i32);
assert!(opt.is_some());

let none = UntaggedOption::<()>::none();
assert!(!none.is_some());

pub fn take(&mut self) -> Option<T>

Takes the value out of the option, leaving a None in its place.

Example

use std_fork::option::UntaggedOption;
use std_fork::zeroable::Zeroable;

#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(C)]
struct MyInt(i32);

unsafe impl Zeroable for MyInt {}

let mut opt = UntaggedOption::some(MyInt(42));
let taken = opt.take();

assert_eq!(taken, Some(MyInt(42)));
assert!(opt.is_none());

pub fn as_ref(&self) -> Option<&T>

Returns a reference to the value if Some, otherwise returns None.

Example

use std_fork::option::UntaggedOption;

let opt = UntaggedOption::some(999u32);
assert_eq!(opt.as_ref(), Some(&999));

let none = UntaggedOption::<u32>::none();
assert_eq!(none.as_ref(), None);

pub fn as_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the value if Some, otherwise returns None.

Example

use std_fork::option::UntaggedOption;

let mut opt = UntaggedOption::some(100i32);

if let Some(val) = opt.as_mut() {
    *val += 1;
}

assert_eq!(opt.as_ref(), Some(&101));

Trait Implementations

impl<T: Debug + Zeroable> Debug for UntaggedOption<T>

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

Formats the value using the given formatter.

impl<T> From<Option<T>> for UntaggedOption<T>

where T: Zeroable,

fn from(value: Option<T>) -> Self

Converts a standard Option<T> into an UntaggedOption<T>.

Example

use std_fork::option::UntaggedOption;

let opt = UntaggedOption::from(Some(255u8));
assert!(opt.is_some());

let none = UntaggedOption::from(None::<u8>);
assert!(none.is_none());

impl<T: PartialEq + Zeroable> PartialEq for UntaggedOption<T>

fn eq(&self, other: &Self) -> 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.