Support for slices? about approx HOT 4 OPEN

Yeah, this seems like it would be really useful! I'm pretty sure this should work, seeing as slices implement the approx traits? Perhaps the documentation should be improved?

from approx.

If they do, it would certainly help to mention it ;)

I concluded from the docs that they don't, and rolled my own (totally not configurable):

#[macro_export]
macro_rules! assert_allclose {
    ($a:expr, $b:expr) => {
        use approx::ulps_eq;
        assert_eq!(
            $a.len(),
            $b.len(),
            "Data lengths differ: {} != {}",
            $a.len(),
            $b.len()
        );
        for i in 0 .. $a.len() {
            assert!(
                ulps_eq!($a[i], $b[i], max_ulps = 7),
                "Values at index {} differ: {} != {}\na = {:?}\nb = {:?}",
                i,
                $a[i],
                $b[i],
                $a,
                $b
            );
        }
    };
}

This indeed looks like it should do the job, but in practice I'm getting:

What may be a bit of a problem with the trait based approach is that a failed assert probably cannot output information to explain why it failed -- which can be quite a time safer. I'm wondering if this could be solved in a combination with the great pretty assertion crate.

from approx.

Ahh - once we have const generics we can implement it for fixed size arrays. We could also do what the standard library used to do and implement the traits for fixed size arrays of length 0 to 32. In the mean time you might be able to do:

assert_abs_diff_eq!([1.0, 2.0, 3.0].as_ref(), [1.0, 2.0, 3.0].as_ref());

This converts both sides to `&[{float}].

from approx.

I ran into this today.
Your solution @brendanzab works! But I ended up writing this:

use approx::assert_abs_diff_eq;
    use std::fmt::Debug;

    fn array_assert_eq<A: approx::AbsDiffEq<A> + Debug, const N: usize>(a: [A; N], b: [A; N]) {
        a.into_iter()
            .zip_eq(b.into_iter())
            .for_each(|(x, y)| assert_abs_diff_eq!(x, y));
    }

which is super-bad, but it means that const-generics are present enough to support slices finally?

from approx.