Compiler Explorer

Source code

// Let’s reverse engineer a simple function that
// calculates the sum of all elements in an array.
//
// If you are familiar with C++, this Rust code will be
// easy to follow. Here is a great intro to Rust:
// https://fasterthanli.me/articles/a-half-hour-to-learn-rust

#![deny(warnings)]

// Returns the sum of all elements in a slice of signed
// 64-bit integers. A slice is an array residing a
// contiguous region of memory whose size is generally
// only known at runtime.
//
// The pointer to the start of the slice will be in rdi.
// The number of elements in the slice will be in rsi.
#[inline(never)]
pub fn sum_imperative(slice: &[i64]) -> i64 {
    let mut sum = 0;
    for n in slice {
        sum += n;
    }
    sum // The returned value will be in rax.
}

// In this program, the sum_iterator() function is
// equivalent to and produces the same machine code as
// the sum_imperative() function, so the two functions
// are merged by the compiler.
#[inline(never)]
pub fn sum_iterator<'a, I>(iter: I) -> i64
where I: Iterator<Item=&'a i64> {
    iter.sum()
}

// Prints the sums of the first N elements of a sample
// vector, as calculated by the two fucntions above. We
// start from N=0 elements and go up to the full length
// of the vector.
//
// In Godbolt’s setup, the compiler thinks main() is
// never used, so we suppress the warning.
#[allow(dead_code)]
fn main() {
    let v = vec![1, 2, 3, 18, -3, -8, -1, -2, -10, -42];
    for i in 0..=(v.len()) {
        let slice = &v[0..i];
        println!(
            "N={:2}: {:4} {:4}",
            i,
            sum_iterator(slice.iter()),
            sum_imperative(slice)
        );
    }
}