Struct Constraint 

pub struct Constraint { /* private fields */ }

A constraint that can be posted to the model

Implementations

impl Constraint

pub fn and(self, other: Constraint) -> Constraint

Combine this constraint with another using AND logic

Examples found in repository

examples/runtime_api_demo.rs (line 150)

fn example_4_constraint_composition() {
    println!("📝 Example 4: Constraint Composition");
    
    let mut m = Model::default();
    let x = m.int(0, 20);
    let y = m.int(0, 20);
    
    // Create individual constraints
    let c1 = x.gt(int(5));      // x > int(5)
    let c2 = x.lt(int(15));     // x < int(15)  
    let c3 = y.ge(int(10));     // y >= int(10)
    
    // Compose them: (x > 5 AND x < 15) AND y >= 10
    let range_constraint = c1.and(c2);
    let combined = range_constraint.and(c3);
    
    m.post(combined);
    
    if let Ok(solution) = m.solve() {
        println!("✓ Solution with composed constraints:");
        println!("  x = {:?} (should be 6-14)", solution[x]);
        println!("  y = {:?} (should be >= 10)", solution[y]);
    } else {
        println!("❌ No solution found");
    }
    println!();
}

// =================== PHASE 2 EXAMPLES ===================

/// Example 5: Model::c() ultra-short syntax
fn example_5_model_c_syntax() {
    println!("📝 Example 5: Model::c() Ultra-Short Syntax (Phase 2)");
    
    let mut m = Model::default();
    let x = m.int(1, 10);
    let y = m.int(1, 10);
    let sum = m.int(2, 20);
    
    // Ultra-short Model::c() syntax - auto-posts constraints
    m.c(x).gt(int(3));                    // x > int(3)
    m.c(y).le(int(8));                    // y <= int(8)
    m.c(x).add(y).eq(sum);               // x + y == sum
    m.c(sum).eq(int(12));                // sum == int(12)
    
    if let Ok(solution) = m.solve() {
        println!("✓ Solution found:");
        println!("  x = {:?}", solution[x]);
        println!("  y = {:?}", solution[y]);
        println!("  sum = {:?}", solution[sum]);
    } else {
        println!("❌ No solution found");
    }
    println!();
}

/// Example 6: Builder fluent interface
fn example_6_builder_fluent_interface() {
    println!("📝 Example 6: Builder Fluent Interface (Phase 2)");
    
    let mut m = Model::default();
    let a = m.int(0, 20);
    let b = m.int(0, 20);
    let result = m.int(0, 100);
    
    // Complex expression building with fluent interface
    m.c(a).mul(int(3)).add(int(5)).le(int(50));         // a * int(3) + int(5) <= int(50)
    m.c(b).div(int(2)).sub(int(1)).ge(int(2));          // b / int(2) - int(1) >= int(2)
    m.c(a).add(b).mul(int(2)).eq(result);              // (a + b) * int(2) == result
    m.c(result).ne(int(20));                           // result != int(20)
    
    if let Ok(solution) = m.solve() {
        println!("✓ Complex fluent constraints satisfied:");
        println!("  a = {:?}", solution[a]);
        println!("  b = {:?}", solution[b]);
        println!("  result = {:?}", solution[result]);
    } else {
        println!("❌ No solution found");
    }
    println!();
}

/// Example 7: Global constraint shortcuts
fn example_7_global_constraints() {
    println!("📝 Example 7: Global Constraint Shortcuts (Phase 2)");
    
    let mut m = Model::default();
    let digits = (0..4).map(|_| m.int(1, 4)).collect::<Vec<_>>();
    
    // Ultra-short global constraints
    m.alldiff(&digits);              // All digits must be different
    m.c(digits[0]).gt(digits[1]);    // First > Second
    m.c(digits[2]).add(digits[3]).eq(int(5)); // Third + Fourth == int(5)
    
    if let Ok(solution) = m.solve() {
        println!("✓ Global constraint solution:");
        for (i, &digit) in digits.iter().enumerate() {
            println!("  digit[{}] = {:?}", i, solution[digit]);
        }
    } else {
        println!("❌ No solution found");
    }
    println!();
}

/// Example 8: Mixed Phase 1 & 2 usage
fn example_8_mixed_phase_usage() {
    println!("📝 Example 8: Mixed Phase 1 & 2 Usage");
    
    let mut m = Model::default();
    let x = m.int(1, 10);
    let y = m.int(1, 10);
    let z = m.int(1, 10);
    
    // Phase 1: Manual constraint creation and posting
    let constraint1 = x.add(y).gt(int(5));
    m.post(constraint1);
    
    // Phase 2: Auto-posting builder syntax
    m.c(y).mul(int(2)).le(z.add(int(3)));
    
    // Global constraints (Phase 2)
    m.alldiff(&[x, y, z]);
    
    // Phase 1: Complex constraint composition  
    let c1 = x.lt(int(8));
    let c2 = y.ge(int(2));
    let combined = c1.and(c2);
    m.post(combined);
    
    if let Ok(solution) = m.solve() {
        println!("✓ Mixed API solution:");
        println!("  x = {:?}", solution[x]);
        println!("  y = {:?}", solution[y]);
        println!("  z = {:?}", solution[z]);
    } else {
        println!("❌ No solution found");
    }
    println!();
}

pub fn or(self, other: Constraint) -> Constraint

Combine this constraint with another using OR logic

pub fn not(self) -> Constraint

Negate this constraint

impl Constraint

pub fn and_all(constraints: Vec<Constraint>) -> Option<Constraint>

Combine multiple constraints with AND logic

pub fn or_all(constraints: Vec<Constraint>) -> Option<Constraint>

Combine multiple constraints with OR logic

Trait Implementations

impl Clone for Constraint

fn clone(&self) -> Constraint

Returns a duplicate of the value.

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

Performs copy-assignment from source.