tests/vector.rs


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

//! Tests if creating a Free Monad for a Vec works. Not sure if this is useful in any way.
//! It is a nice illustration that Free Monads are tree-like though.

use higher_free_macro::free;
use higher::{Functor, Bind, Apply};

free!(FreeVec<A>, Vec<FreeVec<A>>);

#[test]
fn test_vector(){
    let fv = FreeVec::lift_f(vec![2,3,4]);
    let fv = fv.fmap(|x| x*2);
    let fv = fv.bind(|x| if x%3 == 0 {FreeVec::Pure(x)} else {FreeVec::lift_f(vec![x,x+1])});
    let f = FreeVec::lift_f(vec![(|x| (x as f32) / 3.0) as fn(u32)->f32, (|x| (x+2) as f32) as fn(u32)->f32]);
    let r = fv.apply(f.fmap(Into::into));
    match r {
        FreeVec::Free(v) => {
            match &**v{
                [a,b] => {
                    match a {
                        FreeVec::Free(v) => {
                            match &***v {
                                [a,b,c] => {
                                    match a {
                                        FreeVec::Free(v) => {
                                            match &***v {
                                                [a,b] => {
                                                    match a{
                                                        FreeVec::Free(_) => unreachable!(),
                                                        FreeVec::Pure(v) => {assert_eq!(4.0f32/3.0f32, *v)}
                                                    }
                                                    match b{
                                                        FreeVec::Free(_) => unreachable!(),
                                                        FreeVec::Pure(v) => {assert_eq!(5.0f32/3.0f32, *v)}
                                                    }
                                                },
                                                _ => unreachable!()
                                            }
                                        }
                                        FreeVec::Pure(_) => unreachable!(),
                                    }
                                    match b {
                                        FreeVec::Free(_) => unreachable!(),
                                        FreeVec::Pure(v) => assert_eq!(2.0f32, *v),
                                    }
                                    match c {
                                        FreeVec::Free(v) => {
                                            match &***v {
                                                [a,b] => {
                                                    match a{
                                                        FreeVec::Free(_) => unreachable!(),
                                                        FreeVec::Pure(v) => {assert_eq!(8.0f32/3.0f32, *v)}
                                                    }
                                                    match b{
                                                        FreeVec::Free(_) => unreachable!(),
                                                        FreeVec::Pure(v) => {assert_eq!(3.0f32, *v)}
                                                    }
                                                },
                                                _ => unreachable!()
                                            }
                                        }
                                        FreeVec::Pure(_) => unreachable!(),
                                    }
                                },
                                _ => unreachable!()
                            }
                        }
                        FreeVec::Pure(_) => unreachable!()
                    }

                    match b {
                        FreeVec::Free(v) => {
                            match &***v {
                                [a,b,c] => {
                                    match a {
                                        FreeVec::Free(v) => {
                                            match &***v {
                                                [a,b] => {
                                                    match a{
                                                        FreeVec::Free(_) => unreachable!(),
                                                        FreeVec::Pure(v) => {assert_eq!(6.0f32, *v)}
                                                    }
                                                    match b{
                                                        FreeVec::Free(_) => unreachable!(),
                                                        FreeVec::Pure(v) => {assert_eq!(7.0f32, *v)}
                                                    }
                                                },
                                                _ => unreachable!()
                                            }
                                        }
                                        FreeVec::Pure(_) => unreachable!(),
                                    }
                                    match b {
                                        FreeVec::Free(_) => unreachable!(),
                                        FreeVec::Pure(v) => assert_eq!(8.0f32, *v),
                                    }
                                    match c {
                                        FreeVec::Free(v) => {
                                            match &***v {
                                                [a,b] => {
                                                    match a{
                                                        FreeVec::Free(_) => unreachable!(),
                                                        FreeVec::Pure(v) => {assert_eq!(10.0f32, *v)}
                                                    }
                                                    match b{
                                                        FreeVec::Free(_) => unreachable!(),
                                                        FreeVec::Pure(v) => {assert_eq!(11.0f32, *v)}
                                                    }
                                                },
                                                _ => unreachable!()
                                            }
                                        }
                                        FreeVec::Pure(_) => unreachable!(),
                                    }
                                },
                                _ => unreachable!()
                            }
                        }
                        FreeVec::Pure(_) => unreachable!()
                    }
                },
                _ => unreachable!()
            }
        }
        FreeVec::Pure(_) => unreachable!()
    }
}