big: Prettify `internal_cmp_digit`.

core/math/big/build.bat

@@ -1,10 +1,10 @@
 @echo off
-:odin run . -vet
+odin run . -vet
 : -o:size
 :odin build . -build-mode:shared -show-timings -o:minimal -no-bounds-check
 :odin build . -build-mode:shared -show-timings -o:size -no-bounds-check
 :odin build . -build-mode:shared -show-timings -o:size
-odin build . -build-mode:shared -show-timings -o:speed -no-bounds-check
+:odin build . -build-mode:shared -show-timings -o:speed -no-bounds-check
 :odin build . -build-mode:shared -show-timings -o:speed
 
-python test.py
+:python test.py

core/math/big/compare.odin

@@ -89,6 +89,7 @@ int_compare_digit :: proc(a: ^Int, b: DIGIT) -> (comparison: int, err: Error) {
 
 	return #force_inline internal_cmp_digit(a, b), nil;
 }
+int_cmp_digit :: int_compare_digit;
 
 /*
 	Compare the magnitude of two `Int`s, unsigned.

core/math/big/internal.odin

@@ -1046,40 +1046,34 @@ internal_compare :: proc { internal_int_compare, internal_int_compare_digit, };
 internal_cmp :: internal_compare;
 
 /*
-	Compare an `Int` to an unsigned number upto the size of the backing type.
+    Compare an `Int` to an unsigned number upto `DIGIT & _MASK`.
+    Returns -1 if `a` < `b`, 0 if `a` == `b` and 1 if `b` > `a`.
 
-	Returns -1 if `a` < `b`, 0 if `a` == `b` and 1 if `b` > `a`.
-
-	Expects `a` and `b` both to be valid `Int`s, i.e. initialized and not `nil`.
+    Expects: `a` and `b` both to be valid `Int`s, i.e. initialized and not `nil`.
 */
 internal_int_compare_digit :: #force_inline proc(a: ^Int, b: DIGIT) -> (comparison: int) {
+	a_is_negative := #force_inline internal_is_negative(a);
+
+	switch {
 	/*
-		Compare based on sign.
+		Compare based on sign first.
 	*/
-
-	if #force_inline internal_is_negative(a) { return -1; }
-
+	case a_is_negative:     return -1;
 	/*
-		Compare based on magnitude.
+		Then compare on magnitude.
 	*/
-	if a.used > 1 { return +1; }
-
+	case a.used > 1:        return +1;
 	/*
-		Compare the only digit in `a` to `b`.
+		We have only one digit. Compare it against `b`.
 	*/
-	switch {
-	case a.digit[0] < b:
-		return -1;
-	case a.digit[0] == b:
-		return  0;
-	case a.digit[0] > b:
-		return +1;
-	case:
+	case a.digit[0] < b:    return -1;
+	case a.digit[0] == b:   return  0;
+	case a.digit[0] > b:    return +1;
 		/*
 			Unreachable.
 			Just here because Odin complains about a missing return value at the bottom of the proc otherwise.
 		*/
-		return;
+	case:                   return;
 	}
 }
 internal_compare_digit :: proc { internal_int_compare_digit, };