Monoid implementation of alternating sum with Rust.

alt_sum.rs

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct AltSum {
    sum: i64,
    len: usize,
}

impl AltSum {
    pub fn empty() -> Self {
        Self { sum: 0, len: 0 }
    }

    pub fn one(item: i64) -> Self {
        Self { sum: item, len: 1 }
    }

    pub fn sum(self) -> i64 {
        self.sum
    }
    pub fn len(self) -> usize {
        self.len
    }
}

impl Default for AltSum {
    fn default() -> Self {
        Self::empty()
    }
}

impl Monoid for AltSum {
    const ID: Self = Self { sum: 0, len: 0 };

    fn op(self, other: Self) -> Self {
        Self {
            sum: self.sum
                + if self.len % 2 == 0 {
                    other.sum
                } else {
                    -other.sum
                },
            len: self.len + other.len,
        }
    }
}

monoid.rs

/// Monoid must satisfy:
/// ```rs
/// fn test<M: Monoid>(m: M, n: M, l: M) {
///   assert_eq!(m.op(M::ID), m);
///   assert_eq!(M::ID.op(m), m);
///   assert_eq!(m.op(n.op(l)), m.op(n).op(l));
/// }
/// ```
pub trait Monoid: Copy + Eq {
    const ID: Self;
    fn op(self, other: Self) -> Self;
}