gnat 0.1.4

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

use crate::{NatExpr, array::*, 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> {
        // FIXME: oversize
        self.as_slice().partial_cmp(other.as_slice())
    }
}
impl<A> Ord for ArrApi<A>
where
    A: Array,
    A::Item: Ord,
{
    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
        // FIXME: oversize
        self.as_slice().cmp(other.as_slice())
    }
}