Struct ComplementedConstraintStream 

pub struct ComplementedConstraintStream<S, A, B, K, EA, EB, KA, KB, C, D, Sc>
where
    Sc: Score,
{ /* private fields */ }

Zero-erasure constraint stream with complemented groups.

ComplementedConstraintStream results from calling complement on a GroupedConstraintStream. It ensures all keys from a complement source are represented, using default values for missing keys.

The key function for A entities returns Option<K> to allow skipping entities without valid keys (e.g., unassigned shifts).

Type Parameters

• S - Solution type
• A - Original entity type (e.g., Shift)
• B - Complement entity type (e.g., Employee)
• K - Group key type
• EA - Extractor for A entities
• EB - Extractor for B entities (complement source)
• KA - Key function for A (returns Option<K> to allow filtering)
• KB - Key function for B
• C - Collector type
• D - Default value function
• Sc - Score type

Example

use solverforge_scoring::stream::ConstraintFactory;
use solverforge_scoring::stream::collector::count;
use solverforge_scoring::api::constraint_set::IncrementalConstraint;
use solverforge_core::score::SimpleScore;

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

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

#[derive(Clone)]
struct Schedule {
    employees: Vec<Employee>,
    shifts: Vec<Shift>,
}

// Count shifts per employee, including employees with 0 shifts
let constraint = ConstraintFactory::<Schedule, SimpleScore>::new()
    .for_each(|s: &Schedule| &s.shifts)
    .group_by(|shift: &Shift| shift.employee_id, count())
    .complement(
        |s: &Schedule| s.employees.as_slice(),
        |emp: &Employee| emp.id,
        |_emp: &Employee| 0usize,
    )
    .penalize_with(|count: &usize| SimpleScore::of(*count as i64))
    .as_constraint("Shift count");

let schedule = Schedule {
    employees: vec![Employee { id: 0 }, Employee { id: 1 }, Employee { id: 2 }],
    shifts: vec![
        Shift { employee_id: 0 },
        Shift { employee_id: 0 },
        // Employee 1 has 0 shifts, Employee 2 has 0 shifts
    ],
};

// Employee 0: 2, Employee 1: 0, Employee 2: 0 → Total: -2
assert_eq!(constraint.evaluate(&schedule), SimpleScore::of(-2));

Implementations

impl<S, A, B, K, EA, EB, KA, KB, C, D, Sc> ComplementedConstraintStream<S, A, B, K, EA, EB, KA, KB, C, D, Sc>

where S: Send + Sync + 'static, A: Clone + Send + Sync + 'static, B: Clone + Send + Sync + 'static, K: Clone + Eq + Hash + Send + Sync + 'static, EA: Fn(&S) -> &[A] + Send + Sync, EB: Fn(&S) -> &[B] + Send + Sync, KA: Fn(&A) -> Option<K> + Send + Sync, KB: Fn(&B) -> K + Send + Sync, C: UniCollector<A> + Send + Sync + 'static, C::Accumulator: Send + Sync, C::Result: Clone + Send + Sync, D: Fn(&B) -> C::Result + Send + Sync, Sc: Score + 'static,

pub fn penalize_with<W>( self, weight_fn: W, ) -> ComplementedConstraintBuilder<S, A, B, K, EA, EB, KA, KB, C, D, W, Sc>

where W: Fn(&C::Result) -> Sc + Send + Sync,

Penalizes each complemented group with a weight based on the result.

pub fn penalize_hard_with<W>( self, weight_fn: W, ) -> ComplementedConstraintBuilder<S, A, B, K, EA, EB, KA, KB, C, D, W, Sc>

where W: Fn(&C::Result) -> Sc + Send + Sync,

Penalizes each complemented group, explicitly marked as hard constraint.

pub fn reward_with<W>( self, weight_fn: W, ) -> ComplementedConstraintBuilder<S, A, B, K, EA, EB, KA, KB, C, D, W, Sc>

where W: Fn(&C::Result) -> Sc + Send + Sync,

Rewards each complemented group with a weight based on the result.

pub fn reward_hard_with<W>( self, weight_fn: W, ) -> ComplementedConstraintBuilder<S, A, B, K, EA, EB, KA, KB, C, D, W, Sc>

where W: Fn(&C::Result) -> Sc + Send + Sync,

Rewards each complemented group, explicitly marked as hard constraint.

Trait Implementations

impl<S, A, B, K, EA, EB, KA, KB, C, D, Sc: Score> Debug for ComplementedConstraintStream<S, A, B, K, EA, EB, KA, KB, C, D, Sc>

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

Formats the value using the given formatter.