Struct SumMonoid 

pub struct SumMonoid<I: SumItem>(pub I);

Lifting is a no-op and combining is adding.

Tuple Fields

0: I

Implementations

impl<I: SumItem> SumMonoid<I>

pub fn sum(&self) -> &I

Trait Implementations

impl<I: Clone + SumItem> Clone for SumMonoid<I>

fn clone(&self) -> SumMonoid<I>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I: Debug + SumItem> Debug for SumMonoid<I>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I: SumItem> Default for SumMonoid<I>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, I> Deserialize<'de> for SumMonoid<I>

where I: Deserialize<'de> + SumItem,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I: SumItem> Encodable for SumMonoid<I>

type Encoded = SumMonoid<I>

type EncodeError = Infallible

type DecodeError = Infallible

fn encode( &self, encoded: &mut Self::Encoded, ) -> Result<(), EncodeError<Self::EncodeError>>

fn decode( &mut self, encoded: &Self::Encoded, ) -> Result<(), DecodeError<Self::DecodeError>>

fn to_encoded(&self) -> Result<Self::Encoded, EncodeError<Self::EncodeError>>

fn from_encoded( encoded: &Self::Encoded, ) -> Result<Self, DecodeError<Self::DecodeError>>

fn batch_encode<Dst: AsDestMutRef<Self::Encoded>>( src: &[Self], dst: &mut [Dst], ) -> Result<(), EncodeError<Self::EncodeError>>

impl<I: SumItem> Monoid for SumMonoid<I>

type Item = I

fn neutral() -> Self

Returns a value that, when combined with some other value x, will return x.

fn lift(item: &Self::Item) -> Self

Returns a the value corresponding to the item. Ideally, collisions should be rare, i.e. they should at least not happen by accident, and probably also be hard to find on purpose.

fn combine(&self, other: &Self) -> Self

Returns the combination of two items. Not necessarily commutative. A good fingerprint monoid will make it difficult to produce the same output with different inputs (commutativity is allowed).

impl<I: PartialEq + SumItem> PartialEq for SumMonoid<I>

fn eq(&self, other: &SumMonoid<I>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I> Serialize for SumMonoid<I>

where I: Serialize + SumItem,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<I: Eq + SumItem> Eq for SumMonoid<I>

impl<I: SumItem> StructuralPartialEq for SumMonoid<I>