Trait Monoid 

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

    // Provided method
    fn concat<I>(iter: I) -> Self
       where I: IntoIterator<Item = Self> { ... }
}

A monoid: a semigroup with an identity element.

Laws (not enforced by type system):

• Associative: a.combine(b).combine(c) == a.combine(b.combine(c))
• Left identity: empty().combine(a) == a
• Right identity: a.combine(empty()) == a

Example

use algebra::Monoid;
use algebra::Semigroup;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct Product(i32);

impl Semigroup for Product {
    fn combine(&self, other: &Self) -> Self {
        Product(self.0 * other.0)
    }
}

impl Monoid for Product {
    fn empty() -> Self {
        Product(1)
    }
}

let x = Product(3);
let y = Product(5);
assert_eq!(x.combine(&y), Product(15));
assert_eq!(Product::empty().combine(&x), x);
assert_eq!(x.combine(&Product::empty()), x);

Required Methods

fn empty() -> Self

The identity element.

Provided Methods

fn concat<I>(iter: I) -> Self

where I: IntoIterator<Item = Self>,

Fold an iterator using combine, starting from empty.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<T: BoundedJoinSemilattice> Monoid for T