How to Correctly Sum Up Numbers

For example, this is the proposed rust solution (imho the most readable):

    fn sum_up_numbers_correctly(numbers: &[i32]) -> Option<i32> {
        let mut sum: i32 = 0;
        for i in numbers {
            sum = sum.checked_add(*i)?;
        }
        Some(sum)
    }

The upside of wrapping addition is that you can overflow as often as you want, as long as the result is within the range of the type, the result (of addition and subtraction) is correct. The downside is that you don't know if the result is within range. So you trade between correctly handling a larger range of inputs with wrapping or being more certain of the result with checked overflow.

My preferred solution would have been just upcasting. If we make sum an i64 we know it can't overflow the intermediate if you sum less than 2^32 i32 numbers, and on a 64 bit machine you lose basically nothing by doing that. Keep the checked_add if you are concerned about people summing extremely long lists of numbers

    fn sum_up_numbers_correctly(numbers: &[i32]) -> Option<i32> {
        let mut sum: i64 = 0;
        for i in numbers {
            sum = sum.checked_add(*i as i64)?;
        }
        Some(sum.try_into().ok()?)
    }

When summing i64 you can do the same trick by summing into an i128

You can't memorize your way into software engineering. You can't say, "always wrap-around when an operation overflows" or "always tell the user (panic) when an operation overflows".

This article is a great example. C wraps unsigned integer addition on overflow, but Python upscales to arbitrary integer sizes. The trade-off, of course, is performance. If you're writing a real-time engine (for a rocket or a video game) and you can guarantee integer sizes, then you need to use the fastest algorithm possible. But if you're writing a general-purpose calculator, you might prefer upscaling or at least catching overflows and informing the user.

In almost any other disciple there would be a "correct" way to do it, or at least an accepted "best practice." But for software engineers, it's always, "it depends."

  fn sum_up_numbers_correctly(numbers: &[i32]) -> Option<i32> {
      let mut sum: i32 = 0;
      for i in numbers {
          sum = sum.checked_add(*i)?;
      }
      Some(sum)
  }

[0]https://docs.python.org/3/library/math.html#math.fsum

[1]https://github.com/tc39/proposal-math-sum

  alias tally='awk -F '\''[^-.0-9]'\'' '\''{ for (i = 1; i <= NF; i++) s += $i } END { print s }'\'''