typsy 0.1.0

Heterogenous containers
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

use crate::hlist::{Cons, Nil};

pub type Zipped<T, U> = <T as Zip<U>>::Output;
pub trait Zip<O> {
    type Output: UnZip<Left = Self, Right = O>;

    fn zip(self, other: O) -> Self::Output;
}

pub trait UnZip {
    type Left: Zip<Self::Right, Output = Self>;
    type Right: Zip<Self::Left, Output = Self::Flipped>;
    type Flipped: UnZip<Left = Self::Right, Right = Self::Left, Flipped = Self>;

    fn unzip(self) -> (Self::Left, Self::Right);
    fn flip(self) -> Self::Flipped;
}

impl Zip<Nil> for Nil {
    type Output = Self;

    fn zip(self, Nil: Self) -> Self::Output { Self }
}

impl UnZip for Nil {
    type Left = Self;
    type Right = Self;
    type Flipped = Self;

    fn unzip(self) -> (Self::Left, Self::Right) { (Self, Self) }

    fn flip(self) -> Self::Flipped { Self }
}

impl<T, U, R: Zip<S>, S> Zip<Cons<U, S>> for Cons<T, R> {
    type Output = Cons<(T, U), R::Output>;

    fn zip(self, other: Cons<U, S>) -> Self::Output {
        Cons {
            value: (self.value, other.value),
            rest: self.rest.zip(other.rest),
        }
    }
}

impl<T, U, R: UnZip> UnZip for Cons<(T, U), R> {
    type Left = Cons<T, R::Left>;
    type Right = Cons<U, R::Right>;
    type Flipped = Cons<(U, T), R::Flipped>;

    fn unzip(self) -> (Self::Left, Self::Right) {
        let (left, right) = self.rest.unzip();
        (
            Cons {
                value: self.value.0,
                rest: left,
            },
            Cons {
                value: self.value.1,
                rest: right,
            },
        )
    }

    fn flip(self) -> Self::Flipped {
        Cons {
            value: (self.value.1, self.value.0),
            rest: self.rest.flip(),
        }
    }
}