Ad hoc equality test for struct after definition

When working with Julia, it is common to encounter situations where you need to perform an ad hoc equality test for a struct after its definition. This can be useful in various scenarios, such as checking if two instances of a struct have the same values for certain fields. In this article, we will explore three different ways to solve this problem.

Option 1: Implementing the `isequal` function

One way to perform an ad hoc equality test for a struct is by implementing the `isequal` function for that struct. The `isequal` function is a generic function in Julia that is used to test for structural equality between objects. By defining this function for our struct, we can customize how the equality test is performed.

struct MyStruct
    field1
    field2
end

function Base.isequal(a::MyStruct, b::MyStruct)
    return a.field1 == b.field1 && a.field2 == b.field2
end

With this implementation, we can now use the `isequal` function to test for equality between instances of `MyStruct`. For example:

instance1 = MyStruct(1, 2)
instance2 = MyStruct(1, 2)
instance3 = MyStruct(3, 4)

isequal(instance1, instance2)  # Output: true
isequal(instance1, instance3)  # Output: false

Option 2: Overloading the `==` operator

Another way to perform an ad hoc equality test for a struct is by overloading the `==` operator for that struct. The `==` operator is used in Julia to test for equality between objects. By defining this operator for our struct, we can customize how the equality test is performed.

struct MyStruct
    field1
    field2
end

function Base.:(==)(a::MyStruct, b::MyStruct)
    return a.field1 == b.field1 && a.field2 == b.field2
end

With this implementation, we can now use the `==` operator to test for equality between instances of `MyStruct`. For example:

instance1 = MyStruct(1, 2)
instance2 = MyStruct(1, 2)
instance3 = MyStruct(3, 4)

instance1 == instance2  # Output: true
instance1 == instance3  # Output: false

Option 3: Using the `@generated` macro

A third option to perform an ad hoc equality test for a struct is by using the `@generated` macro. This macro allows us to generate code at compile-time based on the types of the arguments. By using this macro, we can generate a custom equality test for our struct.

struct MyStruct
    field1
    field2
end

function myequal(a::MyStruct, b::MyStruct)
    @generated function inner_myequal(a::MyStruct, b::MyStruct)
        quote
            return $(esc(a.field1)) == $(esc(b.field1)) && $(esc(a.field2)) == $(esc(b.field2))
        end
    end
    inner_myequal(a, b)
end

With this implementation, we can now use the `myequal` function to test for equality between instances of `MyStruct`. For example:

instance1 = MyStruct(1, 2)
instance2 = MyStruct(1, 2)
instance3 = MyStruct(3, 4)

myequal(instance1, instance2)  # Output: true
myequal(instance1, instance3)  # Output: false

After exploring these three options, it is clear that the best option depends on the specific requirements of your use case. If you want to customize the equality test for a struct in a general way, implementing the `isequal` function or overloading the `==` operator are good choices. On the other hand, if you need more fine-grained control over the generated code, using the `@generated` macro can be a powerful tool. Consider your specific needs and choose the option that best fits your requirements.