gnat 0.1.8

Type-level numbers without extra bounds
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use crate::{
    NatExpr,
    array::{container::ArrRefConsumer, *},
    consts::Usize,
};

fn partial_eq_impl<A: Array, U>(lhs: &ArrApi<A>, rhs: &[U]) -> bool
where
    A::Item: PartialEq<U>,
{
    (const { crate::to_usize::<A::Length>().is_some() } && lhs.as_slice() == rhs)
}

impl<A, U> PartialEq<[U]> for ArrApi<A>
where
    A: Array,
    A::Item: PartialEq<U>,
{
    fn eq(&self, other: &[U]) -> bool {
        partial_eq_impl(self, other)
    }
}
impl<A, U> PartialEq<&[U]> for ArrApi<A>
where
    A: Array,
    A::Item: PartialEq<U>,
{
    fn eq(&self, &other: &&[U]) -> bool {
        partial_eq_impl(self, other)
    }
}
impl<A, U, const N: usize> PartialEq<[U; N]> for ArrApi<A>
where
    A: Array,
    A::Item: PartialEq<U>,
    Usize<N>: NatExpr<Eval = A::Length>,
{
    fn eq(&self, other: &[U; N]) -> bool {
        partial_eq_impl(self, other)
    }
}
impl<A, B> PartialEq<ArrApi<B>> for ArrApi<A>
where
    A: Array,
    B: Array,
    A::Item: PartialEq<B::Item>,
{
    fn eq(&self, other: &ArrApi<B>) -> bool {
        if const { crate::cmp::<A::Length, B::Length>().is_ne() } {
            false
        } else if const { crate::to_usize::<A::Length>().is_some() } {
            self.as_slice() == other.as_slice()
        } else {
            let mut lhs = container::ArrRefConsumer::new(self);
            let mut rhs = container::ArrRefConsumer::new(other);
            while let (Some(l), Some(r)) = (lhs.pop_front(), rhs.pop_front()) {
                if l != r {
                    return false;
                }
            }
            true
        }
    }
}
impl<A> Eq for ArrApi<A>
where
    A: Array,
    A::Item: Eq,
{
}

impl<A> PartialOrd for ArrApi<A>
where
    A: Array,
    A::Item: PartialOrd,
{
    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
        if crate::to_usize::<A::Length>().is_some() {
            self.as_slice().partial_cmp(other.as_slice())
        } else {
            let mut l_iter = ArrRefConsumer::new(self);
            let mut r_iter = ArrRefConsumer::new(other);
            while let (Some(l), Some(r)) = (l_iter.pop_front(), r_iter.pop_front()) {
                let cmp = l.partial_cmp(r);
                if cmp != Some(core::cmp::Ordering::Equal) {
                    return cmp;
                }
            }
            Some(core::cmp::Ordering::Equal)
        }
    }
}
impl<A> Ord for ArrApi<A>
where
    A: Array,
    A::Item: Ord,
{
    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
        if crate::to_usize::<A::Length>().is_some() {
            self.as_slice().cmp(other.as_slice())
        } else {
            let mut l_iter = ArrRefConsumer::new(self);
            let mut r_iter = ArrRefConsumer::new(other);
            while let (Some(l), Some(r)) = (l_iter.pop_front(), r_iter.pop_front()) {
                let cmp = l.cmp(r);
                if cmp != core::cmp::Ordering::Equal {
                    return cmp;
                }
            }
            core::cmp::Ordering::Equal
        }
    }
}