multidimension 0.3.3

High-level manipulation of multi-dimensional arrays.
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

use super::{NonTuple};

/// `Coated<I>` behaves like `I` in most respects, but implements [`NonTuple`].
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
#[repr(transparent)]
pub struct Coated<I>(pub I);

impl<I> NonTuple for Coated<I>{}

impl<I> std::ops::Deref for Coated<I> {
    type Target = I;
    fn deref(&self) -> &Self::Target { &self.0 }
}

impl<I> std::ops::DerefMut for Coated<I> {
    fn deref_mut(&mut self) -> &mut Self::Target { &mut self.0 }
}

// ----------------------------------------------------------------------------

/// Implemented by types that differ from `T` by adding or removing at most one
/// level of [`Coated`].
pub trait Coat<I: Coat<Self>>: Sized {
    fn coat(self) -> I;
}

impl<I> Coat<I> for Coated<I> {
    #[inline(always)]
    fn coat(self) -> I { self.0 }
}

impl<I> Coat<Coated<I>> for I {
    #[inline(always)]
    fn coat(self) -> Coated<I> { Coated(self) }
}

impl<I: NonTuple> Coat<Self> for I {
    #[inline(always)]
    fn coat(self) -> Self { self }
}

impl Coat<()> for () {
    #[inline(always)]
    fn coat(self) -> () { () }
}

impl<
    I: Coat<CI>, CI: Coat<I>,
> Coat<(CI,)> for (I,) {
    #[inline(always)]
    fn coat(self) -> (CI,) { (self.0.coat(),) }
}

impl<
    I: Coat<CI>, CI: Coat<I>,
    J: Coat<CJ>, CJ: Coat<J>,
> Coat<(CI, CJ)> for (I, J) {
    #[inline(always)]
    fn coat(self) -> (CI, CJ) { (self.0.coat(), self.1.coat()) }
}

impl<
    I: Coat<CI>, CI: Coat<I>,
    J: Coat<CJ>, CJ: Coat<J>,
    K: Coat<CK>, CK: Coat<K>,
> Coat<(CI, CJ, CK)> for (I, J, K) {
    #[inline(always)]
    fn coat(self) -> (CI, CJ, CK) { (self.0.coat(), self.1.coat(), self.2.coat()) }
}