array__ops 1.0.3

A selection of useful array operations
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use core::pin::Pin;

use array_trait::Array;
use slice_ops::AsSlice;

use crate::private;

#[const_trait]
pub trait ArrayReformulate<T, const N: usize>: Array + AsSlice<Item = T>
{
    fn reformulate<const M: usize>(self) -> [T; M]
    where
        [(); M - N]:,
        [(); N - M]:;
    fn reformulate_ref<const M: usize>(&self) -> &[T; M]
    where
        [(); M - N]:,
        [(); N - M]:;
    fn reformulate_mut<const M: usize>(&mut self) -> &mut [T; M]
    where
        [(); M - N]:,
        [(); N - M]:;
    fn reformulate_pin_ref<const M: usize>(self: Pin<&Self>) -> Pin<&[T; M]>
    where
        [(); M - N]:,
        [(); N - M]:;
    fn reformulate_pin_mut<const M: usize>(self: Pin<&mut Self>) -> Pin<&mut [T; M]>
    where
        [(); M - N]:,
        [(); N - M]:;
        
    fn try_reformulate<const M: usize>(self) -> Result<[T; M], [T; N]>;
    fn try_reformulate_ref<const M: usize>(&self) -> Option<&[T; M]>;
    fn try_reformulate_mut<const M: usize>(&mut self) -> Option<&mut [T; M]>;
    fn try_reformulate_pin_ref<const M: usize>(self: Pin<&Self>) -> Option<Pin<&[T; M]>>;
    fn try_reformulate_pin_mut<const M: usize>(self: Pin<&mut Self>) -> Option<Pin<&mut [T; M]>>;
}

impl<T, const N: usize> ArrayReformulate<T, N> for [T; N]
{
    fn reformulate<const M: usize>(self) -> [T; M]
    where
        [(); M - N]:,
        [(); N - M]:
    {
        unsafe {
            self.try_reformulate().unwrap_unchecked()
        }
    }
    fn reformulate_ref<const M: usize>(&self) -> &[T; M]
    where
        [(); M - N]:,
        [(); N - M]:
    {
        unsafe {
            self.try_reformulate_ref().unwrap_unchecked()
        }
    }   
    fn reformulate_mut<const M: usize>(&mut self) -> &mut [T; M]
    where
        [(); M - N]:,
        [(); N - M]:
    {
        unsafe {
            self.try_reformulate_mut().unwrap_unchecked()
        }
    }
    fn reformulate_pin_ref<const M: usize>(self: Pin<&Self>) -> Pin<&[T; M]>
    where
        [(); M - N]:,
        [(); N - M]:
    {
        unsafe {
            self.try_reformulate_pin_ref().unwrap_unchecked()
        }
    }
    fn reformulate_pin_mut<const M: usize>(self: Pin<&mut Self>) -> Pin<&mut [T; M]>
    where
        [(); M - N]:,
        [(); N - M]:
    {
        unsafe {
            self.try_reformulate_pin_mut().unwrap_unchecked()
        }
    }
    
    fn try_reformulate<const M: usize>(self) -> Result<[T; M], Self>
    {
        if N != M
        {
            return Err(self)
        }
        unsafe {
            Ok(private::transmute(self))
        }
    }
    fn try_reformulate_ref<const M: usize>(&self) -> Option<&[T; M]>
    {
        if N != M
        {
            return None
        }
        unsafe {
            Some(self.as_ptr().cast::<[T; M]>().as_ref_unchecked())
        }
    }   
    fn try_reformulate_mut<const M: usize>(&mut self) -> Option<&mut [T; M]>
    {
        if N != M
        {
            return None
        }
        unsafe {
            Some(self.as_mut_ptr().cast::<[T; M]>().as_mut_unchecked())
        }
    }
    fn try_reformulate_pin_ref<const M: usize>(self: Pin<&Self>) -> Option<Pin<&[T; M]>>
    {
        unsafe {
            self.get_ref()
                .try_reformulate_ref()
                .map(|pin| Pin::new_unchecked(pin))
        }
    }
    fn try_reformulate_pin_mut<const M: usize>(self: Pin<&mut Self>) -> Option<Pin<&mut [T; M]>>
    {
        unsafe {
            self.get_unchecked_mut()
                .try_reformulate_mut()
                .map(|pin| Pin::new_unchecked(pin))
        }
    }
}