functor_derive 0.4.3

A derive macro to derive a functor for a type.
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

use crate::funcmap::{T1, T2};
use functor_derive::*;
use std::{
    collections::{HashMap, HashSet},
    hash::Hash,
};

#[test]
fn field_of_hash_map_type_is_mapped_over_key() {
    #[derive(Functor, Debug, PartialEq)]
    struct Test<T: Eq + Hash>(HashMap<T, ()>);

    let src = Test([(T1, ())].into());
    let dst = src.fmap(|_| T2);

    assert_eq!(dst, Test([(T2, ())].into()));
}

#[test]
fn field_of_hash_map_type_is_mapped_over_value() {
    #[derive(Functor, Debug, PartialEq)]
    struct Test<T>(HashMap<(), T>);

    let src = Test([((), T1)].into());
    let dst = src.fmap(|_| T2);

    assert_eq!(dst, Test([((), T2)].into()));
}

// We don't have iterators in our std implementations.
// #[test]
// fn field_of_hash_map_into_iter_type_is_mapped_over_key() {
//     // #[derive(Functor, Debug)]
//     struct Test<T>(hash_map::IntoIter<T, ()>);
//
//     let src = Test(HashMap::from([(T1, ())]).into_iter());
//     let dst = src.fmap(|_| T2);
//
//     assert_eq!(dst.0.collect::<Vec<_>>(), [(T2, ())]);
// }
//
// #[test]
// fn field_of_hash_map_into_iter_type_is_mapped_over_value() {
//     #[derive(Functor, Debug)]
//     struct Test<T>(hash_map::IntoIter<(), T>);
//
//     let src = Test(HashMap::from([((), T1)]).into_iter());
//     let dst = src.fmap(|_| T2);
//
//     assert_eq!(dst.0.collect::<Vec<_>>(), [((), T2)]);
// }

#[test]
fn field_of_hash_set_type_is_mapped() {
    #[derive(Functor, Debug, PartialEq)]
    struct Test<T: Eq + Hash>(HashSet<T>);

    let src = Test([T1].into());
    let dst = src.fmap(|_| T2);

    assert_eq!(dst, Test([T2].into()));
}

// We don't have iterators in our std implementations.
// #[test]
// fn field_of_hash_set_into_iter_type_is_mapped() {
//     #[derive(Functor, Debug)]
//     struct Test<T>(hash_set::IntoIter<T>);
//
//     let src = Test(HashSet::from([T1]).into_iter());
//     let dst = src.fmap(|_| T2);
//
//     assert_eq!(dst.0.collect::<Vec<_>>(), [T2]);
// }