Module stream 

Fluent constraint stream API for zero-erasure constraint programming.

This module provides an ergonomic builder pattern for defining constraints that compile to fully-typed, monomorphized constraint implementations.

Overview

The stream API transforms verbose constraint definitions into concise, fluent declarations while preserving full type information through the entire evaluation pipeline.

Example

use solverforge_scoring::stream::ConstraintFactory;
use solverforge_scoring::api::constraint_set::{ConstraintSet, IncrementalConstraint};
use solverforge_core::score::SimpleScore;

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

#[derive(Clone, Debug)]
struct Shift {
    employee_idx: Option<usize>,
    required_skill: String,
}

// Define constraints using the fluent API
let unassigned = ConstraintFactory::<Schedule, SimpleScore>::new()
    .for_each(|s: &Schedule| &s.shifts)
    .filter(|shift: &Shift| shift.employee_idx.is_none())
    .penalize(SimpleScore::of(1))
    .as_constraint("Unassigned shift");

// Use the constraint
let schedule = Schedule {
    shifts: vec![
        Shift { employee_idx: Some(0), required_skill: "A".into() },
        Shift { employee_idx: None, required_skill: "B".into() },
    ],
};

assert_eq!(unassigned.evaluate(&schedule), SimpleScore::of(-1));

Architecture

The stream builders produce existing constraint types at definition time:

ConstraintFactory::new()
    .for_each(extractor)     -> UniConstraintStream<S, A, Sc>
    .filter(predicate)            -> UniConstraintStream (accumulates filters)
    .penalize(weight)             -> UniConstraintBuilder<S, A, Sc>
    .as_constraint(name)          -> IncrementalUniConstraint<S, A, Sc>

The final IncrementalUniConstraint is fully monomorphized with no virtual dispatch in the hot path.

Modules

collector

Collectors for grouping and aggregating entities.

filter

Zero-erasure filter composition for constraint streams.

joiner

Joiner functions for constraint stream joins.

Structs

BalanceConstraintBuilder

Zero-erasure builder for finalizing a balance constraint.

BalanceConstraintStream

Zero-erasure stream for building balance constraints.

BiConstraintBuilder

BiConstraintStream

ComplementedConstraintBuilder

Zero-erasure builder for finalizing a complemented constraint.

ComplementedConstraintStream

Zero-erasure constraint stream with complemented groups.

ConstraintFactory

Factory for creating constraint streams.

CrossBiConstraintBuilder

Zero-erasure builder for finalizing a cross-bi constraint.

CrossBiConstraintStream

Zero-erasure constraint stream over cross-entity pairs.

FlattenedBiConstraintBuilder

Builder for finalizing an O(1) indexed flattened bi-constraint.

FlattenedBiConstraintStream

O(1) flattened bi-constraint stream.

GroupedConstraintBuilder

Zero-erasure builder for finalizing a grouped constraint.

GroupedConstraintStream

Zero-erasure constraint stream over grouped entities.

IfExistsBuilder

Zero-erasure builder for finalizing an if_exists constraint.

IfExistsStream

Zero-erasure stream for building if_exists/if_not_exists constraints.

PentaConstraintBuilder

PentaConstraintStream

QuadConstraintBuilder

QuadConstraintStream

TriConstraintBuilder

TriConstraintStream

UniConstraintBuilder

Zero-erasure builder for finalizing a uni-constraint.

UniConstraintStream

Zero-erasure constraint stream over a single entity type.