Fix readme

Author: radevgit

README.md

@@ -17,7 +17,7 @@ This library provides efficient algorithms and data structures for solving const
 - **Comparison**: `==`, `!=`, `<`, `<=`, `>`, `>=` (natural syntax)
 - **Boolean Logic**: `and()`, `or()`, `not()` with array syntax `and([a,b,c])` and variadic syntax `and(a,b,c,d)`
 - **Global**: `alldiff()`, `allequal()`, element `x[y] = z`, `count(vars, value, count)`, `table(vars, tuples)`
-- **Ordering**: `between(lower, middle, upper)` for ternary ordering constraints
+- **Ordering**: `a <= b <= c`, `a < b < c`, `a >= b >= c`, `a > b > c` (natural `between` constraints) 
 - **Cardinality**: `at_least(vars, value, count)`, `at_most(vars, value, count)`, `exactly(vars, value, count)`
 - **Conditional**: `if_then(condition, constraint)`, `if_then_else(condition, then_constraint, else_constraint)`
 
@@ -33,16 +33,18 @@ cspsolver = "0.5.15"
 
 ## Examples
 
+
 ```bash
 cargo run --release --example sudoku
 cargo run --release --example n_queens
-cargo run --release --example count_demo      # Count constraint demonstrations
-cargo run --release --example table_demo      # Table constraint with practical examples
-cargo run --release --example magic_square    # Magic squares with enhanced constraints
+cargo run --release --example count_demo 
+cargo run --release --example table_demo
+cargo run --release --example magic_square
 ```
 
 
 
+
 ```
 🧩 Solving PLATINUM puzzle:
 📊 Puzzle stats: 17 clues given, 64 empty cells
@@ -96,7 +98,8 @@ fn main() {
     post!(m, allequal([x, y])); // All equal
 
     // Ordering constraints - powerful ternary relationships
-    post!(m, between(x, y, z)); // x <= y <= z (ordering constraint)
+    post!(m, x <= y <= z);       // Natural chained comparison syntax
+    post!(m, between(x, y, z));  // Alternative function syntax
 
     // Cardinality constraints - counting with fine-grained control
     let tasks = vec![m.int(1, 3), m.int(1, 3), m.int(1, 3)]; // 1=low, 2=medium, 3=high priority
@@ -221,12 +224,21 @@ fn main() {
 The latest version includes powerful new constraint types for advanced modeling:
 
 #### Between Constraints
-Enforce ternary ordering relationships with a single constraint:
+Enforce ternary ordering relationships with natural chained comparison syntax:
 ```rust
 let start = m.int(1, 10);
 let middle = m.int(5, 15); 
 let end = m.int(10, 20);
-post!(m, between(start, middle, end)); // start <= middle <= end
+
+// Natural chained comparison syntax (recommended)
+post!(m, start <= middle <= end);
+
+// Alternative function syntax
+post!(m, between(start, middle, end));
+
+// Other chained comparisons
+post!(m, start < middle < end);     // Strict inequalities
+post!(m, end >= middle >= start);   // Reverse order
 ```
 
 #### Cardinality Constraints  

examples/chained_comparisons_demo.rs

@@ -0,0 +1,57 @@
+use cspsolver::prelude::*;
+
+fn main() {
+    let mut m = Model::default();
+    
+    // Test the new chained comparison syntax
+    let lower = m.int(1, 5);
+    let middle = m.int(3, 8);
+    let upper = m.int(7, 12);
+    
+    println!("=== Testing Chained Comparison Syntax ===");
+    
+    // Original between constraint syntax
+    post!(m, between(lower, middle, upper));
+    println!("✅ Original syntax: between(lower, middle, upper)");
+    
+    // New natural chained comparison syntax
+    let a = m.int(1, 5);
+    let b = m.int(3, 8);
+    let c = m.int(7, 12);
+    
+    post!(m, a <= b <= c);
+    println!("✅ New syntax: a <= b <= c");
+    
+    // Test other chained comparison types
+    let x = m.int(10, 15);
+    let y = m.int(5, 10);
+    let z = m.int(1, 6);
+    
+    post!(m, x >= y >= z);
+    println!("✅ New syntax: x >= y >= z");
+    
+    // Test strict inequalities (these create separate constraints)
+    let p = m.int(1, 5);
+    let q = m.int(3, 8);
+    let r = m.int(7, 12);
+    
+    post!(m, p < q < r);
+    println!("✅ New syntax: p < q < r");
+    
+    if let Ok(solution) = m.solve() {
+        println!("\n=== Solution Found ===");
+        println!("lower = {:?}, middle = {:?}, upper = {:?}", 
+                solution[lower], solution[middle], solution[upper]);
+        println!("a = {:?}, b = {:?}, c = {:?}", 
+                solution[a], solution[b], solution[c]);
+        println!("x = {:?}, y = {:?}, z = {:?}", 
+                solution[x], solution[y], solution[z]);
+        println!("p = {:?}, q = {:?}, r = {:?}", 
+                solution[p], solution[q], solution[r]);
+    } else {
+        println!("No solution found");
+    }
+    
+    println!("\n🎉 Chained comparison syntax working!");
+    println!("You can now use: a <= b <= c instead of between(a, b, c)");
+}

src/constraint_macros.rs

@@ -28,6 +28,8 @@ impl ConstraintRef {
 /// 
 /// **Basic comparisons**: `var op var`, `var op literal`, `var op (expr)`, `var op int(value)`, `var op float(value)`
 /// 
+/// **Chained comparisons**: `a <= b <= c`, `a < b < c`, `a >= b >= c`, `a > b > c` (natural between constraints)
+/// 
 /// **Array indexing**: `vars[i] op vars[j]`, `vars[i] op var`, `var op vars[i]`, `vars[i] op literal`, `literal op vars[i]`, `array[var] == value` (Element)
 /// 
 /// **Arithmetic**: `var op var +/- var`, `var op var */÷ var`, `var op var % divisor`
@@ -43,6 +45,30 @@ impl ConstraintRef {
 /// Where `op` is any of: `==`, `!=`, `<`, `<=`, `>`, `>=`
 #[macro_export]
 macro_rules! post {
+    // Chained comparisons for between constraints: a <= b <= c, a < b < c, etc.
+    ($model:expr, $lower:ident <= $middle:ident <= $upper:ident) => {{
+        $model.props.between_constraint($lower, $middle, $upper);
+        $crate::constraint_macros::ConstraintRef::new(0)
+    }};
+    
+    ($model:expr, $lower:ident < $middle:ident < $upper:ident) => {{
+        $model.props.less_than($lower, $middle);
+        $model.props.less_than($middle, $upper);
+        $crate::constraint_macros::ConstraintRef::new(0)
+    }};
+    
+    ($model:expr, $lower:ident >= $middle:ident >= $upper:ident) => {{
+        $model.props.greater_than_or_equals($lower, $middle);
+        $model.props.greater_than_or_equals($middle, $upper);
+        $crate::constraint_macros::ConstraintRef::new(0)
+    }};
+    
+    ($model:expr, $lower:ident > $middle:ident > $upper:ident) => {{
+        $model.props.greater_than($lower, $middle);
+        $model.props.greater_than($middle, $upper);
+        $crate::constraint_macros::ConstraintRef::new(0)
+    }};
+
     // Handle simple variable comparisons: x < y, x <= y, etc.
     ($model:expr, $left:ident < $right:ident) => {{
         $model.props.less_than($left, $right);
@@ -2832,6 +2858,32 @@ mod tests {
         assert!(true);
     }
 
+    #[test]
+    fn test_chained_comparison_syntax() {
+        let mut m = Model::default();
+        let a = m.int(1, 10);
+        let b = m.int(1, 10);
+        let c = m.int(1, 10);
+        let x = m.int(1, 10);
+        let y = m.int(1, 10);
+        let z = m.int(1, 10);
+        
+        // Test chained <= (between constraint)
+        let _c1 = post!(m, a <= b <= c);
+        
+        // Test chained >= 
+        let _c2 = post!(m, x >= y >= z);
+        
+        // Test chained < (strict inequality)
+        let _c3 = post!(m, a < b < c);
+        
+        // Test chained > (strict inequality)
+        let _c4 = post!(m, x > y > z);
+        
+        // Should compile without errors
+        assert!(true);
+    }
+
     #[test]
     fn test_boolean_array_operations() {
         let mut m = Model::default();