Struct NonNegative 

pub struct NonNegative<T>(/* private fields */);

Proof that a signed value is >= 0.

Implementations

impl NonNegative<i8>

pub fn new_ct(value: i8) -> CtOption<NonNegative<i8>>

Available on crate feature ct only.

Constant-time new: None-masked when value < 0.

impl NonNegative<i16>

pub fn new_ct(value: i16) -> CtOption<NonNegative<i16>>

Available on crate feature ct only.

Constant-time new: None-masked when value < 0.

impl NonNegative<i32>

pub fn new_ct(value: i32) -> CtOption<NonNegative<i32>>

Available on crate feature ct only.

Constant-time new: None-masked when value < 0.

impl NonNegative<i64>

pub fn new_ct(value: i64) -> CtOption<NonNegative<i64>>

Available on crate feature ct only.

Constant-time new: None-masked when value < 0.

impl NonNegative<i128>

pub fn new_ct(value: i128) -> CtOption<NonNegative<i128>>

Available on crate feature ct only.

Constant-time new: None-masked when value < 0.

impl NonNegative<isize>

pub fn new_ct(value: isize) -> CtOption<NonNegative<isize>>

Available on crate feature ct only.

Constant-time new: None-masked when value < 0.

impl NonNegative<i8>

pub const fn new(value: i8) -> Option<Self>

Some iff value >= 0.

pub const unsafe fn new_unchecked(value: i8) -> Self

Safety

value must be >= 0.

pub const fn get(self) -> i8

The proven value.

pub fn from_ref(value: &i8) -> Option<&Self>

Zero-cost borrowed proof (repr(transparent) reinterpret).

pub const fn to_unsigned(self) -> u8

Infallible cast to the unsigned counterpart — the value is >= 0 so the bit pattern is preserved; no Option, no panic.

pub const fn abs(self) -> i8

abs is the identity on a non-negative value (branch-free).

pub const fn isqrt(self) -> i8

isqrt is total on a non-negative value (the inherent signed isqrt would otherwise panic on negatives).

pub const fn into_nonmin(self) -> NonMin<i8>

NonNegative ⊂ NonMin (>= 0, and MIN < 0, so != MIN) — narrows with no recheck so it can feed total neg/abs/division.

impl NonNegative<i16>

pub const fn new(value: i16) -> Option<Self>

Some iff value >= 0.

pub const unsafe fn new_unchecked(value: i16) -> Self

Safety

value must be >= 0.

pub const fn get(self) -> i16

The proven value.

pub fn from_ref(value: &i16) -> Option<&Self>

Zero-cost borrowed proof (repr(transparent) reinterpret).

pub const fn to_unsigned(self) -> u16

Infallible cast to the unsigned counterpart — the value is >= 0 so the bit pattern is preserved; no Option, no panic.

pub const fn abs(self) -> i16

abs is the identity on a non-negative value (branch-free).

pub const fn isqrt(self) -> i16

isqrt is total on a non-negative value (the inherent signed isqrt would otherwise panic on negatives).

pub const fn into_nonmin(self) -> NonMin<i16>

NonNegative ⊂ NonMin (>= 0, and MIN < 0, so != MIN) — narrows with no recheck so it can feed total neg/abs/division.

impl NonNegative<i32>

pub const fn new(value: i32) -> Option<Self>

Some iff value >= 0.

Examples found in repository

examples/typestates.rs (line 63)

fn signed_range() {
    let nn = NonNegative::<i32>::new(81).expect("81 >= 0");
    let u: u32 = nn.to_unsigned(); // infallible, bit-preserving
    assert_eq!(u, 81);
    assert_eq!(nn.isqrt(), 9); // total: input is known non-negative

    // a positive value narrows straight into a NonZero divisor
    let nz = Positive::<i32>::new(7).expect("7 > 0").into_nonzero();
    assert_eq!(nz.get(), 7);
}

pub const unsafe fn new_unchecked(value: i32) -> Self

Safety

value must be >= 0.

pub const fn get(self) -> i32

The proven value.

pub fn from_ref(value: &i32) -> Option<&Self>

Zero-cost borrowed proof (repr(transparent) reinterpret).

pub const fn to_unsigned(self) -> u32

Infallible cast to the unsigned counterpart — the value is >= 0 so the bit pattern is preserved; no Option, no panic.

Examples found in repository

examples/typestates.rs (line 64)

fn signed_range() {
    let nn = NonNegative::<i32>::new(81).expect("81 >= 0");
    let u: u32 = nn.to_unsigned(); // infallible, bit-preserving
    assert_eq!(u, 81);
    assert_eq!(nn.isqrt(), 9); // total: input is known non-negative

    // a positive value narrows straight into a NonZero divisor
    let nz = Positive::<i32>::new(7).expect("7 > 0").into_nonzero();
    assert_eq!(nz.get(), 7);
}

pub const fn abs(self) -> i32

abs is the identity on a non-negative value (branch-free).

pub const fn isqrt(self) -> i32

isqrt is total on a non-negative value (the inherent signed isqrt would otherwise panic on negatives).

Examples found in repository

examples/typestates.rs (line 66)

fn signed_range() {
    let nn = NonNegative::<i32>::new(81).expect("81 >= 0");
    let u: u32 = nn.to_unsigned(); // infallible, bit-preserving
    assert_eq!(u, 81);
    assert_eq!(nn.isqrt(), 9); // total: input is known non-negative

    // a positive value narrows straight into a NonZero divisor
    let nz = Positive::<i32>::new(7).expect("7 > 0").into_nonzero();
    assert_eq!(nz.get(), 7);
}

pub const fn into_nonmin(self) -> NonMin<i32>

NonNegative ⊂ NonMin (>= 0, and MIN < 0, so != MIN) — narrows with no recheck so it can feed total neg/abs/division.

impl NonNegative<i64>

pub const fn new(value: i64) -> Option<Self>

Some iff value >= 0.

pub const unsafe fn new_unchecked(value: i64) -> Self

Safety

value must be >= 0.

pub const fn get(self) -> i64

The proven value.

pub fn from_ref(value: &i64) -> Option<&Self>

Zero-cost borrowed proof (repr(transparent) reinterpret).

pub const fn to_unsigned(self) -> u64

Infallible cast to the unsigned counterpart — the value is >= 0 so the bit pattern is preserved; no Option, no panic.

pub const fn abs(self) -> i64

abs is the identity on a non-negative value (branch-free).

pub const fn isqrt(self) -> i64

isqrt is total on a non-negative value (the inherent signed isqrt would otherwise panic on negatives).

pub const fn into_nonmin(self) -> NonMin<i64>

NonNegative ⊂ NonMin (>= 0, and MIN < 0, so != MIN) — narrows with no recheck so it can feed total neg/abs/division.

impl NonNegative<i128>

pub const fn new(value: i128) -> Option<Self>

Some iff value >= 0.

pub const unsafe fn new_unchecked(value: i128) -> Self

Safety

value must be >= 0.

pub const fn get(self) -> i128

The proven value.

pub fn from_ref(value: &i128) -> Option<&Self>

Zero-cost borrowed proof (repr(transparent) reinterpret).

pub const fn to_unsigned(self) -> u128

Infallible cast to the unsigned counterpart — the value is >= 0 so the bit pattern is preserved; no Option, no panic.

pub const fn abs(self) -> i128

abs is the identity on a non-negative value (branch-free).

pub const fn isqrt(self) -> i128

isqrt is total on a non-negative value (the inherent signed isqrt would otherwise panic on negatives).

pub const fn into_nonmin(self) -> NonMin<i128>

NonNegative ⊂ NonMin (>= 0, and MIN < 0, so != MIN) — narrows with no recheck so it can feed total neg/abs/division.

impl NonNegative<isize>

pub const fn new(value: isize) -> Option<Self>

Some iff value >= 0.

pub const unsafe fn new_unchecked(value: isize) -> Self

Safety

value must be >= 0.

pub const fn get(self) -> isize

The proven value.

pub fn from_ref(value: &isize) -> Option<&Self>

Zero-cost borrowed proof (repr(transparent) reinterpret).

pub const fn to_unsigned(self) -> usize

Infallible cast to the unsigned counterpart — the value is >= 0 so the bit pattern is preserved; no Option, no panic.

pub const fn abs(self) -> isize

abs is the identity on a non-negative value (branch-free).

pub const fn isqrt(self) -> isize

isqrt is total on a non-negative value (the inherent signed isqrt would otherwise panic on negatives).

pub const fn into_nonmin(self) -> NonMin<isize>

NonNegative ⊂ NonMin (>= 0, and MIN < 0, so != MIN) — narrows with no recheck so it can feed total neg/abs/division.

Trait Implementations

impl<T: Clone> Clone for NonNegative<T>

fn clone(&self) -> NonNegative<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for NonNegative<T>

impl<T: Debug> Debug for NonNegative<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for NonNegative<T>

impl<T: PartialEq> PartialEq for NonNegative<T>

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

impl<T: PartialEq> StructuralPartialEq for NonNegative<T>

impl TryFrom<i8> for NonNegative<i8>

Checked construction by value; mirrors NonNegative::new.

type Error = TypestateError

The type returned in the event of a conversion error.

fn try_from(value: i8) -> Result<Self, TypestateError>

Performs the conversion.

impl TryFrom<i16> for NonNegative<i16>

Checked construction by value; mirrors NonNegative::new.

type Error = TypestateError

The type returned in the event of a conversion error.

fn try_from(value: i16) -> Result<Self, TypestateError>

Performs the conversion.

impl TryFrom<i32> for NonNegative<i32>

Checked construction by value; mirrors NonNegative::new.

type Error = TypestateError

The type returned in the event of a conversion error.

fn try_from(value: i32) -> Result<Self, TypestateError>

Performs the conversion.

impl TryFrom<i64> for NonNegative<i64>

Checked construction by value; mirrors NonNegative::new.

type Error = TypestateError

The type returned in the event of a conversion error.

fn try_from(value: i64) -> Result<Self, TypestateError>

Performs the conversion.

impl TryFrom<i128> for NonNegative<i128>

Checked construction by value; mirrors NonNegative::new.

type Error = TypestateError

The type returned in the event of a conversion error.

fn try_from(value: i128) -> Result<Self, TypestateError>

Performs the conversion.

impl TryFrom<isize> for NonNegative<isize>

Checked construction by value; mirrors NonNegative::new.

type Error = TypestateError

The type returned in the event of a conversion error.

fn try_from(value: isize) -> Result<Self, TypestateError>

Performs the conversion.