funlib 0.1.8

Rust functional library
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

//!
//! Monoid implementations and tests
//!

use crate::Monoid;

macro_rules! monoid {
  ($t:ident, $v:expr) => {
    impl Monoid for $t {
      fn mempty() -> Self { $v }
    }
  }
}

monoid!(i8, 0);
monoid!(i16, 0);
monoid!(i32, 0);
monoid!(i64, 0);
monoid!(u8, 0);
monoid!(u16, 0);
monoid!(u32, 0);
monoid!(u64, 0);
monoid!(f32, 0.0);
monoid!(f64, 0.0);

impl<A: Monoid> Monoid for Option<A> {
  fn mempty() -> Self {
    None::<A>
  }
}

impl<A: Monoid> Monoid for Box<A> {
  fn mempty() -> Self {
    Box::new(A::mempty())
  }
}

impl<'a> Monoid for &'a str {
  fn mempty() -> Self {
    ""
  }
}

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

  #[cfg(test)]
  mod laws {
    use crate::Monoid;
    use crate::Semigroup;

    macro_rules! laws {
      ($t: ident, $v: expr, $v2: expr, $v3: expr) => {
        #[allow(non_snake_case)]
        #[test]
        fn $t() {
          assert_eq!($v, $t::mempty().mappend(&$v));
          assert_eq!($v, $v.mappend(&$t::mempty()));
          assert_eq!($v.mappend(&$v2.mappend(&$v3)),($v.mappend(&$v2)).mappend(&$v3));
        }
      };
    }
    macro_rules! laws2 {
      ($t: ident, $t2: ident, $v: expr, $v2: expr, $v3: expr) => {
        #[allow(non_snake_case)]
        #[test]
        fn $t() {
          assert_eq!($v, $t::<$t2>::mempty().mappend(&$v));
          assert_eq!($v, $v.mappend(&$t::mempty()));
          assert_eq!($v.mappend(&$v2.mappend(&$v3)),($v.mappend(&$v2)).mappend(&$v3));
        }
      };
    }
    laws!(i32, 5i32, 6i32, 10i32);
    laws!(u64, 5u64, 6u64, 10u64);
    laws2!(Option, u8, Some(5u8), Some(6u8), Some(10u8));
    laws2!(Box, i64, Box::new(5i64), Box::new(6i64), Box::new(10i64));
  }

  #[test]
  fn i32() {
    assert_eq!(0, i32::mempty());
  }

  #[test]
  fn u8() {
    assert_eq!(0, u8::mempty());
  }

  #[test]
  fn option_i64() {
    assert_eq!(None::<i64>, Option::<i64>::mempty());
  }

  #[test]
  fn _box_i8() {
    assert_eq!(Box::new(0), Box::<i8>::mempty());
  }

  #[test]
  fn _box_str() {
    assert_eq!(Box::new(""), Box::<&str>::mempty());
  }

}