Trait ArithmeticExt

pub trait ArithmeticExt<T>: Arithmetic<T> + Sized {
    // Provided methods
    fn without_comparisons(self) -> FullArithmetic<T, Self> { ... }
    fn with_natural_comparison(self) -> FullArithmetic<T, Self>
       where T: PartialOrd { ... }
    fn with_comparison(
        self,
        comparison: fn(&T, &T) -> Option<Ordering>,
    ) -> FullArithmetic<T, Self> { ... }
}

Extension trait for Arithmetic allowing to combine the arithmetic with comparisons.

Examples

use arithmetic_eval::arith::{ArithmeticExt, ModularArithmetic};

let base = ModularArithmetic::new(11);

// `ModularArithmetic` requires to define how numbers will be compared -
// and the simplest solution is to not compare them at all.
let program = Untyped::<NumGrammar<u32>>::parse_statements("1 < 3 || 1 >= 3")?;
let module = ExecutableModule::builder("test", &program)?.build();
assert_eq!(
    module.with_arithmetic(&base.without_comparisons()).run()?,
    Value::Bool(false)
);

// We can compare numbers by their integer value. This can lead
// to pretty confusing results, though.
let bogus_arithmetic = base.with_natural_comparison();
let program = Untyped::<NumGrammar<u32>>::parse_statements(r#"
    (x, y, z) = (1, 12, 5);
    x == y && x < z && y > z
"#)?;
let module = ExecutableModule::builder("test", &program)?.build();
assert_eq!(
    module.with_arithmetic(&bogus_arithmetic).run()?,
    Value::Bool(true)
);

// It's possible to fix the situation using a custom comparison function,
// which will compare numbers by their residual class.
let less_bogus_arithmetic = base.with_comparison(|&x: &u32, &y: &u32| {
    (x % 11).partial_cmp(&(y % 11))
});
assert_eq!(
    module.with_arithmetic(&less_bogus_arithmetic).run()?,
    Value::Bool(false)
);

Provided Methods

fn without_comparisons(self) -> FullArithmetic<T, Self>

Combines this arithmetic with a comparison function that assumes any two values are incomparable.

fn with_natural_comparison(self) -> FullArithmetic<T, Self>

where T: PartialOrd,

Combines this arithmetic with a comparison function specified by the PartialOrd implementation for T.

fn with_comparison( self, comparison: fn(&T, &T) -> Option<Ordering>, ) -> FullArithmetic<T, Self>

Combines this arithmetic with the specified comparison function.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T, A> ArithmeticExt<T> for A

where A: Arithmetic<T>,