Unexpected 'attempt to add with overflow' scenarios when using Rust's `num` crate for large integers
I'm stuck trying to I'm stuck trying to I'm working with an 'attempt to add with overflow' behavior while using the `num` crate to perform arithmetic with large integers. My code is intended to sum a vector of large numbers, but I get a panic during runtime. Here's the relevant code: ```rust use num::BigInt; use num::ToPrimitive; fn sum_large_numbers(numbers: &[BigInt]) -> Option<BigInt> { let mut total = BigInt::from(0); for number in numbers { total = total + number; } Some(total) } fn main() { let numbers = vec![BigInt::from(1_000_000_000_000_000), BigInt::from(2_000_000_000_000_000)]; let result = sum_large_numbers(&numbers); match result { Some(sum) => println!("Sum: {}", sum.to_string()), None => println!("behavior calculating sum"), } } ``` When I run this code, I get the following behavior message: ``` attempt to add with overflow ``` I initially thought that using `BigInt` would handle large numbers automatically, but it seems that's not the case here. I've checked the `num` crate documentation, and according to it, `BigInt` should be capable of handling arbitrary-sized integers without overflow issues. I'm using `num` crate version `0.4`. I've also tried using `BigInt::checked_add()` instead of `+`, but it seems to return an `Option<BigInt>`, which complicates the flow. How can I properly sum these large numbers without running into overflow errors? What am I doing wrong in my implementation? I recently upgraded to Rust latest. How would you solve this? I'm coming from a different tech stack and learning Rust. Any feedback is welcome!