Struct Nominal

pub struct Nominal<T, M> { /* private fields */ }

Nominal wrapper struct

This struct is zero cost; it is simply a type safe wrapper.

Newtypes are primarily created with assistance from the nominal and nominal_mod macros. The macros will help save you the boilerplate of writing the types and declaring unit structs to use as the marker.

Implementations

impl<T, M> Nominal<T, M>

pub fn new(item: T) -> Self

Creates a nominal struct with the given value

pub fn into_inner(self) -> T

Unwraps the nominal struct and returns the value

pub fn as_value_ref(&self) -> &T

Gets a reference to the wrapped value

Note: Deref is not implemented on purpose, to prevent unintentional auto-derefs

pub fn as_value_mut(&mut self) -> &mut T

Gets a mut reference to the wrapped value

Note: DerefMut is not implemented on purpose, to prevent unintentional auto-derefs

pub fn with_other_marker<M2>(self) -> Nominal<T, M2>

Unwraps and rewraps the value as another nominal type, without modifying the wrapped value

If you’re using this function, make sure you know why you’re using it! after all, the whole point of this is to seperate otherwise identical types into newtypes based on semantic meaning.

pub fn map<T2, F>(self, f: F) -> Nominal<T2, M>

where F: FnOnce(T) -> T2,

Consumes and maps the wrapped value into another value, wrapping it in a nominal type with the same marker

pub async fn map_async<T2, F, Fu>(self, f: F) -> Nominal<T2, M>

where F: FnOnce(T) -> Fu, Fu: IntoFuture<Output = T2>,

Consumes and asyncronously maps the wrapped value into another value, wrapping it in a nominal type with the same marker

impl<T, M, E> Nominal<Result<T, E>, M>

pub fn transpose(self) -> Result<Nominal<T, M>, E>

Transpose a nominal wrapped Result into a Result of a nominal wrapped value

The value gets wrapped, but the error does not. Both are not otherwise modified in any way.

pub fn map_result_ok<T2, F>(self, f: F) -> Nominal<Result<T2, E>, M>

where F: FnOnce(T) -> T2,

Maps the Ok value of a Result, wrapping the resulting Result in a nominal type with the same marker

pub fn map_result_err<E2, F>(self, f: F) -> Nominal<Result<T, E2>, M>

where F: FnOnce(E) -> E2,

Maps the Err value of a Result, wrapping the resulting Result in a nominal type with the same marker

impl<T, M> Nominal<Option<T>, M>

pub fn transpose(self) -> Option<Nominal<T, M>>

Transpose a nominal wrapped Option into an Option of a nominal wrapped value

The value is not otherwise modified in any way.

pub fn map_option_some<T2, F>(self, f: F) -> Nominal<Option<T2>, M>

where F: FnOnce(T) -> T2,

Maps the Some value of an Option, wrapping the resulting Option in a nominal type with the same marker

Trait Implementations

impl<T, M> Clone for Nominal<T, M>

where T: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, M> Debug for Nominal<T, M>

where T: Debug,

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

Formats the value using the given formatter.

impl<T, M> Default for Nominal<T, M>

where T: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<T, M> Display for Nominal<T, M>

where T: Display,

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

Formats the value using the given formatter.

impl<T, M> From<T> for Nominal<T, M>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T, M> Hash for Nominal<T, M>

where T: Hash,

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

where H: Hasher,

Feeds this value into the given Hasher.

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

where Self: Sized, H: Hasher,

Feeds a slice of this type into the given Hasher.

impl<T, M> Ord for Nominal<T, M>

where T: Ord,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl<T, M, TR, MR> PartialEq<Nominal<TR, MR>> for Nominal<T, M>

where T: PartialEq<TR>,

fn eq(&self, other: &Nominal<TR, MR>) -> bool

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

fn ne(&self, other: &Nominal<TR, MR>) -> bool

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

impl<T, M, TR, MR> PartialOrd<Nominal<TR, MR>> for Nominal<T, M>

where T: PartialOrd<TR>,

fn partial_cmp(&self, other: &Nominal<TR, MR>) -> Option<Ordering>

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

fn lt(&self, other: &Nominal<TR, MR>) -> bool

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

fn le(&self, other: &Nominal<TR, MR>) -> bool

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

fn gt(&self, other: &Nominal<TR, MR>) -> bool

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

fn ge(&self, other: &Nominal<TR, MR>) -> bool

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

impl<T, M> Copy for Nominal<T, M>

where T: Copy,

impl<T, M> Eq for Nominal<T, M>

where T: Eq,