Rust code shared from the playground

playground.rs

extern crate rayon;
use rayon::iter::IntoParallelIterator;
use rayon::iter::ParallelIterator;

fn main() {
    let val = integral(|x| x * x, -1f64, 1f64);
    println!("{}", val);
}

fn integral<F>(fun: F, min: f64, max: f64) -> f64
where
    F: Fn(f64) -> f64 + Sized + Sync,
{
    let steps: usize = 100_000;
    let step_size: f64 = (max - min) / (steps as f64);

    (0..steps)
        .into_par_iter()
        .fold(
            || 0f64,
            |acc, x| {
                let i: f64 = x as f64;
                let left_input = min + (i * step_size);
                let right_input = left_input + step_size;
                let left_output = fun(left_input);
                let right_output = fun(right_input);
                let midpt = (left_output + right_output) / 2f64;

                acc + (midpt * step_size)
            },
        )
        .reduce(|| 0f64, |acc, a| acc + a)
}