// So, let us write a function to "add with carry", and give it the appropriate type. Notice Rust's native support for pairs.
So, let us write a function to "add with carry", and give it the appropriate type. Notice Rust's native support for pairs.
So let us write a function to " add with carry " and give it the appropriate type . Notice Rust ' s native support for pairs .
fn overflowing_add(a: u64, b: u64, carry: bool) -> (u64, bool) {
    let sum = a.wrapping_add(b);
    // If an overflow happened, then the sum will be smaller than *both* summands. Without an overflow, of course, it will be
    // at least as large as both of them. So, let's just pick one and check.
    if sum >= a {
        // The addition did not overflow. <br/>
        // **Exercise 08.1**: Write the code to handle adding the carry in this case.
        unimplemented!()
    } else {
        // Otherwise, the addition *did* overflow. It is impossible for the addition of the carry
        // to overflow again, as we are just adding 0 or 1.
        unimplemented!()
    }
}
fn overflowing_add ( a : u64 , b : u64 , carry : bool ) -> ( u64 , bool ) { let sum = a . wrapping_add ( b ) ; // If an overflow happened, then the sum will be smaller than *both* summands. Without an overflow, of course, it will be // at least as large as both of them. So, let's just pick one and check. if sum >= a { // The addition did not overflow. <br/> // **Exercise 08.1**: Write the code to handle adding the carry in this case. unimplemented ! ( ) } else { // Otherwise, the addition *did* overflow. It is impossible for the addition of the carry // to overflow again, as we are just adding 0 or 1. unimplemented ! ( ) } }
So, let us write a function to "add with carry", and give it the appropriate type.
So let us write a function to " add with carry " and give it the appropriate type .
a
u64
b
u64
carry
bool