review fixes

Author: stringhandler

examples/infix_operators.simf

@@ -36,13 +36,17 @@ fn main() {
     assert!(a == a);   // 20 == 20 is true
     assert!(a != b);   // 20 != 6 is true
 
-    // Less than / greater than
+    // Less than: u8 < u8 → bool
     assert!(b < a);   // 6 < 20
+
+    // Greater than: u8 > u8 → bool
     assert!(a > b);   // 20 > 6
 
-    // Less or equal / greater or equal
+    // Less or equal: u8 <= u8 → bool
     assert!(b <= a);  // 6 <= 20
     assert!(b <= b);  // 6 <= 6
+
+    // Greater or equal: u8 >= u8 → bool
     assert!(a >= b);  // 20 >= 6
     assert!(a >= a);  // 20 >= 20
 }

src/ast.rs

@@ -1077,7 +1077,8 @@ fn peek_single_expression_type(
 
 /// Maps a comparison infix operator and operand type to:
 /// - the Simplicity jet
-/// - whether arguments should be swapped (for `>` and `>=`)
+/// - whether arguments should be swapped (for `>` and `>=`) Note: there are no GreaterThan jets, so the
+///   args must be swapped.
 /// - whether the result should be negated (for `!=`)
 ///
 /// Returns `Err` if there is no jet for the given combination.
@@ -1422,7 +1423,7 @@ impl AbstractSyntaxTree for SingleExpression {
                             lhs_warnings,
                         )
                     }
-                    _ => {
+                    Add | Sub | Mul | Div | Rem => {
                         // Arithmetic operators
                         let (jet, arg_ty, assert_no_carry) =
                             determine_infix_arith_op_jet(binary.op(), ty).with_span(from)?;

src/compile/mod.rs

@@ -224,7 +224,7 @@ impl<'brand> Scope<'brand> {
 
 /// Returns the equality jet and a zero `simplicity::Value` for the operand type
 /// of a divide or modulo jet. Used to generate the divisor-zero check.
-fn divisor_check_jet_and_zero(jet: Elements) -> (Elements, simplicity::Value) {
+fn divisor_check_jet_and_zero_for_binary_op(jet: Elements) -> (Elements, simplicity::Value) {
     match jet {
         Elements::Divide8 | Elements::Modulo8 => (Elements::Eq8, simplicity::Value::u8(0)),
         Elements::Divide16 | Elements::Modulo16 => (Elements::Eq16, simplicity::Value::u16(0)),
@@ -390,7 +390,7 @@ impl SingleExpression {
                     //
                     // Step 1: check_rhs_eq_zero : (lhs, rhs) → (1+1)
                     //   = pair(drop(iden), unit_scribe(0)) >>> EqN
-                    let (eq_jet_elem, zero_sv) = divisor_check_jet_and_zero(*jet);
+                    let (eq_jet_elem, zero_sv) = divisor_check_jet_and_zero_for_binary_op(*jet);
                     // drop(iden) : (lhs, rhs) → rhs
                     let rhs_from_pair = ProgNode::drop_(&ProgNode::iden(scope.ctx()));
                     // unit_scribe(0) : (lhs, rhs) → 0