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 hlist::NonEmpty;

use crate::{
    call::{CallMut, CallOnce},
    coprod, hlist, CoProd, HList,
};

pub type Mapped<T, F, TagList = ()> = <T as Map<F, TagList>>::Output;
pub trait Map<F, TagList = ()> {
    type Output;

    fn map(self, f: F) -> Self::Output;
}

impl<F> Map<F> for hlist::Nil {
    type Output = Self;

    fn map(self, _: F) -> Self::Output { Self }
}

impl<F> Map<F> for coprod::CoNil {
    type Output = Self;

    fn map(self, _: F) -> Self::Output { match self {} }
}

impl<F: CallOnce<(T,)>, T> Map<F> for hlist::Cons<T, hlist::Nil> {
    type Output = HList!(F::Output);

    fn map(self, f: F) -> Self::Output { hlist!(f.call_once((self.value,))) }
}

impl<F: CallMut<(T,)>, T, R: NonEmpty + Map<F>> Map<F> for hlist::Cons<T, R> {
    type Output = HList!(F::Output, @R::Output);

    fn map(self, mut f: F) -> Self::Output { hlist!(f.call_mut((self.value,)), @self.rest.map(f)) }
}

impl<F: CallOnce<(T,)>, T, R: Map<F>> Map<F> for coprod::CoCons<T, R> {
    type Output = CoProd!(F::Output, @R::Output);

    fn map(self, f: F) -> Self::Output {
        match self {
            coprod::CoCons::Value(value) => coprod::CoCons::Value(f.call_once((value,))),
            coprod::CoCons::Rest(rest) => coprod::CoCons::Rest(rest.map(f)),
        }
    }
}

impl<F: CallOnce<(T,), N>, T, N> Map<F, (N, ())> for hlist::Cons<T, hlist::Nil> {
    type Output = HList!(F::Output);

    fn map(self, f: F) -> Self::Output { hlist!(f.call_once((self.value,))) }
}

impl<F: CallMut<(T,), N>, T, R: NonEmpty + Map<F, M>, N, M> Map<F, (N, M)> for hlist::Cons<T, R> {
    type Output = HList!(F::Output, @R::Output);

    fn map(self, mut f: F) -> Self::Output { hlist!(f.call_mut((self.value,)), @self.rest.map(f)) }
}

impl<F: CallOnce<(T,), N>, T, R: Map<F, M>, N, M> Map<F, (N, M)> for coprod::CoCons<T, R> {
    type Output = CoProd!(F::Output, @R::Output);

    fn map(self, f: F) -> Self::Output {
        match self {
            coprod::CoCons::Value(value) => coprod::CoCons::Value(f.call_once((value,))),
            coprod::CoCons::Rest(rest) => coprod::CoCons::Rest(rest.map(f)),
        }
    }
}