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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use core::{mem::ManuallyDrop, marker::Destruct, ops::DerefMut};

use crate::{private, ConstIterator};

pub struct IntoConstIter<T, const LENGTH: usize, const DIR: bool, const ENUMERATE: bool = false>
{
    data: [ManuallyDrop<T>; LENGTH],
    i: usize
}

impl<T, const N: usize, const DIR: bool, const ENUMERATE: bool> IntoConstIter<T, N, DIR, ENUMERATE>
{
    pub const fn from(array: [T; N]) -> Self
    {
        Self {
            data: unsafe {private::transmute_unchecked_size(array)},
            i: if DIR {0} else {N}
        }
    }
    
    pub /*const*/ fn drop_copyable(self)
    where
        T: Copy
    {
        let mut this = ManuallyDrop::new(self);
        let this_mut = this.deref_mut();

        while this_mut.i != if DIR {N} else {0}
        {
            if !DIR
            {
                this_mut.i -= 1;
            }
            let _: T = unsafe {ManuallyDrop::into_inner(core::ptr::read(core::mem::transmute(&mut this_mut.data[this_mut.i])))};
            if DIR
            {
                this_mut.i += 1;
            }
        }
    }

    pub /*const*/ fn drop(self)
    where
        T: /*~const*/ Destruct
    {
        let mut this = ManuallyDrop::new(self);
        let this_mut = this.deref_mut();

        while this_mut.i != if DIR {N} else {0}
        {
            if !DIR
            {
                this_mut.i -= 1;
            }
            let _: T = unsafe {ManuallyDrop::into_inner(core::ptr::read(core::mem::transmute(&mut this_mut.data[this_mut.i])))};
            if DIR
            {
                this_mut.i += 1;
            }
        }
    }
}

impl<T, const N: usize, const DIR: bool> IntoConstIter<T, N, DIR, false>
{
    pub const fn next(&mut self) -> Option<T>
    {
        if self.i != if DIR {N} else {0}
        {
            if !DIR
            {
                self.i -= 1;
            }
            let out = unsafe {core::ptr::read(core::mem::transmute(&self.data[self.i]))};
            if DIR
            {
                self.i += 1;
            }
            return Some(out)
        }
        None
    }

    pub const fn enumerate(self) -> IntoConstIter<T, N, DIR, true>
    {
        unsafe {private::transmute_unchecked_size(self)}
    }
}

impl<T, const N: usize, const DIR: bool> IntoConstIter<T, N, DIR, true>
{
    pub const fn next(&mut self) -> Option<(usize, T)>
    {
        if self.i != if DIR {N} else {0}
        {
            if !DIR
            {
                self.i -= 1;
            }
            let i = self.i;
            let out = unsafe {core::ptr::read(core::mem::transmute(&self.data[self.i]))};
            if DIR
            {
                self.i += 1;
            }
            return Some((i, out))
        }
        None
    }
}

impl<T, const N: usize, const DIR: bool, const ENUMERATE: bool> const From<[T; N]> for IntoConstIter<T, N, DIR, ENUMERATE>
{
    fn from(value: [T; N]) -> Self
    {
        Self::from(value)
    }
}
impl<T, const N: usize, const DIR: bool> const ConstIterator for IntoConstIter<T, N, DIR, false>
{
    type Item<'a> = T
    where
        Self: 'a;

    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>>
    {
        Self::next(self)
    }
}
impl<T, const N: usize, const DIR: bool> const ConstIterator for IntoConstIter<T, N, DIR, true>
{
    type Item<'a> = (usize, T)
    where
        Self: 'a;

    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>>
    {
        Self::next(self)
    }
}
impl<T, const N: usize, const DIR: bool, const ENUMERATE: bool> Drop for IntoConstIter<T, N, DIR, ENUMERATE>
{
    fn drop(&mut self)
    {
        while self.i != if DIR {N} else {0}
        {
            if !DIR
            {
                self.i -= 1;
            }
            unsafe {ManuallyDrop::drop(&mut self.data[self.i])};
            if DIR
            {
                self.i += 1;
            }
        }
    }
}