Struct NonMin 

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

Proof that a signed value is not T::MIN.

neg/abs overflow only at MIN, and the only signed-division overflow is MIN / -1. So with the dividend proven != MIN, neg / abs and div_nonzero / rem_nonzero by any non-zero divisor are total — the co-proof the unsigned DivNonZero doesn’t need. Positive / NonNegative narrow here for free (into_nonmin).

use const_num_traits::NonMin;
use core::num::NonZero;

let a = NonMin::<i32>::new(-7).unwrap();
assert_eq!(a.abs(), 7);
assert_eq!(a.neg(), 7);
let d = NonZero::new(2).unwrap();
assert_eq!(a.div_nonzero(d), -3); // -7 / 2, truncating
assert_eq!(a.rem_nonzero(d), -1); // -7 % 2
assert!(NonMin::<i32>::new(i32::MIN).is_none());

Implementations

impl NonMin<i8>

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

Available on crate feature ct only.

Constant-time new: None-masked when value == MIN.

impl NonMin<i16>

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

Available on crate feature ct only.

Constant-time new: None-masked when value == MIN.

impl NonMin<i32>

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

Available on crate feature ct only.

Constant-time new: None-masked when value == MIN.

impl NonMin<i64>

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

Available on crate feature ct only.

Constant-time new: None-masked when value == MIN.

impl NonMin<i128>

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

Available on crate feature ct only.

Constant-time new: None-masked when value == MIN.

impl NonMin<isize>

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

Available on crate feature ct only.

Constant-time new: None-masked when value == MIN.

impl NonMin<i8>

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

Some iff value != <$t>::MIN.

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

Safety

value must not equal <$t>::MIN (i.e. value != <$t>::MIN) — the invariant consumed by neg/abs/div_nonzero/rem_nonzero.

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 neg(self) -> i8

Total negation — MIN (the sole overflow) is excluded.

pub const fn abs(self) -> i8

Total abs — MIN (the sole overflow) is excluded.

pub const fn div_nonzero(self, d: NonZero<i8>) -> i8

Total signed division by a non-zero divisor: the dividend is proven != MIN, so MIN / -1 (the only overflow) can’t occur, and the divisor’s niche rules out divide-by-zero.

pub const fn rem_nonzero(self, d: NonZero<i8>) -> i8

Total signed remainder by a non-zero divisor (same reasoning as div_nonzero; MIN % -1 is excluded).

impl NonMin<i16>

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

Some iff value != <$t>::MIN.

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

Safety

value must not equal <$t>::MIN (i.e. value != <$t>::MIN) — the invariant consumed by neg/abs/div_nonzero/rem_nonzero.

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 neg(self) -> i16

Total negation — MIN (the sole overflow) is excluded.

pub const fn abs(self) -> i16

Total abs — MIN (the sole overflow) is excluded.

pub const fn div_nonzero(self, d: NonZero<i16>) -> i16

Total signed division by a non-zero divisor: the dividend is proven != MIN, so MIN / -1 (the only overflow) can’t occur, and the divisor’s niche rules out divide-by-zero.

pub const fn rem_nonzero(self, d: NonZero<i16>) -> i16

Total signed remainder by a non-zero divisor (same reasoning as div_nonzero; MIN % -1 is excluded).

impl NonMin<i32>

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

Some iff value != <$t>::MIN.

Examples found in repository

examples/typestates.rs (line 76)

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 not equal <$t>::MIN (i.e. value != <$t>::MIN) — the invariant consumed by neg/abs/div_nonzero/rem_nonzero.

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 neg(self) -> i32

Total negation — MIN (the sole overflow) is excluded.

Examples found in repository

examples/typestates.rs (line 78)

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 fn abs(self) -> i32

Total abs — MIN (the sole overflow) is excluded.

Examples found in repository

examples/typestates.rs (line 77)

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 fn div_nonzero(self, d: NonZero<i32>) -> i32

Total signed division by a non-zero divisor: the dividend is proven != MIN, so MIN / -1 (the only overflow) can’t occur, and the divisor’s niche rules out divide-by-zero.

Examples found in repository

examples/typestates.rs (line 82)

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 fn rem_nonzero(self, d: NonZero<i32>) -> i32

Total signed remainder by a non-zero divisor (same reasoning as div_nonzero; MIN % -1 is excluded).

impl NonMin<i64>

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

Some iff value != <$t>::MIN.

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

Safety

value must not equal <$t>::MIN (i.e. value != <$t>::MIN) — the invariant consumed by neg/abs/div_nonzero/rem_nonzero.

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 neg(self) -> i64

Total negation — MIN (the sole overflow) is excluded.

pub const fn abs(self) -> i64

Total abs — MIN (the sole overflow) is excluded.

pub const fn div_nonzero(self, d: NonZero<i64>) -> i64

Total signed division by a non-zero divisor: the dividend is proven != MIN, so MIN / -1 (the only overflow) can’t occur, and the divisor’s niche rules out divide-by-zero.

pub const fn rem_nonzero(self, d: NonZero<i64>) -> i64

Total signed remainder by a non-zero divisor (same reasoning as div_nonzero; MIN % -1 is excluded).

impl NonMin<i128>

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

Some iff value != <$t>::MIN.

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

Safety

value must not equal <$t>::MIN (i.e. value != <$t>::MIN) — the invariant consumed by neg/abs/div_nonzero/rem_nonzero.

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 neg(self) -> i128

Total negation — MIN (the sole overflow) is excluded.

pub const fn abs(self) -> i128

Total abs — MIN (the sole overflow) is excluded.

pub const fn div_nonzero(self, d: NonZero<i128>) -> i128

Total signed division by a non-zero divisor: the dividend is proven != MIN, so MIN / -1 (the only overflow) can’t occur, and the divisor’s niche rules out divide-by-zero.

pub const fn rem_nonzero(self, d: NonZero<i128>) -> i128

Total signed remainder by a non-zero divisor (same reasoning as div_nonzero; MIN % -1 is excluded).

impl NonMin<isize>

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

Some iff value != <$t>::MIN.

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

Safety

value must not equal <$t>::MIN (i.e. value != <$t>::MIN) — the invariant consumed by neg/abs/div_nonzero/rem_nonzero.

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 neg(self) -> isize

Total negation — MIN (the sole overflow) is excluded.

pub const fn abs(self) -> isize

Total abs — MIN (the sole overflow) is excluded.

pub const fn div_nonzero(self, d: NonZero<isize>) -> isize

Total signed division by a non-zero divisor: the dividend is proven != MIN, so MIN / -1 (the only overflow) can’t occur, and the divisor’s niche rules out divide-by-zero.

pub const fn rem_nonzero(self, d: NonZero<isize>) -> isize

Total signed remainder by a non-zero divisor (same reasoning as div_nonzero; MIN % -1 is excluded).

Trait Implementations

impl<T: Clone> Clone for NonMin<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for NonMin<T>

impl<T: Debug> Debug for NonMin<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for NonMin<T>

impl<T: PartialEq> PartialEq for NonMin<T>

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

impl TryFrom<i8> for NonMin<i8>

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

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

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

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

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

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