Zero-Cost Abstractions — A Practical Check

use std::time::Instant;

fn main() {
    // Create 2_147_418_111 integers to get 65536 sum
    let data: Vec<i32> = (0..2_147_418_111).collect();

    // Warm-up
    let _warmup: i32 = data.iter().filter(|x| **x % 2 == 0).map(|x| x * 2).sum();

    // Measure iterator chain
    let start = Instant::now();
    let sum_iter: i32 = data.iter().filter(|x| **x % 2 == 0).map(|x| x * 2).sum();
    let dur_iter = start.elapsed();

    // Measure equivalent for-loop
    let start = Instant::now();
    let mut sum_loop = 0i32;
    for x in &data {
        if x % 2 == 0 {
            sum_loop += x * 2;
        }
    }
    let dur_loop = start.elapsed();

    println!("Iterator sum: {}; time: {:?}", sum_iter, dur_iter);
    println!("Loop sum: {}; time: {:?}", sum_loop, dur_loop);
}

#include <vector>
#include <numeric>
#include <chrono>
#include <fmt/core.h>

using namespace std;
using fmt::print;

int main() {
    vector<int> data;
	data.reserve(2'147'418'111); // Same amount as in Rust

	for (int i = 0; i < data.capacity(); ++i) {
    	data.push_back(i);
	}
    volatile int warmup = accumulate(
        data.begin(), data.end(), 0,
        [](int acc, int x) {
            return (x % 2 == 0) ? acc + x * 2 : acc;
        }
    );

    auto start = chrono::high_resolution_clock::now();
    int sum_iter = accumulate(
        data.begin(), data.end(), 0,
        [](int acc, int x) {
            return (x % 2 == 0) ? acc + x * 2 : acc;
        }
    );
    auto dur_iter = chrono::high_resolution_clock::now() - start;

    start = chrono::high_resolution_clock::now();
    int sum_loop = 0;
    for (int x : data) {
        if (x % 2 == 0) {
            sum_loop += x * 2;
        }
    }
    auto dur_loop = chrono::high_resolution_clock::now() - start;

	print("Iterator sum: {}; time: {}ms\n",
    	sum_iter,
    	chrono::duration<double, milli>(dur_iter).count());

	print("Loop sum: {}; time: {}ms\n",
    	sum_loop,
    	chrono::duration<double, milli>(dur_loop).count());
    return 0;
}

let sum_iter: i32 = data.iter().filter(|x| **x % 2 == 0).map(|x| x * 2).sum();
// and
    for x in &data {
        if x % 2 == 0 {
            sum_loop += x * 2;
        }
    }