Equality

The most common way to test equality is with = For numeric equality (IEEE) use == For bytewise equality use identical?

The behavior and names are based on Clojure's implementation. Read their docs here: https://clojure.org/guides/equality Also check out slosh/tests/equality.slosh for some examples.

  • =

    • (= 2 0x2) is true (comparing an int to a byte)

    • (= 2 2.0) is false (comparing an int to a float)

    • (= 0.0 -0.0) is true

    • (= NaN NaN) is false

    • state.rs defines special forms object with key equal mapped to the name =.

    • compile.rs matches on env.specials().equal and generates opcode EQUAL

    • exec_loop.rs maps opcode EQUAL to function is_equal

    • vm.rs is_equal converts each arg to a Value (in case it needs to be dereferenced) and calls is_equal_pair

    • vm.rs is_equal_pair does a complex test for equality

      • check if both args are Byte or Int and if so, converts both to i64 with Value::get_int and compares with rust native ==
      • check if both args are numbers (Byte, Int, or Float) and if so, converts both to f64 with Value::get_float and compares with rust native ==

  • ==

    • (== 1 1.0) is true (comparing an int to a float)

    • (== 0.0 -0.0) is true

    • (== NaN NaN) is false

    • returns true whenever = does, but also returns true for numbers that are numerically equal

    • when comparing two floats, converts two both to f64 and compares with native f64 ==

    • does not use F56::PartialEq implementation

    • state.rs defines special forms object with key numeq mapped to the name ==.

    • compile.rs calls compile_list which calls compile_special which calls compile_math in compile_math.rs

    • compile_math.rs compile_math matches on env.specials().numeq and generates opcode NUMEQ

    • exec_loop.rs maps opcode NUMEQ to function compare_numeric and passes a comparator |a,b| a == b

    • macros.rs compare_numeric

      • checks if either argument is a Float and if so, converts both to f64 with get_primitive_float macro and uses the comparator
      • checks if either argument is a Int and if so, converts both to i64 with get_primitive_int macro and uses the comparator

  • identical?

    • (identical? 1 1) is true

    • (identical? 1 1.0) is false (different types)

    • (identical? 0.0 -0.0) is false (comparing floats with different bit patterns)

    • (identical? NaN NaN) might be true or false. There are trillions of different bit patterns that represent NaN in IEEE 754

    • is the only equality comparison that uses Value::PartialEq implementation which is always false for different types of Values

    • using identical equality for floats causes problems with hashing. #125 identical equality is 'too strict' in that you probably expect that +0 and -0 should hash to the same thing, but they don't rendering hash tables

    • state.rs defines special forms object with key eq mapped to the name identical?.

    • compile.rs matches on env.specials().eq and generates opcode EQ

    • exec_loop.rs maps opcode EQ to function is_identical

    • vm.rs is_identical converts each arg to a Value (in case it needs to be dereferenced) and compares val1 == val2 which uses Value::PartialEq implementation

  • assert-equal

    • based on =
    • is a macro defined in core.slosh which checks if the arguments are = and throws an error if they are not

  • not=

    • defined in vm/core.slosh as the negation of =

  • not==

    • defined in vm/core.slosh as the negation of ==