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
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

pub mod impl_alloc;
pub mod impl_core;
pub mod impl_std;

use paste::paste;

// Re-export derive macro.
pub use functor_derive_lib::*;
pub use impl_alloc::*;
#[allow(unused)]
pub use impl_core::*;
pub use impl_std::*;

pub trait Functor<A>: Sized {
    type Target<B>;

    fn fmap<B>(self, f: impl Fn(A) -> B) -> Self::Target<B>;

    fn try_fmap<B, E>(self, f: impl Fn(A) -> Result<B, E>) -> Result<Self::Target<B>, E>;
}

#[macro_export]
macro_rules! functor_n {
    ($n:expr) => {
        paste! {
        #[doc(hidden)]
        pub trait [<Functor $n>]<A>: Sized {
            type Target<B>;

            fn [<__fmap_ $n _ref>]<B>(self, f: &impl Fn(A) -> B) -> Self::Target<B>;

            fn [<__try_fmap_ $n _ref>]<B, E>(self, f: &impl Fn(A) -> Result<B, E>) -> Result<Self::Target<B>, E>;
        }
        }
    };
}

functor_n!(0);
functor_n!(1);
functor_n!(2);
functor_n!(3);
functor_n!(4);
functor_n!(5);
functor_n!(6);
functor_n!(7);
functor_n!(8);
functor_n!(9);
functor_n!(10);
functor_n!(11);
functor_n!(12);
functor_n!(13);
functor_n!(14);
functor_n!(15);
functor_n!(16);
functor_n!(17);
functor_n!(18);
functor_n!(19);
// please don't use more than 20 generics.

#[doc(hidden)]
pub trait FunctorValues<A>: Sized {
    type Target<B>;

    fn fmap_values<B>(self, f: impl Fn(A) -> B) -> Self::Target<B>;

    fn try_fmap_values<B, E>(self, f: impl Fn(A) -> Result<B, E>) -> Result<Self::Target<B>, E>;
}

#[doc(hidden)]
pub trait FunctorOrdKeys<A: Ord>: Sized {
    type Target<B: Ord>;

    fn fmap_keys<B: Ord>(self, f: impl Fn(A) -> B) -> Self::Target<B> {
        self.__fmap_0_ref(&f)
    }

    fn try_fmap_keys<B: Ord, E>(self, f: impl Fn(A) -> Result<B, E>) -> Result<Self::Target<B>, E> {
        self.__try_fmap_0_ref(&f)
    }

    fn __fmap_0_ref<B: Ord>(self, f: &impl Fn(A) -> B) -> Self::Target<B>;

    fn __try_fmap_0_ref<B: Ord, E>(
        self,
        f: &impl Fn(A) -> Result<B, E>,
    ) -> Result<Self::Target<B>, E>;
}

#[macro_export]
macro_rules! functor_impl {
    ($typ:ident) => {
        paste::paste! {
            impl<A> Functor<A> for $typ<A> {
                type Target<B> = $typ<B>;

                fn fmap<B>(self, f: impl Fn(A) -> B) -> Self::Target<B> {
                    self.[<__fmap_0_ref>](&f)
                }

                fn try_fmap<B, E>(self, f: impl Fn(A) -> Result<B, E>) -> Result<Self::Target<B>, E> {
                    self.[<__try_fmap_0_ref>](&f)
                }
            }
        }
    };
}