Trait Semigroup 

pub trait Semigroup: Sized {
    // Required method
    fn combine(self, other: Self) -> Self;
}

A type that supports an associative binary operation

Laws

Implementations must satisfy the associativity law:

a.combine(b).combine(c) == a.combine(b.combine(c))

Note on Ownership

The combine method takes self by value, not by reference. If you need to preserve the original values, you must clone them before combining.

Required Methods

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

Combine this value with another value associatively

Examples

use stillwater::Semigroup;

let v1 = vec![1, 2];
let v2 = vec![3, 4];
let result = v1.combine(v2);
assert_eq!(result, vec![1, 2, 3, 4]);

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Semigroup for String

fn combine(self, other: String) -> String

impl<K, V> Semigroup for BTreeMap<K, V>

where K: Ord + Clone, V: Semigroup + Clone,

Semigroup for BTreeMap that merges maps, combining values with the same key.

Same semantics as HashMap but maintains ordered keys.

Example

use std::collections::BTreeMap;
use stillwater::Semigroup;

let mut map1 = BTreeMap::new();
map1.insert("a", vec![1, 2]);

let mut map2 = BTreeMap::new();
map2.insert("a", vec![3, 4]);
map2.insert("b", vec![5]);

let combined = map1.combine(map2);
assert_eq!(combined.get("a"), Some(&vec![1, 2, 3, 4]));
assert_eq!(combined.get("b"), Some(&vec![5]));

fn combine(self, other: BTreeMap<K, V>) -> BTreeMap<K, V>

impl<K, V> Semigroup for HashMap<K, V>

where K: Eq + Hash + Clone, V: Semigroup + Clone,

Semigroup for HashMap that merges maps, combining values with the same key.

When keys conflict, values are combined using their Semigroup instance.

Example

use std::collections::HashMap;
use stillwater::Semigroup;

let mut map1 = HashMap::new();
map1.insert("errors", vec!["error1"]);
map1.insert("warnings", vec!["warn1"]);

let mut map2 = HashMap::new();
map2.insert("errors", vec!["error2"]);
map2.insert("info", vec!["info1"]);

let combined = map1.combine(map2);
// Result:
// {
//   "errors": ["error1", "error2"],  // Combined
//   "warnings": ["warn1"],            // From map1
//   "info": ["info1"]                 // From map2
// }

fn combine(self, other: HashMap<K, V>) -> HashMap<K, V>

impl<T1, T2> Semigroup for (T1, T2)

where T1: Semigroup, T2: Semigroup,

fn combine(self, other: (T1, T2)) -> (T1, T2)

impl<T1, T2, T3> Semigroup for (T1, T2, T3)

where T1: Semigroup, T2: Semigroup, T3: Semigroup,

fn combine(self, other: (T1, T2, T3)) -> (T1, T2, T3)

impl<T1, T2, T3, T4> Semigroup for (T1, T2, T3, T4)

where T1: Semigroup, T2: Semigroup, T3: Semigroup, T4: Semigroup,

fn combine(self, other: (T1, T2, T3, T4)) -> (T1, T2, T3, T4)

impl<T1, T2, T3, T4, T5> Semigroup for (T1, T2, T3, T4, T5)

where T1: Semigroup, T2: Semigroup, T3: Semigroup, T4: Semigroup, T5: Semigroup,

fn combine(self, other: (T1, T2, T3, T4, T5)) -> (T1, T2, T3, T4, T5)

impl<T1, T2, T3, T4, T5, T6> Semigroup for (T1, T2, T3, T4, T5, T6)

where T1: Semigroup, T2: Semigroup, T3: Semigroup, T4: Semigroup, T5: Semigroup, T6: Semigroup,

fn combine(self, other: (T1, T2, T3, T4, T5, T6)) -> (T1, T2, T3, T4, T5, T6)

impl<T1, T2, T3, T4, T5, T6, T7> Semigroup for (T1, T2, T3, T4, T5, T6, T7)

where T1: Semigroup, T2: Semigroup, T3: Semigroup, T4: Semigroup, T5: Semigroup, T6: Semigroup, T7: Semigroup,

fn combine( self, other: (T1, T2, T3, T4, T5, T6, T7), ) -> (T1, T2, T3, T4, T5, T6, T7)

impl<T1, T2, T3, T4, T5, T6, T7, T8> Semigroup for (T1, T2, T3, T4, T5, T6, T7, T8)

where T1: Semigroup, T2: Semigroup, T3: Semigroup, T4: Semigroup, T5: Semigroup, T6: Semigroup, T7: Semigroup, T8: Semigroup,

fn combine( self, other: (T1, T2, T3, T4, T5, T6, T7, T8), ) -> (T1, T2, T3, T4, T5, T6, T7, T8)

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> Semigroup for (T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T1: Semigroup, T2: Semigroup, T3: Semigroup, T4: Semigroup, T5: Semigroup, T6: Semigroup, T7: Semigroup, T8: Semigroup, T9: Semigroup,

fn combine( self, other: (T1, T2, T3, T4, T5, T6, T7, T8, T9), ) -> (T1, T2, T3, T4, T5, T6, T7, T8, T9)

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Semigroup for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T1: Semigroup, T2: Semigroup, T3: Semigroup, T4: Semigroup, T5: Semigroup, T6: Semigroup, T7: Semigroup, T8: Semigroup, T9: Semigroup, T10: Semigroup,

fn combine( self, other: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), ) -> (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Semigroup for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T1: Semigroup, T2: Semigroup, T3: Semigroup, T4: Semigroup, T5: Semigroup, T6: Semigroup, T7: Semigroup, T8: Semigroup, T9: Semigroup, T10: Semigroup, T11: Semigroup,

fn combine( self, other: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), ) -> (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Semigroup for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where T1: Semigroup, T2: Semigroup, T3: Semigroup, T4: Semigroup, T5: Semigroup, T6: Semigroup, T7: Semigroup, T8: Semigroup, T9: Semigroup, T10: Semigroup, T11: Semigroup, T12: Semigroup,

fn combine( self, other: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), ) -> (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

impl<T> Semigroup for Option<T>

where T: Semigroup,

Semigroup for Option that lifts the inner Semigroup.

• Some(a).combine(Some(b)) = Some(a.combine(b))
• Some(a).combine(None) = Some(a)
• None.combine(Some(b)) = Some(b)
• None.combine(None) = None

Example

use stillwater::Semigroup;

let opt1 = Some(vec![1, 2]);
let opt2 = Some(vec![3, 4]);
let result = opt1.combine(opt2);
assert_eq!(result, Some(vec![1, 2, 3, 4]));

let none: Option<Vec<i32>> = None;
let some = Some(vec![1, 2]);
assert_eq!(none.combine(some.clone()), some);

fn combine(self, other: Option<T>) -> Option<T>

impl<T> Semigroup for BTreeSet<T>

where T: Ord,

Semigroup for BTreeSet using union.

Same semantics as HashSet but maintains ordered elements.

Example

use std::collections::BTreeSet;
use stillwater::Semigroup;

let set1: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
let set2: BTreeSet<_> = [3, 4, 5].iter().cloned().collect();

let combined = set1.combine(set2);
assert_eq!(combined.len(), 5); // {1, 2, 3, 4, 5}

fn combine(self, other: BTreeSet<T>) -> BTreeSet<T>

impl<T> Semigroup for Vec<T>

fn combine(self, other: Vec<T>) -> Vec<T>

impl<T> Semigroup for HashSet<T>

where T: Eq + Hash,

Semigroup for HashSet using union.

Example

use std::collections::HashSet;
use stillwater::Semigroup;

let set1: HashSet<_> = [1, 2, 3].iter().cloned().collect();
let set2: HashSet<_> = [3, 4, 5].iter().cloned().collect();

let combined = set1.combine(set2);
assert_eq!(combined.len(), 5); // {1, 2, 3, 4, 5}

fn combine(self, other: HashSet<T>) -> HashSet<T>

Implementors

impl Semigroup for ConfigErrors

impl<T> Semigroup for Max<T>

where T: Ord,

impl<T> Semigroup for Min<T>

where T: Ord,

impl<T> Semigroup for Product<T>

where T: Mul<Output = T>,

impl<T> Semigroup for Sum<T>

where T: Add<Output = T>,

impl<T> Semigroup for First<T>

impl<T> Semigroup for Intersection<BTreeSet<T>>

where T: Ord + Clone,

impl<T> Semigroup for Intersection<HashSet<T>>

where T: Eq + Hash + Clone,

impl<T> Semigroup for Last<T>

impl<T> Semigroup for NonEmptyVec<T>