Trait Monoid

Source

pub trait Monoid: Semigroup {
    // Required method
    fn unit() -> Self;
}

Available on crate feature monoid only.

Expand description

Monoid represents a binary operation that satisfies the following properties

Closure: op: T × T → T
Associativity: op(op(a, b), c) = op(a, op(b, c))
Existence of identity element: op(unit(), a) = a = op(a, unit())

§Deriving

Monoid can be derived like Semigroup, use monoid attribute.

use semigroup::{Semigroup, Monoid};
#[derive(Debug, Clone, PartialEq, Default, Semigroup)]
#[semigroup(monoid, with = "semigroup::op::Coalesce")]
pub struct ExampleStruct<'a> {
    pub str: Option<&'a str>,
    #[semigroup(with = "semigroup::op::Sum")]
    pub sum: u32,
}

let a = ExampleStruct::unit();
let b = ExampleStruct { str: Some("ten"), sum: 10 };
let c = ExampleStruct { str: None, sum: 100 };

// #[test]
semigroup::assert_monoid!(&a, &b, &c);
assert_eq!(a.semigroup(b).semigroup(c), ExampleStruct { str: Some("ten"), sum: 110 });

§Construction

Monoid can be constructed by crate::ConstructionMonoid like Semigroup, use monoid attribute.

Some operations are already provided by crate::op.

use semigroup::{Construction, Semigroup, Monoid};

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default, Hash, Construction)]
#[construction(monoid, commutative, unit = Self(0))]
pub struct Sum(u64);
impl Semigroup for Sum {
    fn op(base: Self, other: Self) -> Self {
        Self(base.0 + other.0)
    }
}
let (a, b, c) = (Sum::unit(), Sum(2), Sum(3));
// #[test]
semigroup::assert_monoid!(&a, &b, &c);
assert_eq!(a.semigroup(b).semigroup(c), Sum(5));

§Optional `Semigroup`

Option<Semigroup> can behave like Monoid. In such case, OptionMonoid is useful.

§Testing

Use crate::assert_monoid! macro.

The closure and associativity properties are same as Semigroup, so they are guaranteed by crate::assert_semigroup!. However, existence of identity element is not guaranteed the macro, so it must be verified manually using crate::assert_monoid!.