Struct Positive 

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

Proof that a signed value is > 0.

Implementations

impl Positive<i8>

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

Available on crate feature ct only.

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

impl Positive<i16>

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

Available on crate feature ct only.

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

impl Positive<i32>

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

Available on crate feature ct only.

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

impl Positive<i64>

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

Available on crate feature ct only.

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

impl Positive<i128>

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

Available on crate feature ct only.

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

impl Positive<isize>

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

Available on crate feature ct only.

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

impl Positive<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.

pub const fn abs(self) -> i8

abs is the identity on a positive value.

pub const fn isqrt(self) -> i8

isqrt is total on a positive value.

pub const fn into_nonnegative(self) -> NonNegative<i8>

Positive ⊂ NonNegative.

pub const fn into_nonzero(self) -> NonZero<i8>

Positive ⊂ NonZero — narrows to core::num::NonZero with no recheck, so a Positive divisor can feed DivNonZero directly.

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

Positive ⊂ NonMin (> 0, so != MIN).

impl Positive<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.

pub const fn abs(self) -> i16

abs is the identity on a positive value.

pub const fn isqrt(self) -> i16

isqrt is total on a positive value.

pub const fn into_nonnegative(self) -> NonNegative<i16>

Positive ⊂ NonNegative.

pub const fn into_nonzero(self) -> NonZero<i16>

Positive ⊂ NonZero — narrows to core::num::NonZero with no recheck, so a Positive divisor can feed DivNonZero directly.

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

Positive ⊂ NonMin (> 0, so != MIN).

impl Positive<i32>

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

Some iff value > 0.

Examples found in repository

examples/typestates.rs (line 69)

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);
}

/// `NonMin`: a signed value proven `!= MIN` has total `abs`/`neg` and total
/// signed division — the `MIN.abs()` and `MIN / -1` overflow cases are gone.
fn nonmin() {
    let a = NonMin::<i32>::new(-7).expect("-7 != MIN");
    assert_eq!(a.abs(), 7); // no overflow branch
    assert_eq!(a.neg(), 7);

    // signed division by NonZero: MIN/-1 is impossible by construction
    let d = core::num::NonZero::new(2).unwrap();
    assert_eq!(a.div_nonzero(d), -7 / 2);

    // Positive/NonNegative narrow into NonMin for free
    let q = Positive::<i32>::new(9).unwrap().into_nonmin();
    assert_eq!(q.abs(), 9);

    assert!(NonMin::<i32>::new(i32::MIN).is_none());
}

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.

pub const fn abs(self) -> i32

abs is the identity on a positive value.

pub const fn isqrt(self) -> i32

isqrt is total on a positive value.

pub const fn into_nonnegative(self) -> NonNegative<i32>

Positive ⊂ NonNegative.

pub const fn into_nonzero(self) -> NonZero<i32>

Positive ⊂ NonZero — narrows to core::num::NonZero with no recheck, so a Positive divisor can feed DivNonZero directly.

Examples found in repository

examples/typestates.rs (line 69)

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>

Positive ⊂ NonMin (> 0, so != MIN).

Examples found in repository

examples/typestates.rs (line 85)

fn nonmin() {
    let a = NonMin::<i32>::new(-7).expect("-7 != MIN");
    assert_eq!(a.abs(), 7); // no overflow branch
    assert_eq!(a.neg(), 7);

    // signed division by NonZero: MIN/-1 is impossible by construction
    let d = core::num::NonZero::new(2).unwrap();
    assert_eq!(a.div_nonzero(d), -7 / 2);

    // Positive/NonNegative narrow into NonMin for free
    let q = Positive::<i32>::new(9).unwrap().into_nonmin();
    assert_eq!(q.abs(), 9);

    assert!(NonMin::<i32>::new(i32::MIN).is_none());
}

impl Positive<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.

pub const fn abs(self) -> i64

abs is the identity on a positive value.

pub const fn isqrt(self) -> i64

isqrt is total on a positive value.

pub const fn into_nonnegative(self) -> NonNegative<i64>

Positive ⊂ NonNegative.

pub const fn into_nonzero(self) -> NonZero<i64>

Positive ⊂ NonZero — narrows to core::num::NonZero with no recheck, so a Positive divisor can feed DivNonZero directly.

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

Positive ⊂ NonMin (> 0, so != MIN).

impl Positive<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.

pub const fn abs(self) -> i128

abs is the identity on a positive value.

pub const fn isqrt(self) -> i128

isqrt is total on a positive value.

pub const fn into_nonnegative(self) -> NonNegative<i128>

Positive ⊂ NonNegative.

pub const fn into_nonzero(self) -> NonZero<i128>

Positive ⊂ NonZero — narrows to core::num::NonZero with no recheck, so a Positive divisor can feed DivNonZero directly.

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

Positive ⊂ NonMin (> 0, so != MIN).

impl Positive<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.

pub const fn abs(self) -> isize

abs is the identity on a positive value.

pub const fn isqrt(self) -> isize

isqrt is total on a positive value.

pub const fn into_nonnegative(self) -> NonNegative<isize>

Positive ⊂ NonNegative.

pub const fn into_nonzero(self) -> NonZero<isize>

Positive ⊂ NonZero — narrows to core::num::NonZero with no recheck, so a Positive divisor can feed DivNonZero directly.

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

Positive ⊂ NonMin (> 0, so != MIN).

Trait Implementations

impl<T: Clone> Clone for Positive<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for Positive<T>

impl<T: Debug> Debug for Positive<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for Positive<T>

impl<T: PartialEq> PartialEq for Positive<T>

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

impl TryFrom<i8> for Positive<i8>

Checked construction by value; mirrors Positive::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 Positive<i16>

Checked construction by value; mirrors Positive::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 Positive<i32>

Checked construction by value; mirrors Positive::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 Positive<i64>

Checked construction by value; mirrors Positive::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 Positive<i128>

Checked construction by value; mirrors Positive::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 Positive<isize>

Checked construction by value; mirrors Positive::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.