algar 0.4.1

Algebraic structures, higher-kinded types and other category theory bad ideas
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

use crate::{Applicative, Foldable, Functor, Monoid};

/// `Traversable` represents data structures which can be traversed while perserving the shape.
/// Helpful to walk through a data structure from left to right,
/// running some action on each element in turn.
/// Similar to applicatives, it can be used to do things like collecting some effects
pub trait Traversable<'a>: Functor<'a> {
    /// Convert elements to actions, then evaluate the actions from left-to-right
    /// and collect the results.
    ///
    /// Haskell signature
    /// traverse  :: Applicative f => (a -> f b) -> t a -> f (t b)
    fn traverse<F, B: 'a, W>(self, f: F) -> W::Wrapped<Self::Wrapped<B>>
    where
        F: Fn(&Self::Unwrapped) -> W::Wrapped<B>,
        W: Applicative<'a, Unwrapped = Self::Wrapped<B>, Wrapped<Self::Wrapped<B>> = W>
            + 'a
            + Monoid,
        <W as Functor<'a>>::Wrapped<Self::Wrapped<B>>: Applicative<'a>,
        <Self as Functor<'a>>::Wrapped<B>: 'a;

    /// Evaluate each action in the structure from left to right, and collect the results
    ///
    /// Haskell signature
    /// sequenceA :: Applicative f => t (f a) -> f (t a)
    fn sequence_a<B: 'a, W>(self) -> W::Wrapped<Self::Wrapped<B>>
    where
        W: Applicative<'a, Unwrapped = Self::Wrapped<B>, Wrapped<Self::Wrapped<B>> = W>
            + 'a
            + Monoid,
        W: Applicative<'a, Wrapped<B> = Self::Unwrapped>,
        <Self as Functor<'a>>::Wrapped<B>: 'a,
        Self::Unwrapped: Applicative<'a> + 'a + Copy;
}

impl<'a, A: Monoid> Traversable<'a> for Vec<A> {
    fn traverse<F, B: 'a, W>(self, f: F) -> W::Wrapped<Self::Wrapped<B>>
    where
        F: Fn(&Self::Unwrapped) -> W::Wrapped<B>,
        W: Applicative<'a, Unwrapped = Self::Wrapped<B>, Wrapped<Self::Wrapped<B>> = W>
            + 'a
            + Monoid,
        <W as Functor<'a>>::Wrapped<Self::Wrapped<B>>: Applicative<'a> + Monoid,
        <Self as Functor<'a>>::Wrapped<B>: 'a,
    {
        self.foldr(W::of(vec![]), |k, v| {
            let c = f(v);

            k.lift_a2(c, |mut acc, v: B| {
                acc.insert(0, v);
                acc
            })
        })
    }

    fn sequence_a<B: 'a, W>(self) -> W::Wrapped<Self::Wrapped<B>>
    where
        W: Applicative<'a, Unwrapped = Self::Wrapped<B>, Wrapped<Self::Wrapped<B>> = W>
            + 'a
            + Monoid,
        <Self as Functor<'a>>::Wrapped<B>: 'a,
        W: Applicative<'a, Wrapped<B> = Self::Unwrapped>,
        Self::Unwrapped: Applicative<'a> + 'a + Copy,
    {
        self.traverse::<_, _, W>(|a| *a)
    }
}

#[cfg(test)]
mod test {
    use crate::Traversable;

    #[test]
    fn test_vec_option_traverse() {
        let a = vec![1, 2, 3];

        let result = a.traverse::<_, _, Option<_>>(|v| Option::Some((*v).to_string()));
        assert_eq!(
            Option::Some(vec!["1".to_string(), "2".to_string(), "3".to_string()]),
            result
        );
    }

    #[test]
    fn test_vec_option_traverse_fail() {
        let a = vec![1, 2, 3];

        let result =
            a.traverse::<_, _, Option<_>>(|v| if *v > 2 { None } else { Option::Some(*v) });
        assert_eq!(None, result);
    }

    #[test]
    fn test_vec_option_sequence() {
        let a = vec![Option::Some(1), Option::Some(2), Option::Some(3)];

        let result = a.sequence_a::<_, Option<_>>();
        assert_eq!(Option::Some(vec![1, 2, 3]), result);
    }

    #[test]
    fn test_vec_option_sequence_fail() {
        let a = vec![Option::Some(1), None, Option::Some(3)];

        let result = a.sequence_a::<_, Option<_>>();
        assert_eq!(None, result);
    }
}