Overflow on absolute comparison of signed integers

[pcpthm]

fn main() {
    approx::abs_diff_ne!(std::i32::MAX, std::i32::MIN);
}

Expected behavior: Runs fine.
Actual behavior: thread 'main' panicked at 'attempt to subtract with overflow'.

[pcpthm]

More corner case:

approx::abs_diff_ne!(-1, std::i32::MAX)

won't overflow on subtraction but will be overflow on abs

[brendanzab]

Oh huh, that's interesting. We actually implement these comparisons for integers?

[brendanzab]

Right, seems like it's here:

approx/src/abs_diff_eq.rs

Lines 35 to 87 in 0527afe

	macro_rules! impl_unsigned_abs_diff_eq {
	($T:ident, $default_epsilon:expr) => {
	impl AbsDiffEq for $T {
	type Epsilon = $T;
	#[inline]
	fn default_epsilon() -> $T {
	$default_epsilon
	}
	#[inline]
	fn abs_diff_eq(&self, other: &$T, epsilon: $T) -> bool {
	(if self > other {
	self - other
	} else {
	other - self
	}) <= epsilon
	}
	}
	};
	}
	impl_unsigned_abs_diff_eq!(u8, 0);
	impl_unsigned_abs_diff_eq!(u16, 0);
	impl_unsigned_abs_diff_eq!(u32, 0);
	impl_unsigned_abs_diff_eq!(u64, 0);
	impl_unsigned_abs_diff_eq!(usize, 0);
	macro_rules! impl_signed_abs_diff_eq {
	($T:ident, $default_epsilon:expr) => {
	impl AbsDiffEq for $T {
	type Epsilon = $T;
	#[inline]
	fn default_epsilon() -> $T {
	$default_epsilon
	}
	#[inline]
	fn abs_diff_eq(&self, other: &$T, epsilon: $T) -> bool {
	$T::abs(self - other) <= epsilon
	}
	}
	};
	}
	impl_signed_abs_diff_eq!(i8, 0);
	impl_signed_abs_diff_eq!(i16, 0);
	impl_signed_abs_diff_eq!(i32, 0);
	impl_signed_abs_diff_eq!(i64, 0);
	impl_signed_abs_diff_eq!(isize, 0);
	impl_signed_abs_diff_eq!(f32, f32::EPSILON);
	impl_signed_abs_diff_eq!(f64, f64::EPSILON);

[jonaspleyer]

What is the expected behavior here? Panic on overflow?