fp-collections 0.0.2

An alternate collections library for rust
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

pub mod identity {
    use fp_collections::helpers::*;
    use fp_collections::{list::List, ls};

    #[test]
    fn it_returns_what_it_gets() {
        let object = 23;
        assert_eq!(identity(object), object);

        let object = "hello";
        assert_eq!(identity(object), object);

        let object = &[1, 2, 3];
        assert_eq!(identity(object), object);

        let object = ls![1, 2, 3];
        assert_eq!(identity(object.clone()), object);
    }

    #[test]
    fn it_can_be_used_pointfree() {
        let list = ls![1, 2, 3];
        let result = list.clone().map(identity);
        assert_eq!(list, result);
    }
}

pub mod constant {
    use fp_collections::helpers::*;
    use fp_collections::{list::List, ls};

    #[test]
    fn it_returns_a_getter() {
        let object = 23;
        assert_eq!(constant(object)(), object);

        let object = "hello";
        assert_eq!(constant(object)(), object);

        let object = &[1, 2, 3];
        assert_eq!(constant(object)(), object);

        let object = ls![1, 2, 3];
        assert_eq!(constant(object.clone())(), object);
    }

    // TODO: Add ability to use in a pointfree way
    // #[test]
    // fn it_can_be_used_pointfree() {
    // let list = ls![1, 2, 3];
    // let result = list.clone().map(constant(5));
    // assert_eq!(list, ls![5, 5, 5]);
    // }
}

pub mod compose2 {
    use fp_collections::helpers::*;
    use fp_collections::{list::List, ls};

    #[test]
    fn it_composes_same_types() {
        fn add5(x: i32) -> i32 {
            x + 5
        }
        fn mul2(x: i32) -> i32 {
            x * 2
        }

        let do_math = compose2(add5, mul2);

        assert_eq!(do_math(5), 15);
    }

    #[test]
    fn it_composes_different_types() {
        fn to_text(x: i32) -> String {
            format!("My number is {}", x)
        }
        fn to_list(x: String) -> List<String> {
            ls![x]
        }

        let execute = compose2(to_list, to_text);

        assert_eq!(execute(666), ls![String::from("My number is 666")]);
    }
}

pub mod compose {
    use fp_collections::{compose, helpers::*};
    use fp_collections::{list::List, ls};

    #[test]
    fn it_composes_same_types() {
        fn add5(x: i32) -> i32 {
            x + 5
        }
        fn mul2(x: i32) -> i32 {
            x * 2
        }
        fn sub1(x: i32) -> i32 {
            x - 1
        }

        let do_math = compose!(sub1, add5, mul2);

        assert_eq!(do_math(5), 14);
    }

    #[test]
    fn it_composes_different_types() {
        fn to_text(x: i32) -> String {
            format!("My number is {}", x)
        }
        fn to_list(x: String) -> List<String> {
            ls![x, "hello".to_string(), "world".to_string()]
        }
        fn map_to_5(x: List<String>) -> List<i32> {
            x.map(|_| 5)
        }

        let execute = compose!(map_to_5, to_list, to_text);

        assert_eq!(execute(666), ls![5, 5, 5]);
    }
}