fix: comparison operators in ZynML grammar and signed integer comparisons

- Fix comparison expressions in ml.zyn grammar to properly build Binary
  expressions instead of discarding the operator with `-> inner`
- Add comparison_with_op and comparison_no_op rules to handle `a < b` etc.
- Fix Cranelift backend to use operand type (not result type) for signed
  vs unsigned comparison selection
- Add SSA lowering to pass operand type for comparison instructions
- While loops and if statements now work correctly with comparisons

Also adds minimal test examples for stdlib features:
- test_01 through test_13 for println, arithmetic, control flow, etc.
- hello_basic.zynml as working tensor example without f-strings

Author: darmie

crates/compiler/src/cranelift_backend.rs

@@ -1343,7 +1343,7 @@ impl SsaBuilder {
     ) -> CompilerResult<HirId> {
         use zyntax_typed_ast::typed_ast::TypedExpression;
         use crate::hir::{BinaryOp, UnaryOp};
-        
+
         match &expr.node {
             TypedExpression::Variable(name) => {
                 // Check if this is an address-taken variable - need to load from stack
@@ -1484,12 +1484,24 @@ impl SsaBuilder {
                 let result_type = self.convert_type(&expr.ty);
 
                 let hir_op = self.convert_binary_op(op);
+
+                // For comparisons, use the operand type (not Bool result type) for the instruction
+                let inst_type = match hir_op {
+                    crate::hir::BinaryOp::Lt | crate::hir::BinaryOp::Le |
+                    crate::hir::BinaryOp::Gt | crate::hir::BinaryOp::Ge |
+                    crate::hir::BinaryOp::Eq | crate::hir::BinaryOp::Ne => {
+                        // Use the left operand type so cranelift can determine signed/unsigned
+                        self.convert_type(&left.ty)
+                    }
+                    _ => result_type.clone()
+                };
+
                 let result = self.create_value(result_type.clone(), HirValueKind::Instruction);
 
                 let inst = HirInstruction::Binary {
                     op: hir_op,
                     result,
-                    ty: result_type,
+                    ty: inst_type,
                     left: left_val,
                     right: right_val,
                 };

crates/compiler/src/ssa.rs

@@ -0,0 +1,40 @@
+// Basic hello.zynml - test core tensor operations
+import tensor
+
+def main() {
+    println("Hello from ZynML!")
+
+    // Create tensors using arange (which works)
+    let a = Tensor::arange(1.0, 5.0, 1.0)  // [1.0, 2.0, 3.0, 4.0]
+    let b = Tensor::arange(5.0, 9.0, 1.0)  // [5.0, 6.0, 7.0, 8.0]
+
+    println("Tensor a:")
+    println(a)
+
+    println("Tensor b:")
+    println(b)
+
+    // Arithmetic operations using operator overloading
+    let sum = a + b
+    println("a + b:")
+    println(sum)
+
+    let diff = b - a
+    println("b - a:")
+    println(diff)
+
+    let prod = a * b
+    println("a * b (element-wise):")
+    println(prod)
+
+    // Reduction operations
+    let total = a.sum()
+    println("Sum of a:")
+    println(total)
+
+    let avg = a.mean()
+    println("Mean of a:")
+    println(avg)
+
+    println("Done!")
+}

crates/zynml/examples/hello_basic.zynml

@@ -0,0 +1,6 @@
+// Test 01: Basic println with string
+import prelude
+
+def main() {
+    println("Hello World!")
+}

crates/zynml/examples/test_01_println_string.zynml

@@ -0,0 +1,8 @@
+// Test 02: Basic println with integers
+import prelude
+
+def main() {
+    println(42)
+    println(-10)
+    println(0)
+}

crates/zynml/examples/test_02_println_int.zynml

@@ -0,0 +1,8 @@
+// Test 03: Basic println with floats
+import prelude
+
+def main() {
+    println(3.14)
+    println(-2.5)
+    println(0.0)
+}

crates/zynml/examples/test_03_println_float.zynml

@@ -0,0 +1,12 @@
+// Test 04: Let bindings
+import prelude
+
+def main() {
+    let x = 42
+    let name = "Alice"
+    let pi = 3.14159
+
+    println(x)
+    println(name)
+    println(pi)
+}

crates/zynml/examples/test_04_let_binding.zynml

@@ -0,0 +1,11 @@
+// Test 05: Basic arithmetic
+import prelude
+
+def main() {
+    let a = 10
+    let b = 3
+
+    println(a + b)
+    println(a - b)
+    println(a * b)
+}

crates/zynml/examples/test_05_arithmetic.zynml

@@ -0,0 +1,16 @@
+// Test 06: Function definitions and calls
+import prelude
+
+def add(a: int, b: int): int {
+    a + b
+}
+
+def greet(name: str) {
+    println(name)
+}
+
+def main() {
+    let result = add(5, 7)
+    println(result)
+    greet("Hello from function!")
+}

crates/zynml/examples/test_06_function_call.zynml

@@ -0,0 +1,12 @@
+// Test 07: If-else control flow
+import prelude
+
+def main() {
+    let x = 10
+
+    if x > 5 {
+        println("x is greater than 5")
+    } else {
+        println("x is not greater than 5")
+    }
+}