Enum arithmetic_eval::fns::Compare

#[non_exhaustive]
pub enum Compare {
    Raw,
    Min,
    Max,
}

Comparator functions on two primitive arguments. All functions use Arithmetic to determine ordering between the args.

Type

fn(Num, Num) -> Ordering // for `Compare::Raw`
fn(Num, Num) -> Num // for `Compare::Min` and `Compare::Max`

Examples

Using min function:

let program = "
    // Finds a minimum number in an array.
    extended_min = |...xs| fold(xs, INFINITY, min);
    extended_min(2, -3, 7, 1, 3) == -3
";
let program = Untyped::<F32Grammar>::parse_statements(program)?;
let module = ExecutableModule::new("test_min", &program)?;

let mut env = Environment::new();
env.insert("INFINITY", Value::Prim(f32::INFINITY))
    .insert_native_fn("fold", fns::Fold)
    .insert_native_fn("min", fns::Compare::Min);
assert_eq!(module.with_env(&env)?.run()?, Value::Bool(true));

Using cmp function with Comparisons.

let program = "
    map((1, -7, 0, 2), |x| cmp(x, 0)) == (GREATER, LESS, EQUAL, GREATER)
";
let program = Untyped::<F32Grammar>::parse_statements(program)?;
let module = ExecutableModule::new("test_cmp", &program)?;

let mut env = Environment::new();
env.extend(Comparisons::iter());
env.insert_native_fn("map", fns::Map);
assert_eq!(module.with_env(&env)?.run()?, Value::Bool(true));

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Raw

Returns an Ordering wrapped into an OpaqueRef, or Value::void() if the provided values are not comparable.

Min

Returns the minimum of the two values. If the values are equal / not comparable, returns the first one.

Max

Returns the maximum of the two values. If the values are equal / not comparable, returns the first one.

Trait Implementations

impl Clone for Compare

fn clone(&self) -> Compare

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Compare

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> NativeFn<T> for Compare

fn evaluate( &self, args: Vec<SpannedValue<T>>, ctx: &mut CallContext<'_, T>, ) -> EvalResult<T>

Executes the function on the specified arguments.

impl Copy for Compare