Replace `err != nil` with `or_return` where appropriate

core/math/big/helpers.odin

@@ -42,7 +42,7 @@ int_set_from_integer :: proc(dest: ^Int, src: $T, minimize := false, allocator :
 		Check that `src` is usable and `dest` isn't immutable.
 	*/
 	assert_if_nil(dest);
-	if err = #force_inline internal_error_if_immutable(dest); err != nil { return err; }
+	(#force_inline internal_error_if_immutable(dest)) or_return;
 
 	return #force_inline internal_int_set_from_integer(dest, src, minimize);
 }
@@ -64,8 +64,8 @@ int_copy :: proc(dest, src: ^Int, minimize := false, allocator := context.alloca
 	assert_if_nil(dest, src);
 	context.allocator = allocator;
 
-	if err = #force_inline internal_clear_if_uninitialized(src); err != nil { return err; }
-	if err = #force_inline internal_error_if_immutable(dest);    err != nil { return err; }
+	(#force_inline internal_clear_if_uninitialized(src)) or_return;
+	(#force_inline internal_error_if_immutable(dest))    or_return;
 
 	return #force_inline internal_int_copy(dest, src, minimize);
 }
@@ -92,8 +92,8 @@ int_abs :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error)
 	assert_if_nil(dest, src);
 	context.allocator = allocator;
 
-	if err = #force_inline internal_clear_if_uninitialized(src); err != nil { return err; }
-	if err = #force_inline internal_error_if_immutable(dest);    err != nil { return err; }
+	(#force_inline internal_clear_if_uninitialized(src)) or_return;
+	(#force_inline internal_error_if_immutable(dest))    or_return;
 
 	return #force_inline internal_int_abs(dest, src);
 }
@@ -113,8 +113,8 @@ int_neg :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error)
 	assert_if_nil(dest, src);
 	context.allocator = allocator;
 
-	if err = #force_inline internal_clear_if_uninitialized(src); err != nil { return err; }
-	if err = #force_inline internal_error_if_immutable(dest);    err != nil { return err; }
+	(#force_inline internal_clear_if_uninitialized(src)) or_return;
+	(#force_inline internal_error_if_immutable(dest))    or_return;
 
 	return #force_inline internal_int_neg(dest, src);
 }
@@ -134,8 +134,8 @@ int_bitfield_extract :: proc(a: ^Int, offset, count: int, allocator := context.a
 	assert_if_nil(a);
 	context.allocator = allocator;
 
-	if err = #force_inline internal_clear_if_uninitialized(a); err != nil { return {}, err; }
-	return #force_inline   internal_int_bitfield_extract(a, offset, count);
+	(#force_inline internal_clear_if_uninitialized(a)) or_return;
+	return #force_inline internal_int_bitfield_extract(a, offset, count);
 }
 
 /*
@@ -148,8 +148,8 @@ shrink :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) {
 	assert_if_nil(a);
 	context.allocator = allocator;
 
-	if err = #force_inline internal_clear_if_uninitialized(a); err != nil { return err; }
-	return #force_inline   internal_shrink(a);
+	(#force_inline internal_clear_if_uninitialized(a)) or_return;
+	return #force_inline internal_shrink(a);
 }
 
 int_grow :: proc(a: ^Int, digits: int, allow_shrink := false, allocator := context.allocator) -> (err: Error) {
@@ -305,8 +305,8 @@ int_get :: proc(a: ^Int, $T: typeid, allocator := context.allocator) -> (res: T,
 		Check that `a` is usable.
 	*/
 	assert_if_nil(a);
-	if err = #force_inline internal_clear_if_uninitialized(a, allocator); err != nil { return T{}, err; }
-	return #force_inline   internal_int_get(a, T);
+	(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
+	return #force_inline internal_int_get(a, T);
 }
 get :: proc { int_get, };
 
@@ -315,8 +315,8 @@ int_get_float :: proc(a: ^Int, allocator := context.allocator) -> (res: f64, err
 		Check that `a` is usable.
 	*/
 	assert_if_nil(a);
-	if err = #force_inline internal_clear_if_uninitialized(a, allocator); err != nil { return 0, err; }
-	return #force_inline   internal_int_get_float(a);
+	(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
+	return #force_inline internal_int_get_float(a);
 }
 
 /*
@@ -327,8 +327,8 @@ count_bits :: proc(a: ^Int, allocator := context.allocator) -> (count: int, err:
 		Check that `a` is usable.
 	*/
 	assert_if_nil(a);
-	if err = #force_inline internal_clear_if_uninitialized(a, allocator); err != nil { return 0, err; }
-	return #force_inline   internal_count_bits(a), nil;
+	(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
+	return #force_inline internal_count_bits(a), nil;
 }
 
 /*
@@ -340,8 +340,8 @@ int_count_lsb :: proc(a: ^Int, allocator := context.allocator) -> (count: int, e
 		Check that `a` is usable.
 	*/
 	assert_if_nil(a);
-	if err = #force_inline internal_clear_if_uninitialized(a, allocator); err != nil { return 0, err; }
-	return #force_inline   internal_int_count_lsb(a);
+	(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
+	return #force_inline internal_int_count_lsb(a);
 }
 
 platform_count_lsb :: #force_inline proc(a: $T) -> (count: int)
@@ -398,7 +398,7 @@ clear_if_uninitialized_multi :: proc(args: ..^Int, allocator := context.allocato
 	assert_if_nil(..args);
 
 	for i in &args {
-		if err = #force_inline internal_clear_if_uninitialized_single(i, allocator); err != nil { return nil; }
+		(#force_inline internal_clear_if_uninitialized_single(i, allocator)) or_return;
 	}
 	return err;
 }
@@ -425,7 +425,7 @@ int_init_multi :: proc(integers: ..^Int, allocator := context.allocator) -> (err
 
 	integers := integers;
 	for a in &integers {
-		if err = #force_inline internal_clear(a, true, allocator); err != nil { return err; }
+		(#force_inline internal_clear(a, true, allocator)) or_return;
 	}
 	return nil;
 }
@@ -440,7 +440,7 @@ copy_digits :: proc(dest, src: ^Int, digits: int, allocator := context.allocator
 		Check that `src` is usable and `dest` isn't immutable.
 	*/
 	assert_if_nil(dest, src);
-	if err = #force_inline internal_clear_if_uninitialized(src); err != nil { return err; }
+	(#force_inline internal_clear_if_uninitialized(src)) or_return;
 
 	digits = min(digits, len(src.digit), len(dest.digit));
 	return #force_inline internal_copy_digits(dest, src, digits);
@@ -454,7 +454,7 @@ copy_digits :: proc(dest, src: ^Int, digits: int, allocator := context.allocator
 */
 clamp :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) {
 	assert_if_nil(a);
-	if err = #force_inline internal_clear_if_uninitialized(a, allocator); err != nil { return err; }
+	(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
 
 	for a.used > 0 && a.digit[a.used - 1] == 0 {
 		a.used -= 1;
@@ -472,7 +472,7 @@ clamp :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) {
 */
 int_to_bytes_size :: proc(a: ^Int, signed := false, allocator := context.allocator) -> (size_in_bytes: int, err: Error) {
 	assert_if_nil(a);
-	if err = #force_inline internal_clear_if_uninitialized(a, allocator); err != nil { return {}, err; }
+	(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
 
 	size_in_bits := internal_count_bits(a);
 
@@ -488,9 +488,8 @@ int_to_bytes_size :: proc(a: ^Int, signed := false, allocator := context.allocat
 */
 int_to_bytes_little :: proc(a: ^Int, buf: []u8, signed := false, allocator := context.allocator) -> (err: Error) {
 	assert_if_nil(a);
-	size_in_bytes: int;
 
-	if size_in_bytes, err = int_to_bytes_size(a, signed, allocator); err != nil { return err; }
+	size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return;
 	l := len(buf);
 	if size_in_bytes > l { return .Buffer_Overflow; }
 
@@ -512,9 +511,8 @@ int_to_bytes_little :: proc(a: ^Int, buf: []u8, signed := false, allocator := co
 */
 int_to_bytes_big :: proc(a: ^Int, buf: []u8, signed := false, allocator := context.allocator) -> (err: Error) {
 	assert_if_nil(a);
-	size_in_bytes: int;
 
-	if size_in_bytes, err = int_to_bytes_size(a, signed, allocator); err != nil { return err; }
+	size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return;
 	l := len(buf);
 	if size_in_bytes > l { return .Buffer_Overflow; }
 
@@ -537,18 +535,17 @@ int_to_bytes_big :: proc(a: ^Int, buf: []u8, signed := false, allocator := conte
 */
 int_to_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, allocator := context.allocator) -> (err: Error) {
 	assert_if_nil(a);
-	size_in_bytes: int;
 
 	if !signed && a.sign == .Negative { return .Invalid_Argument; }
 
 	l := len(buf);
-	if size_in_bytes, err = int_to_bytes_size(a, signed, allocator); err != nil { return err; }
-	if size_in_bytes > l              { return .Buffer_Overflow;  }
+	size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return;
+	if size_in_bytes > l { return .Buffer_Overflow;  }
 
 	if a.sign == .Negative {
 		t := &Int{};
 		defer destroy(t);
-		if err = internal_complement(t, a, allocator); err != nil { return err; }
+		internal_complement(t, a, allocator) or_return;
 
 		size_in_bits := internal_count_bits(t);
 		i := 0;
@@ -574,19 +571,18 @@ int_to_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, allocato
 */
 int_to_bytes_big_python :: proc(a: ^Int, buf: []u8, signed := false, allocator := context.allocator) -> (err: Error) {
 	assert_if_nil(a);
-	size_in_bytes: int;
 
 	if !signed && a.sign == .Negative { return .Invalid_Argument; }
 	if a.sign == .Zero_or_Positive    { return int_to_bytes_big(a, buf, signed, allocator); }
 
 	l := len(buf);
-	if size_in_bytes, err = int_to_bytes_size(a, signed, allocator); err != nil { return err; }
-	if size_in_bytes > l              { return .Buffer_Overflow;  }
+	size_in_bytes := int_to_bytes_size(a, signed, allocator) or_return;
+	if size_in_bytes > l { return .Buffer_Overflow;  }
 
 	t := &Int{};
 	defer destroy(t);
 
-	if err = internal_complement(t, a, allocator); err != nil { return err; }
+	internal_complement(t, a, allocator) or_return;
 
 	size_in_bits := internal_count_bits(t);
 	i := l - 1;
@@ -619,8 +615,8 @@ int_from_bytes_big :: proc(a: ^Int, buf: []u8, signed := false, allocator := con
 	}
 	size_in_digits := (size_in_bits + _DIGIT_BITS - 1) / _DIGIT_BITS;
 	size_in_digits += 0 if size_in_bits % 8 == 0 else 1;
-	if err = internal_zero(a, false, allocator); err != nil { return err; }
-	if err = internal_grow(a, size_in_digits, false, allocator); err != nil { return err; }
+	internal_zero(a, false, allocator) or_return;
+	internal_grow(a, size_in_digits, false, allocator) or_return;
 
 	if signed {
 		sign = .Zero_or_Positive if buf[0] == 0 else .Negative;
@@ -628,7 +624,7 @@ int_from_bytes_big :: proc(a: ^Int, buf: []u8, signed := false, allocator := con
 	}
 
 	for v in buf {
-		if err = internal_shl(a, a, 8); err != nil { return err; }
+		internal_shl(a, a, 8) or_return;
 		a.digit[0] |= DIGIT(v);
 	}
 	a.sign = sign;
@@ -656,8 +652,8 @@ int_from_bytes_big_python :: proc(a: ^Int, buf: []u8, signed := false, allocator
 	}
 	size_in_digits := (size_in_bits + _DIGIT_BITS - 1) / _DIGIT_BITS;
 	size_in_digits += 0 if size_in_bits % 8 == 0 else 1;
-	if err = internal_zero(a, false, allocator); err != nil { return err; }
-	if err = internal_grow(a, size_in_digits, false, allocator); err != nil { return err; }
+	internal_zero(a, false, allocator) or_return;
+	internal_grow(a, size_in_digits, false, allocator) or_return;
 
 	if signed {
 		sign = .Zero_or_Positive if buf[0] == 0 else .Negative;
@@ -665,7 +661,7 @@ int_from_bytes_big_python :: proc(a: ^Int, buf: []u8, signed := false, allocator
 	}
 
 	for v in buf {
-		if err = internal_shl(a, a, 8); err != nil { return err; }
+		internal_shl(a, a, 8) or_return;
 		if signed && sign == .Negative {
 			a.digit[0] |= DIGIT(255 - v);	
 		} else {
@@ -674,7 +670,7 @@ int_from_bytes_big_python :: proc(a: ^Int, buf: []u8, signed := false, allocator
 	}
 	a.sign = sign;
 	a.used = size_in_digits;
-	if err = internal_clamp(a); err != nil { return err; }
+	internal_clamp(a) or_return;
 
 	if signed && sign == .Negative {
 		return internal_sub(a, a, 1);
@@ -702,8 +698,8 @@ int_from_bytes_little :: proc(a: ^Int, buf: []u8, signed := false, allocator :=
 	}
 	size_in_digits := (size_in_bits + _DIGIT_BITS - 1) / _DIGIT_BITS;
 	size_in_digits += 0 if size_in_bits % 8 == 0 else 1;
-	if err = internal_zero(a, false, allocator); err != nil { return err; }
-	if err = internal_grow(a, size_in_digits, false, allocator); err != nil { return err; }
+	internal_zero(a, false, allocator) or_return;
+	internal_grow(a, size_in_digits, false, allocator) or_return;
 
 	if signed {
 		sign = .Zero_or_Positive if buf[l-1] == 0 else .Negative;
@@ -712,7 +708,7 @@ int_from_bytes_little :: proc(a: ^Int, buf: []u8, signed := false, allocator :=
 	}
 
 	for _, i in buf {
-		if err = internal_shl(a, a, 8); err != nil { return err; }
+		internal_shl(a, a, 8) or_return;
 		a.digit[0] |= DIGIT(buf[l-i-1]);
 	}
 	a.sign = sign;
@@ -740,8 +736,8 @@ int_from_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, alloca
 	}
 	size_in_digits := (size_in_bits + _DIGIT_BITS - 1) / _DIGIT_BITS;
 	size_in_digits += 0 if size_in_bits % 8 == 0 else 1;
-	if err = internal_zero(a, false, allocator); err != nil { return err; }
-	if err = internal_grow(a, size_in_digits, false, allocator); err != nil { return err; }
+	internal_zero(a, false, allocator) or_return;
+	internal_grow(a, size_in_digits, false, allocator) or_return;
 
 	if signed {
 		sign = .Zero_or_Positive if buf[l-1] == 0 else .Negative;
@@ -750,7 +746,7 @@ int_from_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, alloca
 	}
 
 	for _, i in buf {
-		if err = internal_shl(a, a, 8); err != nil { return err; }
+		internal_shl(a, a, 8) or_return;
 		if signed && sign == .Negative {
 			a.digit[0] |= DIGIT(255 - buf[l-i-1]);
 		} else {
@@ -759,7 +755,7 @@ int_from_bytes_little_python :: proc(a: ^Int, buf: []u8, signed := false, alloca
 	}
 	a.sign = sign;
 	a.used = size_in_digits;
-	if err = internal_clamp(a); err != nil { return err; }
+	internal_clamp(a) or_return;
 
 	if signed && sign == .Negative {
 		return internal_sub(a, a, 1);

core/math/big/internal.odin

@@ -58,7 +58,7 @@ internal_int_add_unsigned :: proc(dest, a, b: ^Int, allocator := context.allocat
 	max_used = x.used;
 	old_used = dest.used;
 
-	if err = internal_grow(dest, max(max_used + 1, _DEFAULT_DIGIT_COUNT)); err != nil { return err; }
+	internal_grow(dest, max(max_used + 1, _DEFAULT_DIGIT_COUNT)) or_return;
 	dest.used = max_used + 1;
 	/*
 		All parameters have been initialized.
@@ -158,7 +158,7 @@ internal_add_signed :: proc { internal_int_add_signed, };
 internal_int_add_digit :: proc(dest, a: ^Int, digit: DIGIT, allocator := context.allocator) -> (err: Error) {
 	context.allocator = allocator;
 
-	if err = internal_grow(dest, a.used + 1); err != nil { return err; }
+	internal_grow(dest, a.used + 1) or_return;
 	/*
 		Fast paths for destination and input Int being the same.
 	*/
@@ -284,7 +284,7 @@ internal_int_sub_unsigned :: proc(dest, number, decrease: ^Int, allocator := con
 	max_used := x.used;
 	i: int;
 
-	if err = grow(dest, max(max_used, _DEFAULT_DIGIT_COUNT)); err != nil { return err; }
+	grow(dest, max(max_used, _DEFAULT_DIGIT_COUNT)) or_return;
 	dest.used = max_used;
 	/*
 		All parameters have been initialized.
@@ -389,7 +389,7 @@ internal_int_sub_signed :: proc(dest, number, decrease: ^Int, allocator := conte
 internal_int_sub_digit :: proc(dest, number: ^Int, digit: DIGIT, allocator := context.allocator) -> (err: Error) {
 	context.allocator = allocator;
 
-	if err = internal_grow(dest, number.used + 1); err != nil { return err; }
+	internal_grow(dest, number.used + 1) or_return;
 
 	dest := dest; digit := digit;
 	/*
@@ -520,12 +520,12 @@ internal_int_shr1 :: proc(dest, src: ^Int) -> (err: Error) {
 internal_int_shl1 :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error) {
 	context.allocator = allocator;
 
-	if err = internal_copy(dest, src); err != nil { return err; }
+	internal_copy(dest, src) or_return;
 	/*
 		Grow `dest` to accommodate the additional bits.
 	*/
 	digits_needed := dest.used + 1;
-	if err = internal_grow(dest, digits_needed); err != nil { return err; }
+	internal_grow(dest, digits_needed) or_return;
 	dest.used = digits_needed;
 
 	mask  := (DIGIT(1) << uint(1)) - DIGIT(1);
@@ -568,15 +568,14 @@ internal_int_mul_digit :: proc(dest, src: ^Int, multiplier: DIGIT, allocator :=
 		return #force_inline internal_int_shl1(dest, src);
 	}
 	if #force_inline platform_int_is_power_of_two(int(multiplier)) {
-		ix: int;
-		if ix, err = internal_log(multiplier, 2); err != nil { return err; }
+		ix := internal_log(multiplier, 2) or_return;
 		return internal_shl(dest, src, ix);
 	}
 
 	/*
 		Ensure `dest` is big enough to hold `src` * `multiplier`.
 	*/
-	if err = grow(dest, max(src.used + 1, _DEFAULT_DIGIT_COUNT)); err != nil { return err; }
+	grow(dest, max(src.used + 1, _DEFAULT_DIGIT_COUNT)) or_return;
 
 	/*
 		Save the original used count.
@@ -722,7 +721,7 @@ internal_int_divmod :: proc(quotient, remainder, numerator, denominator: ^Int, a
 	*/
 	if #force_inline internal_cmp_mag(numerator, denominator) == -1 {
 		if remainder != nil {
-			if err = internal_copy(remainder, numerator); err != nil { return err; }
+			internal_copy(remainder, numerator) or_return;
 		}
 		if quotient != nil {
 			internal_zero(quotient);
@@ -809,7 +808,7 @@ internal_int_divmod_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT,
 	*/
 	q := &Int{};
 
-	if err = internal_grow(q, numerator.used); err != nil { return 0, err; }
+	internal_grow(q, numerator.used) or_return;
 
 	q.used = numerator.used;
 	q.sign = numerator.sign;
@@ -853,7 +852,7 @@ internal_div :: proc { internal_int_div, };
 	Asssumes quotient, numerator and denominator to have been initialized and not to be nil.
 */
 internal_int_mod :: proc(remainder, numerator, denominator: ^Int, allocator := context.allocator) -> (err: Error) {
-	if err = #force_inline internal_int_divmod(nil, remainder, numerator, denominator, allocator); err != nil { return err; }
+	(#force_inline internal_int_divmod(nil, remainder, numerator, denominator, allocator)) or_return;
 
 	if remainder.used == 0 || denominator.sign == remainder.sign { return nil; }
 
@@ -865,7 +864,7 @@ internal_mod :: proc{ internal_int_mod, };
 	remainder = (number + addend) % modulus.
 */
 internal_int_addmod :: proc(remainder, number, addend, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
-	if err = #force_inline internal_add(remainder, number, addend, allocator); err != nil { return err; }
+	(#force_inline internal_add(remainder, number, addend, allocator)) or_return;
 	return #force_inline internal_mod(remainder, remainder, modulus, allocator);
 }
 internal_addmod :: proc { internal_int_addmod, };
@@ -874,7 +873,7 @@ internal_addmod :: proc { internal_int_addmod, };
 	remainder = (number - decrease) % modulus.
 */
 internal_int_submod :: proc(remainder, number, decrease, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
-	if err = #force_inline internal_sub(remainder, number, decrease, allocator); err != nil { return err; }
+	(#force_inline internal_sub(remainder, number, decrease, allocator)) or_return;
 	return #force_inline internal_mod(remainder, remainder, modulus, allocator);
 }
 internal_submod :: proc { internal_int_submod, };
@@ -883,7 +882,7 @@ internal_submod :: proc { internal_int_submod, };
 	remainder = (number * multiplicand) % modulus.
 */
 internal_int_mulmod :: proc(remainder, number, multiplicand, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
-	if err = #force_inline internal_mul(remainder, number, multiplicand, allocator); err != nil { return err; }
+	(#force_inline internal_mul(remainder, number, multiplicand, allocator)) or_return;
 	return #force_inline internal_mod(remainder, remainder, modulus, allocator);
 }
 internal_mulmod :: proc { internal_int_mulmod, };
@@ -892,7 +891,7 @@ internal_mulmod :: proc { internal_int_mulmod, };
 	remainder = (number * number) % modulus.
 */
 internal_int_sqrmod :: proc(remainder, number, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
-	if err = #force_inline internal_sqr(remainder, number, allocator); err != nil { return err; }
+	(#force_inline internal_sqr(remainder, number, allocator)) or_return;
 	return #force_inline internal_mod(remainder, remainder, modulus, allocator);
 }
 internal_sqrmod :: proc { internal_int_sqrmod, };
@@ -915,9 +914,11 @@ internal_int_factorial :: proc(res: ^Int, n: int, allocator := context.allocator
 		return #force_inline internal_set(res, _factorial_table[n]);
 	}
 
-	if err = #force_inline internal_set(res, _factorial_table[i - 1]); err != nil { return err; }
+	(#force_inline internal_set(res, _factorial_table[i - 1])) or_return;
 	for {
-		if err = #force_inline internal_mul(res, res, DIGIT(i)); err != nil || i == n { return err; }
+		if err = #force_inline internal_mul(res, res, DIGIT(i)); err != nil || i == n {
+			return err;
+		}
 		i += 1;
 	}
 
@@ -950,8 +951,8 @@ internal_int_mod_bits :: proc(remainder, numerator: ^Int, bits: int, allocator :
 	/*
 		If the modulus is larger than the value, return the value.
 	*/
-	err = internal_copy(remainder, numerator);
-	if bits >= (numerator.used * _DIGIT_BITS) || err != nil {
+	internal_copy(remainder, numerator) or_return;
+	if bits >= (numerator.used * _DIGIT_BITS) {
 		return;
 	}
 
@@ -1264,7 +1265,7 @@ internal_int_pow :: proc(dest, base: ^Int, power: int, allocator := context.allo
 			A zero base is a special case.
 		*/
 		if power  < 0 {
-			if err = internal_zero(dest); err != nil { return err; }
+			internal_zero(dest) or_return;
 			return .Math_Domain_Error;
 		}
 		if power == 0 { return  internal_one(dest); }
@@ -1293,37 +1294,34 @@ internal_int_pow :: proc(dest, base: ^Int, power: int, allocator := context.allo
 	}
 
 	g := &Int{};
-	if err = internal_copy(g, base); err != nil { return err; }
+	internal_copy(g, base) or_return;
 
 	/*
 		Set initial result.
 	*/
-	if err = internal_one(dest); err != nil { return err; }
+	internal_one(dest) or_return;
+
+	defer internal_destroy(g);
 
-	loop: for power > 0 {
+	for power > 0 {
 		/*
 			If the bit is set, multiply.
 		*/
 		if power & 1 != 0 {
-			if err = internal_mul(dest, g, dest); err != nil {
-				break loop;
-			}
+			internal_mul(dest, g, dest) or_return;
 		}
 		/*
 			Square.
 		*/
 		if power > 1 {
-			if err = #force_inline internal_sqr(g, g); err != nil {
-				break loop;
-			}
+			internal_sqr(g, g) or_return;
 		}
 
 		/* shift to next bit */
 		power >>= 1;
 	}
 
-	internal_destroy(g);
-	return err;
+	return;
 }
 
 /*
@@ -1336,7 +1334,7 @@ internal_int_pow_int :: proc(dest: ^Int, base, power: int, allocator := context.
 	base_t := &Int{};
 	defer internal_destroy(base_t);
 
-	if err = internal_set(base_t, base); err != nil { return err; }
+	internal_set(base_t, base) or_return;
 
 	return #force_inline internal_int_pow(dest, base_t, power);
 }
@@ -1387,15 +1385,15 @@ internal_int_sqrt :: proc(dest, src: ^Int, allocator := context.allocator) -> (e
 	count := #force_inline internal_count_bits(src);
 
 	a, b := count >> 1, count & 1;
-	if err = internal_int_power_of_two(x, a+b, allocator);   err != nil { return err; }
+	internal_int_power_of_two(x, a+b, allocator) or_return;
 
 	for {
 		/*
 			y = (x + n // x) // 2
 		*/
-		if err = internal_div(t1, src, x); err != nil { return err; }
-		if err = internal_add(t2, t1, x);  err != nil { return err; }
-		if err = internal_shr(y, t2, 1);   err != nil { return err; }
+		internal_div(t1, src, x) or_return;
+		internal_add(t2, t1, x)  or_return;
+		internal_shr(y, t2, 1)   or_return;
 
 		if c := internal_cmp(y, x); c == 0 || c == 1 {
 			internal_swap(dest, x);
@@ -1480,33 +1478,33 @@ internal_int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.alloca
 		Start value must be larger than root.
 	*/
 	ilog2 += 2;
-	if err = internal_int_power_of_two(t2, ilog2); err != nil { return err; }
+	internal_int_power_of_two(t2, ilog2) or_return;
 
 	c: int;
 	iterations := 0;
 	for {
 		/* t1 = t2 */
-		if err = internal_copy(t1, t2); err != nil { return err; }
+		internal_copy(t1, t2) or_return;
 
 		/* t2 = t1 - ((t1**b - a) / (b * t1**(b-1))) */
 
 		/* t3 = t1**(b-1) */
-		if err = internal_pow(t3, t1, n-1); err != nil { return err; }
+		internal_pow(t3, t1, n-1) or_return;
 
 		/* numerator */
 		/* t2 = t1**b */
-		if err = internal_mul(t2, t1, t3); err != nil { return err; }
+		internal_mul(t2, t1, t3) or_return;
 
 		/* t2 = t1**b - a */
-		if err = internal_sub(t2, t2, a); err != nil { return err; }
+		internal_sub(t2, t2, a) or_return;
 
 		/* denominator */
 		/* t3 = t1**(b-1) * b  */
-		if err = internal_mul(t3, t3, DIGIT(n)); err != nil { return err; }
+		internal_mul(t3, t3, DIGIT(n)) or_return;
 
 		/* t3 = (t1**b - a)/(b * t1**(b-1)) */
-		if err = internal_div(t3, t2, t3); err != nil { return err; }
-		if err = internal_sub(t2, t1, t3); err != nil { return err; }
+		internal_div(t3, t2, t3) or_return;
+		internal_sub(t2, t1, t3) or_return;
 
 		/*
 			 Number of rounds is at most log_2(root). If it is more it
@@ -1526,14 +1524,14 @@ internal_int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.alloca
 
 	iterations = 0;
 	for {
-		if err = internal_pow(t2, t1, n); err != nil { return err; }
+		internal_pow(t2, t1, n) or_return;
 
 		c = internal_cmp(t2, a);
 		if c == 0 {
 			swap(dest, t1);
 			return nil;
 		} else if c == -1 {
-			if err = internal_add(t1, t1, DIGIT(1)); err != nil { return err; }
+			internal_add(t1, t1, DIGIT(1)) or_return;
 		} else {
 			break;
 		}
@@ -1549,11 +1547,11 @@ internal_int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.alloca
 		Correct overshoot from above or from recurrence.
 		*/
 	for {
-		if err = internal_pow(t2, t1, n); err != nil { return err; }
+		internal_pow(t2, t1, n) or_return;
 	
 		if internal_cmp(t2, a) != 1 { break; }
 		
-		if err = internal_sub(t1, t1, DIGIT(1)); err != nil { return err; }
+		internal_sub(t1, t1, DIGIT(1)) or_return;
 
 		iterations += 1;
 		if iterations == MAX_ITERATIONS_ROOT_N {
@@ -1606,12 +1604,12 @@ internal_int_set_from_integer :: proc(dest: ^Int, src: $T, minimize := false, al
 
 	src := src;
 
-	if err = internal_error_if_immutable(dest); err != nil { return err; }
+	internal_error_if_immutable(dest) or_return;
 	/*
 		Most internal procs asssume an Int to have already been initialize,
 		but as this is one of the procs that initializes, we have to check the following.
 	*/
-	if err = internal_clear_if_uninitialized_single(dest); err != nil { return err; }
+	internal_clear_if_uninitialized_single(dest) or_return;
 
 	dest.flags = {}; // We're not -Inf, Inf, NaN or Immutable.
 
@@ -1631,7 +1629,7 @@ internal_int_set_from_integer :: proc(dest: ^Int, src: $T, minimize := false, al
 internal_set :: proc { internal_int_set_from_integer, internal_int_copy };
 
 internal_copy_digits :: #force_inline proc(dest, src: ^Int, digits: int) -> (err: Error) {
-	if err = #force_inline internal_error_if_immutable(dest); err != nil { return err; }
+	(#force_inline internal_error_if_immutable(dest)) or_return;
 
 	/*
 		If dest == src, do nothing
@@ -1653,7 +1651,7 @@ internal_int_copy :: proc(dest, src: ^Int, minimize := false, allocator := conte
 	*/
 	if (dest == src) { return nil; }
 
-	if err = internal_error_if_immutable(dest); err != nil { return err; }
+	internal_error_if_immutable(dest) or_return;
 
 	/*
 		Grow `dest` to fit `src`.
@@ -1661,7 +1659,7 @@ internal_int_copy :: proc(dest, src: ^Int, minimize := false, allocator := conte
 	*/
 	needed := src.used if minimize else max(src.used, _DEFAULT_DIGIT_COUNT);
 
-	if err = internal_grow(dest, needed, minimize); err != nil { return err; }
+	internal_grow(dest, needed, minimize) or_return;
 
 	/*
 		Copy everything over and zero high digits.
@@ -1708,9 +1706,7 @@ internal_int_abs :: proc(dest, src: ^Int, allocator := context.allocator) -> (er
 	/*
 		Copy `src` to `dest`
 	*/
-	if err = internal_copy(dest, src); err != nil {
-		return err;
-	}
+	internal_copy(dest, src) or_return;
 
 	/*
 		Fix sign.
@@ -1744,7 +1740,7 @@ internal_int_neg :: proc(dest, src: ^Int, allocator := context.allocator) -> (er
 	/*
 		Copy `src` to `dest`
 	*/
-	if err = internal_copy(dest, src); err != nil { return err; }
+	internal_copy(dest, src) or_return;
 
 	/*
 		Fix sign.
@@ -1953,7 +1949,7 @@ internal_int_power_of_two :: proc(a: ^Int, power: int, allocator := context.allo
 		Grow to accomodate the single bit.
 	*/
 	a.used = (power / _DIGIT_BITS) + 1;
-	if err = internal_grow(a, a.used); err != nil { return err; }
+	internal_grow(a, a.used) or_return;
 	/*
 		Zero the entirety.
 	*/
@@ -2061,7 +2057,7 @@ internal_int_and :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (e
 	/*
 		Grow the destination to accomodate the result.
 	*/
-	if err = internal_grow(dest, used); err != nil { return err; }
+	internal_grow(dest, used) or_return;
 
 	neg_a := #force_inline internal_is_negative(a);
 	neg_b := #force_inline internal_is_negative(b);
@@ -2122,7 +2118,7 @@ internal_int_or :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (er
 	/*
 		Grow the destination to accomodate the result.
 	*/
-	if err = internal_grow(dest, used); err != nil { return err; }
+	internal_grow(dest, used) or_return;
 
 	neg_a := #force_inline internal_is_negative(a);
 	neg_b := #force_inline internal_is_negative(b);
@@ -2183,7 +2179,7 @@ internal_int_xor :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (e
 	/*
 		Grow the destination to accomodate the result.
 	*/
-	if err = internal_grow(dest, used); err != nil { return err; }
+	internal_grow(dest, used) or_return;
 
 	neg_a := #force_inline internal_is_negative(a);
 	neg_b := #force_inline internal_is_negative(b);
@@ -2269,21 +2265,21 @@ internal_int_shrmod :: proc(quotient, remainder, numerator: ^Int, bits: int, all
 	bits := bits;
 	if bits < 0 { return .Invalid_Argument; }
 
-	if err = internal_copy(quotient, numerator); err != nil { return err; }
+	internal_copy(quotient, numerator) or_return;
 
 	/*
 		Shift right by a certain bit count (store quotient and optional remainder.)
 	   `numerator` should not be used after this.
 	*/
 	if remainder != nil {
-		if err = internal_int_mod_bits(remainder, numerator, bits); err != nil { return err; }
+		internal_int_mod_bits(remainder, numerator, bits) or_return;
 	}
 
 	/*
 		Shift by as many digits in the bit count.
 	*/
 	if bits >= _DIGIT_BITS {
-		if err = internal_shr_digit(quotient, bits / _DIGIT_BITS); err != nil { return err; }
+		internal_shr_digit(quotient, bits / _DIGIT_BITS) or_return;
 	}
 
 	/*
@@ -2362,9 +2358,8 @@ internal_int_shr_signed :: proc(dest, src: ^Int, bits: int, allocator := context
 	if src.sign == .Zero_or_Positive {
 		return internal_shr(dest, src, bits);
 	}
-	if err = internal_int_add_digit(dest, src, DIGIT(1)); err != nil { return err; }
-
-	if err = internal_shr(dest, dest, bits);              err != nil { return err; }
+	internal_int_add_digit(dest, src, DIGIT(1)) or_return;
+	internal_shr(dest, dest, bits) or_return;
 	return internal_sub(dest, src, DIGIT(1));
 }
 
@@ -2380,19 +2375,19 @@ internal_int_shl :: proc(dest, src: ^Int, bits: int, allocator := context.alloca
 
 	if bits < 0 { return .Invalid_Argument; }
 
-	if err = internal_copy(dest, src); err != nil { return err; }
+	internal_copy(dest, src) or_return;
 
 	/*
 		Grow `dest` to accommodate the additional bits.
 	*/
 	digits_needed := dest.used + (bits / _DIGIT_BITS) + 1;
-	if err = internal_grow(dest, digits_needed); err != nil { return err; }
+	internal_grow(dest, digits_needed) or_return;
 	dest.used = digits_needed;
 	/*
 		Shift by as many digits in the bit count as we have.
 	*/
 	if bits >= _DIGIT_BITS {
-		if err = internal_shl_digit(dest, bits / _DIGIT_BITS); err != nil { return err; }
+		internal_shl_digit(dest, bits / _DIGIT_BITS) or_return;
 	}
 
 	/*
@@ -2434,12 +2429,14 @@ internal_int_shl_digit :: proc(quotient: ^Int, digits: int, allocator := context
 	/*
 		No need to shift a zero.
 	*/
-	if #force_inline internal_is_zero(quotient) { return {}; }
+	if #force_inline internal_is_zero(quotient) {
+		return nil;
+	}
 
 	/*
 		Resize `quotient` to accomodate extra digits.
 	*/
-	if err = #force_inline internal_grow(quotient, quotient.used + digits); err != nil { return err; }
+	(#force_inline internal_grow(quotient, quotient.used + digits)) or_return;
 
 	/*
 		Increment the used by the shift amount then copy upwards.
@@ -2537,7 +2534,7 @@ internal_int_rand :: proc(dest: ^Int, bits: int, r: ^rnd.Rand = nil, allocator :
 		digits += 1;
 	}
 
-	if err = #force_inline internal_grow(dest, digits); err != nil { return err; }
+	(#force_inline internal_grow(dest, digits)) or_return;
 
 	for i := 0; i < digits; i += 1 {
 		dest.digit[i] = int_random_digit(r) & _MASK;
@@ -2600,7 +2597,7 @@ internal_int_init_multi :: proc(integers: ..^Int, allocator := context.allocator
 
 	integers := integers;
 	for a in &integers {
-		if err = internal_clear(a); err != nil { return err; }
+		internal_clear(a) or_return;
 	}
 	return nil;
 }

core/math/big/logical.odin

@@ -25,7 +25,7 @@ int_and :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error
 	assert_if_nil(dest, a, b);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a, b); err != nil { return err; }
+	internal_clear_if_uninitialized(a, b) or_return;
 	return #force_inline internal_int_and(dest, a, b);
 }
 and :: proc { int_and, };
@@ -37,7 +37,7 @@ int_or :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error)
 	assert_if_nil(dest, a, b);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a, b); err != nil { return err; }
+	internal_clear_if_uninitialized(a, b) or_return;
 	return #force_inline internal_int_or(dest, a, b);
 }
 or :: proc { int_or, };
@@ -49,7 +49,7 @@ int_xor :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error
 	assert_if_nil(dest, a, b);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a, b); err != nil { return err; }
+	internal_clear_if_uninitialized(a, b) or_return;
 	return #force_inline internal_int_xor(dest, a, b);
 }
 xor :: proc { int_xor, };
@@ -64,7 +64,7 @@ int_complement :: proc(dest, src: ^Int, allocator := context.allocator) -> (err:
 	assert_if_nil(dest, src);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
+	internal_clear_if_uninitialized(dest, src) or_return;
 	return #force_inline internal_int_complement(dest, src);
 }
 complement :: proc { int_complement, };
@@ -97,7 +97,7 @@ int_shr_digit :: proc(quotient: ^Int, digits: int, allocator := context.allocato
 	assert_if_nil(quotient);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(quotient); err != nil { return err; }
+	internal_clear_if_uninitialized(quotient) or_return;
 	return #force_inline internal_int_shr_digit(quotient, digits);
 }
 shr_digit :: proc { int_shr_digit, };
@@ -109,7 +109,7 @@ int_shr_signed :: proc(dest, src: ^Int, bits: int, allocator := context.allocato
 	assert_if_nil(dest, src);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
+	internal_clear_if_uninitialized(dest, src) or_return;
 	return #force_inline internal_int_shr_signed(dest, src, bits);
 }
 
@@ -122,7 +122,7 @@ int_shl :: proc(dest, src: ^Int, bits: int, allocator := context.allocator) -> (
 	assert_if_nil(dest, src);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
+	internal_clear_if_uninitialized(dest, src) or_return;
 	return #force_inline internal_int_shl(dest, src, bits);
 }
 shl :: proc { int_shl, };
@@ -138,7 +138,7 @@ int_shl_digit :: proc(quotient: ^Int, digits: int, allocator := context.allocato
 	assert_if_nil(quotient);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(quotient); err != nil { return err; }
+	internal_clear_if_uninitialized(quotient) or_return;
 	return #force_inline internal_int_shl_digit(quotient, digits);
 }
 shl_digit :: proc { int_shl_digit, };

core/math/big/prime.odin

@@ -19,12 +19,13 @@ int_prime_is_divisible :: proc(a: ^Int, allocator := context.allocator) -> (res:
 	assert_if_nil(a);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a); err != nil { return {}, err; }
+	internal_clear_if_uninitialized(a) or_return;
 
-	rem: DIGIT;
 	for prime in _private_prime_table {
-		if rem, err = #force_inline int_mod_digit(a, prime); err != nil { return false, err; }
-		if rem == 0 { return true, nil; }
+		rem := (#force_inline int_mod_digit(a, prime)) or_return;
+		if rem == 0 {
+			return true, nil;
+		}
 	}
 	/*
 		Default to not divisible.

core/math/big/public.odin

@@ -24,7 +24,7 @@ int_add :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error
 	assert_if_nil(dest, a, b);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(dest, a, b); err != nil { return err; }
+	internal_clear_if_uninitialized(dest, a, b) or_return;
 	/*
 		All parameters have been initialized.
 	*/
@@ -41,11 +41,11 @@ int_add_digit :: proc(dest, a: ^Int, digit: DIGIT, allocator := context.allocato
 	assert_if_nil(dest, a);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a); err != nil { return err; }
+	internal_clear_if_uninitialized(a) or_return;
 	/*
 		Grow destination as required.
 	*/
-	if err = grow(dest, a.used + 1); err != nil { return err; }
+	grow(dest, a.used + 1) or_return;
 
 	/*
 		All parameters have been initialized.
@@ -60,7 +60,7 @@ int_sub :: proc(dest, number, decrease: ^Int, allocator := context.allocator) ->
 	assert_if_nil(dest, number, decrease);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(dest, number, decrease); err != nil { return err; }
+	internal_clear_if_uninitialized(dest, number, decrease) or_return;
 	/*
 		All parameters have been initialized.
 	*/
@@ -77,11 +77,11 @@ int_sub_digit :: proc(dest, a: ^Int, digit: DIGIT, allocator := context.allocato
 	assert_if_nil(dest, a);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a); err != nil { return err; }
+	internal_clear_if_uninitialized(a) or_return;
 	/*
 		Grow destination as required.
 	*/
-	if err = grow(dest, a.used + 1); err != nil { return err; }
+	grow(dest, a.used + 1) or_return;
 
 	/*
 		All parameters have been initialized.
@@ -97,11 +97,11 @@ int_halve :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Erro
 	assert_if_nil(dest, src);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
+	internal_clear_if_uninitialized(dest, src) or_return;
 	/*
 		Grow destination as required.
 	*/
-	if dest != src { if err = grow(dest, src.used + 1); err != nil { return err; } }
+	if dest != src { grow(dest, src.used + 1) or_return }
 
 	return #force_inline internal_int_shr1(dest, src);
 }
@@ -116,11 +116,11 @@ int_double :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Err
 	assert_if_nil(dest, src);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
+	internal_clear_if_uninitialized(dest, src) or_return;
 	/*
 		Grow destination as required.
 	*/
-	if dest != src { if err = grow(dest, src.used + 1); err != nil { return err; } }
+	if dest != src { grow(dest, src.used + 1) or_return; }
 
 	return #force_inline internal_int_shl1(dest, src);
 }
@@ -134,7 +134,7 @@ int_mul_digit :: proc(dest, src: ^Int, multiplier: DIGIT, allocator := context.a
 	assert_if_nil(dest, src);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(src, dest); err != nil { return err; }
+	internal_clear_if_uninitialized(src, dest) or_return;
 
 	return #force_inline internal_int_mul_digit(dest, src, multiplier);
 }
@@ -146,7 +146,7 @@ int_mul :: proc(dest, src, multiplier: ^Int, allocator := context.allocator) ->
 	assert_if_nil(dest, src, multiplier);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(dest, src, multiplier); err != nil { return err; }
+	internal_clear_if_uninitialized(dest, src, multiplier) or_return;
 
 	return #force_inline internal_int_mul(dest, src, multiplier);
 }
@@ -166,7 +166,7 @@ int_divmod :: proc(quotient, remainder, numerator, denominator: ^Int, allocator
 		Early out if neither of the results is wanted.
 	*/
 	if quotient == nil && remainder == nil { return nil; }
-	if err = internal_clear_if_uninitialized(numerator, denominator); err != nil { return err; }
+	internal_clear_if_uninitialized(numerator, denominator) or_return;
 
 	return #force_inline internal_divmod(quotient, remainder, numerator, denominator);
 }
@@ -175,7 +175,7 @@ int_divmod_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT, allocato
 	assert_if_nil(quotient, numerator);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(numerator); err != nil { return 0, err; }
+	internal_clear_if_uninitialized(numerator) or_return;
 
 	return #force_inline internal_divmod(quotient, numerator, denominator);
 }
@@ -185,7 +185,7 @@ int_div :: proc(quotient, numerator, denominator: ^Int, allocator := context.all
 	assert_if_nil(quotient, numerator, denominator);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(numerator, denominator); err != nil { return err; }
+	internal_clear_if_uninitialized(numerator, denominator) or_return;
 
 	return #force_inline internal_divmod(quotient, nil, numerator, denominator);
 }
@@ -194,11 +194,10 @@ int_div_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT, allocator :
 	assert_if_nil(quotient, numerator);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(numerator); err != nil { return err; }
+	internal_clear_if_uninitialized(numerator) or_return;
 
-	remainder: DIGIT;
-	remainder, err = #force_inline internal_divmod(quotient, numerator, denominator);
-	return err;
+	_ = (#force_inline internal_divmod(quotient, numerator, denominator)) or_return;
+	return;
 }
 div :: proc { int_div, int_div_digit, };
 
@@ -211,7 +210,7 @@ int_mod :: proc(remainder, numerator, denominator: ^Int, allocator := context.al
 	assert_if_nil(remainder, numerator, denominator);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(numerator, denominator); err != nil { return err; }
+	internal_clear_if_uninitialized(numerator, denominator) or_return;
 
 	return #force_inline internal_int_mod(remainder, numerator, denominator);
 }
@@ -229,7 +228,7 @@ int_addmod :: proc(remainder, number, addend, modulus: ^Int, allocator := contex
 	assert_if_nil(remainder, number, addend);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(number, addend, modulus); err != nil { return err; }
+	internal_clear_if_uninitialized(number, addend, modulus) or_return;
 
 	return #force_inline internal_addmod(remainder, number, addend, modulus);
 }
@@ -242,7 +241,7 @@ int_submod :: proc(remainder, number, decrease, modulus: ^Int, allocator := cont
 	assert_if_nil(remainder, number, decrease);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(number, decrease, modulus); err != nil { return err; }
+	internal_clear_if_uninitialized(number, decrease, modulus) or_return;
 
 	return #force_inline internal_submod(remainder, number, decrease, modulus);
 }
@@ -255,7 +254,7 @@ int_mulmod :: proc(remainder, number, multiplicand, modulus: ^Int, allocator :=
 	assert_if_nil(remainder, number, multiplicand);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(number, multiplicand, modulus); err != nil { return err; }
+	internal_clear_if_uninitialized(number, multiplicand, modulus) or_return;
 
 	return #force_inline internal_mulmod(remainder, number, multiplicand, modulus);
 }
@@ -268,7 +267,7 @@ int_sqrmod :: proc(remainder, number, modulus: ^Int, allocator := context.alloca
 	assert_if_nil(remainder, number, modulus);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(number, modulus); err != nil { return err; }
+	internal_clear_if_uninitialized(number, modulus) or_return;
 
 	return #force_inline internal_sqrmod(remainder, number, modulus);
 }
@@ -312,14 +311,14 @@ int_choose_digit :: proc(res: ^Int, n, k: int, allocator := context.allocator) -
 	n_fac, k_fac, n_minus_k_fac := &Int{}, &Int{}, &Int{};
 	defer internal_destroy(n_fac, k_fac, n_minus_k_fac);
 
-	if err = #force_inline internal_int_factorial(n_minus_k_fac, n - k);  err != nil { return err; }
-	if err = #force_inline internal_int_factorial(k_fac, k);              err != nil { return err; }
-	if err = #force_inline internal_mul(k_fac, k_fac, n_minus_k_fac);     err != nil { return err; }
+	(#force_inline internal_int_factorial(n_minus_k_fac, n - k)) or_return;
+	(#force_inline internal_int_factorial(k_fac, k))             or_return;
+	(#force_inline internal_mul(k_fac, k_fac, n_minus_k_fac))    or_return;
 
-	if err = #force_inline internal_int_factorial(n_fac, n);              err != nil { return err; }
-	if err = #force_inline internal_div(res, n_fac, k_fac);               err != nil { return err; }
+	(#force_inline internal_int_factorial(n_fac, n))             or_return;
+	(#force_inline internal_div(res, n_fac, k_fac))              or_return;
 
-	return err;	
+	return;
 }
 choose :: proc { int_choose_digit, };
 
@@ -331,7 +330,7 @@ int_gcd_lcm :: proc(res_gcd, res_lcm, a, b: ^Int, allocator := context.allocator
 	assert_if_nil(a, b);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a, b); err != nil { return err; }
+	internal_clear_if_uninitialized(a, b) or_return;
 	return #force_inline internal_int_gcd_lcm(res_gcd, res_lcm, a, b);
 }
 gcd_lcm :: proc { int_gcd_lcm, };
@@ -359,8 +358,8 @@ int_mod_bits :: proc(remainder, numerator: ^Int, bits: int, allocator := context
 	assert_if_nil(remainder, numerator);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(remainder, numerator); err != nil { return err; }
-	if bits  < 0 { return .Invalid_Argument; }
+	internal_clear_if_uninitialized(remainder, numerator) or_return;
+	if bits < 0 { return .Invalid_Argument; }
 
 	return #force_inline internal_int_mod_bits(remainder, numerator, bits);
 }
@@ -375,7 +374,7 @@ int_log :: proc(a: ^Int, base: DIGIT, allocator := context.allocator) -> (res: i
 	assert_if_nil(a);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a); err != nil { return 0, err; }
+	internal_clear_if_uninitialized(a) or_return;
 
 	return #force_inline internal_int_log(a, base);
 }
@@ -392,7 +391,7 @@ int_pow :: proc(dest, base: ^Int, power: int, allocator := context.allocator) ->
 	assert_if_nil(dest, base);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(dest, base); err != nil { return err; }
+	internal_clear_if_uninitialized(dest, base) or_return;
 
 	return #force_inline internal_int_pow(dest, base, power);
 }
@@ -420,7 +419,7 @@ int_sqrt :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error
 	assert_if_nil(dest, src);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(dest, src);	err != nil { return err; }
+	internal_clear_if_uninitialized(dest, src) or_return;
 
 	return #force_inline internal_int_sqrt(dest, src);
 }
@@ -446,7 +445,7 @@ int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.allocator) -> (
 	/*
 		Initialize dest + src if needed.
 	*/
-	if err = internal_clear_if_uninitialized(dest, src);	err != nil { return err; }
+	internal_clear_if_uninitialized(dest, src) or_return;
 
 	return #force_inline internal_int_root_n(dest, src, n);
 }
@@ -466,7 +465,7 @@ int_is_zero :: proc(a: ^Int, allocator := context.allocator) -> (zero: bool, err
 	assert_if_nil(a);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
+	internal_clear_if_uninitialized(a) or_return;
 
 	return #force_inline internal_is_zero(a), nil;
 }
@@ -475,7 +474,7 @@ int_is_positive :: proc(a: ^Int, allocator := context.allocator) -> (positive: b
 	assert_if_nil(a);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
+	internal_clear_if_uninitialized(a) or_return;
 
 	return #force_inline internal_is_positive(a), nil;
 }
@@ -484,7 +483,7 @@ int_is_negative :: proc(a: ^Int, allocator := context.allocator) -> (negative: b
 	assert_if_nil(a);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
+	internal_clear_if_uninitialized(a) or_return;
 
 	return #force_inline internal_is_negative(a), nil;
 }
@@ -493,7 +492,7 @@ int_is_even :: proc(a: ^Int, allocator := context.allocator) -> (even: bool, err
 	assert_if_nil(a);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
+	internal_clear_if_uninitialized(a) or_return;
 
 	return #force_inline internal_is_even(a), nil;
 }
@@ -502,7 +501,7 @@ int_is_odd :: proc(a: ^Int, allocator := context.allocator) -> (odd: bool, err:
 	assert_if_nil(a);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
+	internal_clear_if_uninitialized(a) or_return;
 
 	return #force_inline internal_is_odd(a), nil;
 }
@@ -515,7 +514,7 @@ int_is_power_of_two :: proc(a: ^Int, allocator := context.allocator) -> (res: bo
 	assert_if_nil(a);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
+	internal_clear_if_uninitialized(a) or_return;
 
 	return #force_inline internal_is_power_of_two(a), nil;
 }
@@ -527,7 +526,7 @@ int_compare :: proc(a, b: ^Int, allocator := context.allocator) -> (comparison:
 	assert_if_nil(a, b);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a, b); err != nil {	return 0, err; }
+	internal_clear_if_uninitialized(a, b) or_return;
 
 	return #force_inline internal_cmp(a, b), nil;
 }
@@ -540,7 +539,7 @@ int_compare_digit :: proc(a: ^Int, b: DIGIT, allocator := context.allocator) ->
 	assert_if_nil(a);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a); err != nil { return 0, err; }
+	internal_clear_if_uninitialized(a) or_return;
 
 	return #force_inline internal_cmp_digit(a, b), nil;
 }
@@ -553,7 +552,7 @@ int_compare_magnitude :: proc(a, b: ^Int, allocator := context.allocator) -> (re
 	assert_if_nil(a, b);
 	context.allocator = allocator;
 
-	if err = internal_clear_if_uninitialized(a, b); err != nil { return 0, err; }
+	internal_clear_if_uninitialized(a, b) or_return;
 
 	return #force_inline internal_cmp_mag(a, b), nil;
 }

core/math/big/radix.odin

@@ -26,7 +26,7 @@ int_itoa_string :: proc(a: ^Int, radix := i8(-1), zero_terminate := false, alloc
 	context.allocator = allocator;
 
 	a := a; radix := radix;
-	if err = clear_if_uninitialized(a); err != nil { return "", err; }
+	clear_if_uninitialized(a) or_return;
 	/*
 		Radix defaults to 10.
 	*/
@@ -39,14 +39,9 @@ int_itoa_string :: proc(a: ^Int, radix := i8(-1), zero_terminate := false, alloc
 
 	/*
 		Calculate the size of the buffer we need, and 
-	*/
-	size: int;
-	/*
 		Exit if calculating the size returned an error.
 	*/
-	if size, err = radix_size(a, radix, zero_terminate); err != nil {
-		return "", err;
-	}
+	size := radix_size(a, radix, zero_terminate) or_return;
 
 	/*
 		Allocate the buffer we need.
@@ -70,7 +65,7 @@ int_itoa_cstring :: proc(a: ^Int, radix := i8(-1), allocator := context.allocato
 	context.allocator = allocator;
 
 	a := a; radix := radix;
-	if err = clear_if_uninitialized(a); err != nil { return "", err; }
+	clear_if_uninitialized(a) or_return;
 	/*
 		Radix defaults to 10.
 	*/
@@ -104,7 +99,7 @@ int_itoa_cstring :: proc(a: ^Int, radix := i8(-1), allocator := context.allocato
 int_itoa_raw :: proc(a: ^Int, radix: i8, buffer: []u8, size := int(-1), zero_terminate := false) -> (written: int, err: Error) {
 	assert_if_nil(a);
 	a := a; radix := radix; size := size;
-	if err = clear_if_uninitialized(a); err != nil { return 0, err; }
+	clear_if_uninitialized(a) or_return;
 	/*
 		Radix defaults to 10.
 	*/
@@ -117,9 +112,7 @@ int_itoa_raw :: proc(a: ^Int, radix: i8, buffer: []u8, size := int(-1), zero_ter
 		We weren't given a size. Let's compute it.
 	*/
 	if size == -1 {
-		if size, err = radix_size(a, radix, zero_terminate); err != nil {
-			return 0, err;
-		}
+		size = radix_size(a, radix, zero_terminate) or_return;
 	}
 
 	/*
@@ -256,12 +249,14 @@ int_atoi :: proc(res: ^Int, input: string, radix: i8, allocator := context.alloc
 	/*
 		Set the integer to the default of zero.
 	*/
-	if err = internal_zero(res); err != nil { return err; }
+	internal_zero(res) or_return;
 
 	/*
 		We'll interpret an empty string as zero.
 	*/
-	if len(input) == 0 { return nil; }
+	if len(input) == 0 {
+		return nil;
+	}
 
 	/*
 		If the leading digit is a minus set the sign to negative.
@@ -301,8 +296,8 @@ int_atoi :: proc(res: ^Int, input: string, radix: i8, allocator := context.alloc
 			break;
 		}
 
-		if err = internal_mul(res, res, DIGIT(radix)); err != nil { return err; }
-		if err = internal_add(res, res, DIGIT(y));     err != nil { return err; }
+		internal_mul(res, res, DIGIT(radix)) or_return;
+		internal_add(res, res, DIGIT(y))     or_return;
 
 		input = input[1:];
 	}
@@ -333,7 +328,7 @@ radix_size :: proc(a: ^Int, radix: i8, zero_terminate := false, allocator := con
 	assert_if_nil(a);
 
 	if radix < 2 || radix > 64                     { return -1, .Invalid_Argument; }
-	if err = clear_if_uninitialized(a); err != nil { return {}, err; }
+	clear_if_uninitialized(a) or_return;
 
 	if internal_is_zero(a) {
 		if zero_terminate {
@@ -352,22 +347,22 @@ radix_size :: proc(a: ^Int, radix: i8, zero_terminate := false, allocator := con
 			digit     = a.digit,
 		};
 
-		if size, err = internal_log(t, DIGIT(radix));   err != nil { return {}, err; }
+		size = internal_log(t, DIGIT(radix)) or_return;
 	} else {
 		la, k := &Int{}, &Int{};
 		defer internal_destroy(la, k);
 
 		/* la = floor(log_2(a)) + 1 */
 		bit_count := internal_count_bits(a);
-		if err = internal_set(la, bit_count);           err != nil { return {}, err; }
+		internal_set(la, bit_count) or_return;
 
 		/* k = floor(2^29/log_2(radix)) + 1 */
 		lb := _log_bases;
-		if err = internal_set(k, lb[radix]);            err != nil { return {}, err; }
+		internal_set(k, lb[radix]) or_return;
 
 		/* n = floor((la *  k) / 2^29) + 1 */
-		if err = internal_mul(k, la, k);                err != nil { return 0, err; }
-		if err = internal_shr(k, k, _RADIX_SIZE_SCALE); err != nil { return {}, err; }
+		internal_mul(k, la, k) or_return;
+		internal_shr(k, k, _RADIX_SIZE_SCALE) or_return;
 
 		/* The "+1" here is the "+1" in "floor((la *  k) / 2^29) + 1" */
 		/* n = n + 1 + EOS + sign */
@@ -440,8 +435,8 @@ _itoa_raw_full :: proc(a: ^Int, radix: i8, buffer: []u8, zero_terminate := false
 
 	temp, denominator := &Int{}, &Int{};
 
-	if err = internal_copy(temp, a);           err != nil { return 0, err; }
-	if err = internal_set(denominator, radix); err != nil { return 0, err; }
+	internal_copy(temp, a)           or_return;
+	internal_set(denominator, radix) or_return;
 
 	available := len(buffer);
 	if zero_terminate {

core/math/big/test.odin

@@ -49,7 +49,7 @@ PyRes :: struct {
 	if bb.used == 1 {
 		if err = #force_inline internal_add(sum, aa, bb.digit[0]); err != nil { return PyRes{res=":add:add(sum,a,b):", err=err}; }	
 	} else {
-		if err = #force_inline internal_add(sum, aa, bb);          err != nil { return PyRes{res=":add:add(sum,a,b):", err=err}; }
+		if err = #force_inline internal_add(sum, aa, bb); err != nil { return PyRes{res=":add:add(sum,a,b):", err=err}; }
 	}
 
 	r: cstring;
@@ -70,7 +70,7 @@ PyRes :: struct {
 	if bb.used == 1 {
 		if err = #force_inline internal_sub(sum, aa, bb.digit[0]); err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err}; }
 	} else {
-		if err = #force_inline internal_sub(sum, aa, bb);          err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err}; }
+		if err = #force_inline internal_sub(sum, aa, bb); err != nil { return PyRes{res=":sub:sub(sum,a,b):", err=err}; }
 	}
 
 	r: cstring;
@@ -88,7 +88,7 @@ PyRes :: struct {
 
 	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":mul:atoi(a):", err=err}; }
 	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":mul:atoi(b):", err=err}; }
-	if err = #force_inline internal_mul(product, aa, bb);    err != nil { return PyRes{res=":mul:mul(product,a,b):", err=err}; }
+	if err = #force_inline internal_mul(product, aa, bb); err != nil { return PyRes{res=":mul:mul(product,a,b):", err=err}; }
 
 	r: cstring;
 	r, err = int_itoa_cstring(product, 16, context.temp_allocator);
@@ -104,7 +104,7 @@ PyRes :: struct {
 	defer internal_destroy(aa, square);
 
 	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":sqr:atoi(a):", err=err}; }
-	if err = #force_inline internal_sqr(square, aa);        err != nil { return PyRes{res=":sqr:sqr(square,a):", err=err}; }
+	if err = #force_inline internal_sqr(square, aa); err != nil { return PyRes{res=":sqr:sqr(square,a):", err=err}; }
 
 	r: cstring;
 	r, err = int_itoa_cstring(square, 16, context.temp_allocator);
@@ -124,7 +124,7 @@ PyRes :: struct {
 
 	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":div:atoi(a):", err=err}; }
 	if err = atoi(bb, string(b), 16); err != nil { return PyRes{res=":div:atoi(b):", err=err}; }
-	if err = #force_inline internal_div(quotient, aa, bb);   err != nil { return PyRes{res=":div:div(quotient,a,b):", err=err}; }
+	if err = #force_inline internal_div(quotient, aa, bb); err != nil { return PyRes{res=":div:div(quotient,a,b):", err=err}; }
 
 	r: cstring;
 	r, err = int_itoa_cstring(quotient, 16, context.temp_allocator);
@@ -145,7 +145,7 @@ PyRes :: struct {
 	defer internal_destroy(aa);
 
 	if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":log:atoi(a):", err=err}; }
-	if l, err = #force_inline internal_log(aa, base);        err != nil { return PyRes{res=":log:log(a, base):", err=err}; }
+	if l, err = #force_inline internal_log(aa, base); err != nil { return PyRes{res=":log:log(a, base):", err=err}; }
 
 	#force_inline internal_zero(aa);
 	aa.digit[0] = DIGIT(l)  & _MASK;
@@ -170,7 +170,7 @@ PyRes :: struct {
 	defer internal_destroy(dest, bb);
 
 	if err = atoi(bb, string(base), 16); err != nil { return PyRes{res=":pow:atoi(base):", err=err}; }
-	if err = #force_inline internal_pow(dest, bb, power);       err != nil { return PyRes{res=":pow:pow(dest, base, power):", err=err}; }
+	if err = #force_inline internal_pow(dest, bb, power); err != nil { return PyRes{res=":pow:pow(dest, base, power):", err=err}; }
 
 	r: cstring;
 	r, err = int_itoa_cstring(dest, 16, context.temp_allocator);
@@ -189,7 +189,7 @@ PyRes :: struct {
 	defer internal_destroy(src);
 
 	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":sqrt:atoi(src):", err=err}; }
-	if err = #force_inline internal_sqrt(src, src);                err != nil { return PyRes{res=":sqrt:sqrt(src):", err=err}; }
+	if err = #force_inline internal_sqrt(src, src); err != nil { return PyRes{res=":sqrt:sqrt(src):", err=err}; }
 
 	r: cstring;
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator);
@@ -208,7 +208,7 @@ PyRes :: struct {
 	defer internal_destroy(src);
 
 	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":root_n:atoi(src):", err=err}; }
-	if err = #force_inline internal_root_n(src, src, power);       err != nil { return PyRes{res=":root_n:root_n(src):", err=err}; }
+	if err = #force_inline internal_root_n(src, src, power); err != nil { return PyRes{res=":root_n:root_n(src):", err=err}; }
 
 	r: cstring;
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator);
@@ -227,7 +227,7 @@ PyRes :: struct {
 	defer internal_destroy(src);
 
 	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_digit:atoi(src):", err=err}; }
-	if err = #force_inline internal_shr_digit(src, digits);        err != nil { return PyRes{res=":shr_digit:shr_digit(src):", err=err}; }
+	if err = #force_inline internal_shr_digit(src, digits); err != nil { return PyRes{res=":shr_digit:shr_digit(src):", err=err}; }
 
 	r: cstring;
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator);
@@ -246,7 +246,7 @@ PyRes :: struct {
 	defer internal_destroy(src);
 
 	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shl_digit:atoi(src):", err=err}; }
-	if err = #force_inline internal_shl_digit(src, digits);        err != nil { return PyRes{res=":shl_digit:shr_digit(src):", err=err}; }
+	if err = #force_inline internal_shl_digit(src, digits); err != nil { return PyRes{res=":shl_digit:shr_digit(src):", err=err}; }
 
 	r: cstring;
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator);
@@ -265,7 +265,7 @@ PyRes :: struct {
 	defer internal_destroy(src);
 
 	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr:atoi(src):", err=err}; }
-	if err = #force_inline internal_shr(src, src, bits);           err != nil { return PyRes{res=":shr:shr(src, bits):", err=err}; }
+	if err = #force_inline internal_shr(src, src, bits); err != nil { return PyRes{res=":shr:shr(src, bits):", err=err}; }
 
 	r: cstring;
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator);
@@ -284,7 +284,7 @@ PyRes :: struct {
 	defer internal_destroy(src);
 
 	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shr_signed:atoi(src):", err=err}; }
-	if err = #force_inline internal_shr_signed(src, src, bits);    err != nil { return PyRes{res=":shr_signed:shr_signed(src, bits):", err=err}; }
+	if err = #force_inline internal_shr_signed(src, src, bits); err != nil { return PyRes{res=":shr_signed:shr_signed(src, bits):", err=err}; }
 
 	r: cstring;
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator);
@@ -303,7 +303,7 @@ PyRes :: struct {
 	defer internal_destroy(src);
 
 	if err = atoi(src, string(source), 16); err != nil { return PyRes{res=":shl:atoi(src):", err=err}; }
-	if err = #force_inline internal_shl(src, src, bits);           err != nil { return PyRes{res=":shl:shl(src, bits):", err=err}; }
+	if err = #force_inline internal_shl(src, src, bits); err != nil { return PyRes{res=":shl:shl(src, bits):", err=err}; }
 
 	r: cstring;
 	r, err = int_itoa_cstring(src, 16, context.temp_allocator);