Struct GroupedUniConstraint 

pub struct GroupedUniConstraint<S, A, K, E, KF, C, W, Sc>
where
    C: UniCollector<A>,
    Sc: Score,
{ /* private fields */ }

Zero-erasure constraint that groups entities by key and scores based on collector results.

This enables incremental scoring for group-by operations:

• Tracks which entities belong to which group
• Maintains collector state per group
• Computes score deltas when entities are added/removed

All type parameters are concrete - no trait objects, no Arc allocations.

Type Parameters

• S - Solution type
• A - Entity type
• K - Group key type
• E - Extractor function for entities
• KF - Key function
• C - Collector type
• W - Weight function
• Sc - Score type

Example

use solverforge_scoring::constraint::grouped::GroupedUniConstraint;
use solverforge_scoring::stream::collector::count;
use solverforge_scoring::api::constraint_set::IncrementalConstraint;
use solverforge_core::{ConstraintRef, ImpactType};
use solverforge_core::score::SimpleScore;

#[derive(Clone, Hash, PartialEq, Eq)]
struct Shift { employee_id: usize }

#[derive(Clone)]
struct Solution { shifts: Vec<Shift> }

// Penalize based on squared workload per employee
let constraint = GroupedUniConstraint::new(
    ConstraintRef::new("", "Balanced workload"),
    ImpactType::Penalty,
    |s: &Solution| &s.shifts,
    |shift: &Shift| shift.employee_id,
    count::<Shift>(),
    |count: &usize| SimpleScore::of((*count * *count) as i64),
    false,
);

let solution = Solution {
    shifts: vec![
        Shift { employee_id: 1 },
        Shift { employee_id: 1 },
        Shift { employee_id: 1 },
        Shift { employee_id: 2 },
    ],
};

// Employee 1: 3 shifts -> 9 penalty
// Employee 2: 1 shift -> 1 penalty
// Total: -10
assert_eq!(constraint.evaluate(&solution), SimpleScore::of(-10));

Implementations

impl<S, A, K, E, KF, C, W, Sc> GroupedUniConstraint<S, A, K, E, KF, C, W, Sc>

where S: Send + Sync + 'static, A: Clone + Send + Sync + 'static, K: Clone + Eq + Hash + Send + Sync + 'static, E: Fn(&S) -> &[A] + Send + Sync, KF: Fn(&A) -> K + Send + Sync, C: UniCollector<A> + Send + Sync + 'static, C::Accumulator: Send + Sync, C::Result: Send + Sync, W: Fn(&C::Result) -> Sc + Send + Sync, Sc: Score + 'static,

pub fn new( constraint_ref: ConstraintRef, impact_type: ImpactType, extractor: E, key_fn: KF, collector: C, weight_fn: W, is_hard: bool, ) -> Self

Creates a new zero-erasure grouped constraint.

Arguments

• constraint_ref - Identifier for this constraint
• impact_type - Whether to penalize or reward
• extractor - Function to get entity slice from solution
• key_fn - Function to extract group key from entity
• collector - Collector to aggregate entities per group
• weight_fn - Function to compute score from collector result
• is_hard - Whether this is a hard constraint

Trait Implementations

impl<S, A, K, E, KF, C, W, Sc> Debug for GroupedUniConstraint<S, A, K, E, KF, C, W, Sc>

where C: UniCollector<A>, Sc: Score,

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

Formats the value using the given formatter.

impl<S, A, K, E, KF, C, W, Sc> IncrementalConstraint<S, Sc> for GroupedUniConstraint<S, A, K, E, KF, C, W, Sc>

where S: Send + Sync + 'static, A: Clone + Send + Sync + 'static, K: Clone + Eq + Hash + Send + Sync + 'static, E: Fn(&S) -> &[A] + Send + Sync, KF: Fn(&A) -> K + Send + Sync, C: UniCollector<A> + Send + Sync + 'static, C::Accumulator: Send + Sync, C::Result: Send + Sync, C::Value: Send + Sync, W: Fn(&C::Result) -> Sc + Send + Sync, Sc: Score + 'static,

fn evaluate(&self, solution: &S) -> Sc

Full evaluation of this constraint.

fn match_count(&self, solution: &S) -> usize

Returns the number of matches for this constraint.

fn initialize(&mut self, solution: &S) -> Sc

Initializes internal state by inserting all entities.

fn on_insert(&mut self, solution: &S, entity_index: usize) -> Sc

Called when an entity is inserted or its variable changes.

fn on_retract(&mut self, solution: &S, entity_index: usize) -> Sc

Called when an entity is retracted or before its variable changes.

fn reset(&mut self)

Resets internal state for a new solving session.

fn name(&self) -> &str

Returns the constraint name.

fn is_hard(&self) -> bool

Returns true if this is a hard constraint.

fn constraint_ref(&self) -> ConstraintRef

Returns the constraint reference (package + name).

fn get_matches(&self, _solution: &S) -> Vec<DetailedConstraintMatch<Sc>>

Returns detailed matches with entity justifications.

fn weight(&self) -> Sc

Returns the constraint weight (score per match).