arranged 0.1.2

Statically bounds-checked (machine-word-abstracting? TBD) ranged types as zero or low-runtime overhead abstractions providing safe (no unintentional overflow) arithmetic.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

use std::ops::Sub;

use arith_traits::IWrappingOps;
use num_traits::{Num, SaturatingSub};

use crate::traits::ITyEq;

pub trait IRange {
    const INVARIANTS: () = ();
    type ValueType: Num + TryFrom<Self::WidenedValueType>;
    type WidenedValueType: From<Self::ValueType> + Sub + IWrappingOps;

    fn contains(value: &Self::ValueType) -> bool
    where
        Self: Sized;
}

pub trait IRangeFinite<TValue>: IRange + IRangeFrom + IRangeTo
where
    (TValue, <Self as IRange>::ValueType): ITyEq,
    TValue: SaturatingSub, {
    fn is_empty() -> bool;
    fn len() -> Option<usize>;
}

pub trait IRangeFrom: IRange {
    fn start() -> <Self as IRange>::ValueType;
}

pub trait IRangeIntoIterator: IRangeFrom + IntoIterator<Item = <Self as IRange>::ValueType> {
    type IntoIter: Iterator;
    fn into_iter() -> <Self as IRangeIntoIterator>::IntoIter;
}

pub trait IRangeTo: IRange {
    fn end() -> <Self as IRange>::ValueType;
}

pub trait IRangeToInclusive: IRangeTo {}