Struct Sigma

pub struct Sigma<Raw: Debug, Invariant: Test<Raw, 1>> { /* private fields */ }

Type that maintains a given invariant.

Implementations

impl<Raw: Debug, Invariant: Test<Raw, 1>> Sigma<Raw, Invariant>

pub fn all<const N: usize>(array: &[Raw; N]) -> &[Sigma<Raw, Invariant>; N]

Check all elements of an array.

pub fn also<OtherInvariant: Test<Raw, 1>>(self) -> Sigma<Raw, OtherInvariant>

Without changing its internal value, view one sigma-typed value as implementing another sigma type by checking the latter invariant at runtime (iff debug assertions are enabled).

Panics

If the latter invariant does not hold.

pub fn also_ref<OtherInvariant: Test<Raw, 1>>( &self, ) -> &Sigma<Raw, OtherInvariant>

Without changing its internal value, view one sigma-typed value as implementing another sigma type by checking the latter invariant at runtime (iff debug assertions are enabled).

Panics

If the latter invariant does not hold.

pub fn check(&self)

Check an invariant if and only if debug assertions are enabled.

Panics

If the invariant does not hold and debug assertions are enabled.

pub fn get(self) -> Raw

Unwrap the internal value that satisfies the invariant. If you’re using this to create another value that should also maintain an invariant, use map instead.

pub fn get_by<Y, F: FnOnce(Raw) -> Y>(self, f: F) -> Y

Unwrap the internal value that satisfies the invariant. If you’re using this to create another value that should also maintain an invariant, use map instead.

pub fn get_by_mut<Y, F: FnOnce(&mut Raw) -> Y>(&mut self, f: F) -> Y

Unwrap the internal value that satisfies the invariant. If you’re using this to create another value that should also maintain an invariant, use map instead.

pub fn get_by_ref<Y, F: FnOnce(&Raw) -> Y>(&self, f: F) -> Y

Unwrap the internal value that satisfies the invariant. If you’re using this to create another value that should also maintain an invariant, use map instead.

pub const fn get_mut(&mut self) -> &mut Raw

Unwrap the internal value that satisfies the invariant. If you’re using this to create another value that should also maintain an invariant, use map instead.

pub const fn get_ref(&self) -> &Raw

Unwrap the internal value that satisfies the invariant. If you’re using this to create another value that should also maintain an invariant, use map instead.

pub fn map<OtherRaw: Debug, OtherInvariant: Test<OtherRaw, 1>, F: FnOnce(Raw) -> OtherRaw>( self, f: F, ) -> Sigma<OtherRaw, OtherInvariant>

Apply a function to a term that implements a given invariant (say, A), then check the output for a (possibly different) invariant (say, B).

pub fn map_mut<Y, F: FnOnce(&mut Raw) -> Y>(&mut self, f: F) -> Y

Apply a function that mutates this value, then check that the operation maintained this invariant.

pub fn map_ref<OtherRaw: Debug, OtherInvariant: Test<OtherRaw, 1>, F: FnOnce(&Raw) -> OtherRaw>( &self, f: F, ) -> Sigma<OtherRaw, OtherInvariant>

Apply a function to a term that implements a given invariant (say, A), then check the output for a (possibly different) invariant (say, B).

pub fn new(raw: Raw) -> Self

Create a new sigma type instance by checking an invariant.

Panics

If the invariant does not hold and debug assertions are enabled.

pub fn try_also<OtherInvariant: Test<Raw, 1>>( self, ) -> Option<Sigma<Raw, OtherInvariant>>

Without changing its internal value, try to view one sigma-typed value as implementing another sigma type by checking the latter invariant at runtime.

Errors

If the latter invariant does not hold.

pub fn try_also_ref<OtherInvariant: Test<Raw, 1>>( &self, ) -> Result<&Sigma<Raw, OtherInvariant>, OtherInvariant::Error<'_>>

Without changing its internal value, try to view one sigma-typed value as implementing another sigma type by checking the latter invariant at runtime.

Errors

If the latter invariant does not hold.

pub fn try_check(&self) -> Result<(), Invariant::Error<'_>>

Check an invariant without panicking.

Errors

If the invariant does not hold.

pub fn try_new(raw: Raw) -> Option<Self>

Create a new sigma type instance by checking an invariant.

Errors

If the invariant does not hold.

pub fn wrap(reference: &Raw) -> &Self

Wrap a reference through pointer reinterpretation magic.

pub fn wrap_mut(reference: &mut Raw) -> &mut Self

Wrap a reference through pointer reinterpretation magic.

Trait Implementations

impl<L: Debug + Add<R, Output: Debug>, R: Debug, Invariant: Test<L, 1> + Test<R, 1> + Test<L::Output, 1>> Add<Sigma<R, Invariant>> for Sigma<L, Invariant>

type Output = Sigma<<L as Add<R>>::Output, Invariant>

The resulting type after applying the + operator.

fn add(self, rhs: Sigma<R, Invariant>) -> Self::Output

Performs the + operation.

impl<L: Debug + AddAssign<R>, R: Debug, Invariant: Test<L, 1> + Test<R, 1>> AddAssign<Sigma<R, Invariant>> for Sigma<L, Invariant>

fn add_assign(&mut self, rhs: Sigma<R, Invariant>)

Performs the += operation.

impl<Raw: Debug, Invariant: Test<Raw, 1>> AsRef<Raw> for Sigma<Raw, Invariant>

fn as_ref(&self) -> &Raw

Converts this type into a shared reference of the (usually inferred) input type.

impl<Raw: Debug, Invariant: Test<Raw, 1>> Borrow<Raw> for Sigma<Raw, Invariant>

fn borrow(&self) -> &Raw

Immutably borrows from an owned value.

impl<Raw: CanBeInfinite + Debug, Invariant: Test<Raw>> CanBeInfinite for Sigma<Raw, Invariant>

fn check_finite(&self) -> bool

Check that this value is finite (i.e. not infinite, NaN, etc).

impl<Raw: Clone + Debug, Invariant: Test<Raw, 1>> Clone for Sigma<Raw, Invariant>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Raw: Debug, Invariant: Test<Raw, 1>> Debug for Sigma<Raw, Invariant>

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

Formats the value using the given formatter.

impl<Raw: Default + Debug, Invariant: Test<Raw, 1>> Default for Sigma<Raw, Invariant>

fn default() -> Self

Returns the “default value” for a type.

impl<Raw: Debug, Invariant: Test<Raw, 1>> Deref for Sigma<Raw, Invariant>

type Target = Raw

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Raw: Debug + Display, Invariant: Test<Raw, 1>> Display for Sigma<Raw, Invariant>

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

Formats the value using the given formatter.

impl<L: CanBeInfinite + Debug + Div<R, Output: CanBeInfinite + Debug>, R: CanBeInfinite + Debug> Div<Sigma<R, FiniteInvariant<R>>> for Finite<L>

type Output = Sigma<<L as Div<R>>::Output, FiniteInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Finite<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NegativeInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Div<R>>::Output, PositiveInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Negative<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Div<R>>::Output, NonPositiveInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Negative<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Div<R>>::Output, NonNegativeInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Negative<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NegativeInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Div<R>>::Output, NegativeInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Negative<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, NonZeroInvariant<R>>> for NonZero<L>

type Output = Sigma<<L as Div<R>>::Output, NonZeroInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, PositiveInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Div<R>>::Output, NegativeInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Positive<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, PositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Div<R>>::Output, NonNegativeInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Positive<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, PositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Div<R>>::Output, NonPositiveInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Positive<R>) -> Self::Output

Performs the / operation.

impl<L: PartialOrd + Zero + Debug + Div<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Div<Sigma<R, PositiveInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Div<R>>::Output, PositiveInvariant<<L as Div<R>>::Output>>

The resulting type after applying the / operator.

fn div(self, rhs: Positive<R>) -> Self::Output

Performs the / operation.

impl<Raw: Hash + Debug, Invariant: Test<Raw, 1>> Hash for Sigma<Raw, Invariant>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<L: CanBeInfinite + Debug + Mul<R, Output: CanBeInfinite + Debug>, R: CanBeInfinite + Debug> Mul<Sigma<R, FiniteInvariant<R>>> for Finite<L>

type Output = Sigma<<L as Mul<R>>::Output, FiniteInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Finite<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NegativeInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Mul<R>>::Output, PositiveInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Negative<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Mul<R>>::Output, NonPositiveInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Negative<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Mul<R>>::Output, NonNegativeInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Negative<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NegativeInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Mul<R>>::Output, NegativeInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Negative<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NonNegativeInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Mul<R>>::Output, NonNegativeInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonNegative<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NonNegativeInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Mul<R>>::Output, NonPositiveInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonNegative<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NonPositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Mul<R>>::Output, NonPositiveInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonPositive<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NonPositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Mul<R>>::Output, NonNegativeInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonPositive<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, NonZeroInvariant<R>>> for NonZero<L>

type Output = Sigma<<L as Mul<R>>::Output, NonZeroInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZero<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, PositiveInvariant<R>>> for Negative<L>

type Output = Sigma<<L as Mul<R>>::Output, NegativeInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Positive<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, PositiveInvariant<R>>> for NonNegative<L>

type Output = Sigma<<L as Mul<R>>::Output, NonNegativeInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Positive<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, PositiveInvariant<R>>> for NonPositive<L>

type Output = Sigma<<L as Mul<R>>::Output, NonPositiveInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Positive<R>) -> Self::Output

Performs the * operation.

impl<L: PartialOrd + Zero + Debug + Mul<R, Output: PartialOrd + Zero + Debug>, R: PartialOrd + Zero + Debug> Mul<Sigma<R, PositiveInvariant<R>>> for Positive<L>

type Output = Sigma<<L as Mul<R>>::Output, PositiveInvariant<<L as Mul<R>>::Output>>

The resulting type after applying the * operator.

fn mul(self, rhs: Positive<R>) -> Self::Output

Performs the * operation.

impl<Raw: Ord + Debug, Invariant: Test<Raw, 1>> Ord for Sigma<Raw, Invariant>

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

Restrict a value to a certain interval.

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.

impl<Raw: PartialEq + Debug, Invariant: Test<Raw, 1>> PartialEq for Sigma<Raw, Invariant>

fn eq(&self, other: &Self) -> bool

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

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

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

impl<Raw: PartialOrd + Debug, Invariant: Test<Raw, 1>> PartialOrd for Sigma<Raw, Invariant>

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

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

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

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

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

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

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

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

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

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

impl<L: Debug + Sub<R, Output: Debug>, R: Debug, Invariant: Test<L, 1> + Test<R, 1> + Test<L::Output, 1>> Sub<Sigma<R, Invariant>> for Sigma<L, Invariant>

type Output = Sigma<<L as Sub<R>>::Output, Invariant>

The resulting type after applying the - operator.

fn sub(self, rhs: Sigma<R, Invariant>) -> Self::Output

Performs the - operation.

impl<Raw: Copy + Debug, Invariant: Test<Raw, 1>> Copy for Sigma<Raw, Invariant>

impl<Raw: Eq + Debug, Invariant: Test<Raw, 1>> Eq for Sigma<Raw, Invariant>