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

use core::cmp::PartialEq;

use crate::{Chain, Cycle, Interleave, Reverse, Slice, SliceMut, SliceOf, SliceOfMut};

macro_rules! impl_eq {
    ($(
        $typ:ident [$($lifetimes:lifetime),* $($generics:ident),*] = $bound:ident
    ;)*) =>{$(
        impl<
            $($lifetimes,)* T, $($generics,)* const N: usize,
        > PartialEq<[T; N]> for $typ<$($lifetimes,)* T, $($generics,)*>
        where
            T: PartialEq,
            $($generics : $bound<T>,)*
        {
            fn eq(&self, other: &[T; N]) -> bool {
                if self.len() != N {
                    false
                } else {
                    for i in 0..self.len() {
                        if self.get(i) != Some(&other[i]) {
                            return false;
                        }
                    }

                    true
                }
            }
        }

        impl<
            $($lifetimes,)* T, $($generics,)*
        > PartialEq<[T]> for $typ<$($lifetimes,)* T, $($generics,)*>
        where
            T: PartialEq,
            $($generics : $bound<T>,)*
        {
            fn eq(&self, other: &[T]) -> bool {
                if self.len() != other.len() {
                    false
                } else {
                    for i in 0..self.len() {
                        if self.get(i) != Some(&other[i]) {
                            return false;
                        }
                    }

                    true
                }
            }
        }

        impl<
            'a, $($lifetimes,)* T, $($generics,)*
        > PartialEq<&'a [T]> for $typ<$($lifetimes,)* T, $($generics,)*>
        where
            T: PartialEq,
            $($generics : $bound<T>,)*
        {
            fn eq(&self, other: &&'a [T]) -> bool {
                if self.len() != other.len() {
                    false
                } else {
                    for i in 0..self.len() {
                        if self.get(i) != Some(&other[i]) {
                            return false;
                        }
                    }

                    true
                }
            }
        }
    )*};
}

impl_eq! {
    Chain[A, B] = Slice;
    Cycle[A] = Slice;
    Interleave[A, B] = Slice;
    Reverse[A] = Slice;
    SliceOf[A] = Slice;
    SliceOfMut[A] = SliceMut;
}