Dict equality with composite type value

Still new to Julia and trying to test one of my methods which return a Dict. I know what should be included in this Dict and I try to compare it with what is returned by my method. However I have difficulties to test equality between two Dicts.

Here is a minimal working example of my problem :


module Module
import Base

export Struct
export Simple

struct Struct

struct Simple


import Base
using Module
using Test

@testset "simple" begin
        expected = Dict{Int, Module.Simple}()
        expected[1] = Module.Simple(1)
        actual = Dict{Int, Module.Simple}()
        actual[1] = Module.Simple(1)
        @test actual == expected

@testset "struct" begin
        expected = Dict{Int, Module.Struct}()
        expected[1] = Module.Struct(1, [1.0])
        actual = Dict{Int, Module.Struct}()
        actual[1] = Module.Struct(1, [1.0])
        @test actual == expected

For the Simple struct, test passed without any problem.
For the Struct struct, test failed with the following error :

(Module) pkg> test
   Testing Module
 Resolving package versions...
Test Summary: | Pass  Total
simple        |    1      1
struct: Test Failed at /home/xxxxxxx/sandbox/Module/test/runtests.jl:18
  Expression: actual == expected
   Evaluated: Dict(1 => Struct(1, [1.0])) == Dict(1 => Struct(1, [1.0]))
 [1] top-level scope at /home/xxxxxxxxx/sandbox/Module/test/runtests.jl:18
 [2] top-level scope at /build/julia/src/julia-1.2.0/usr/share/julia/stdlib/v1.2/Test/src/Test.jl:1113
 [3] top-level scope at /home/xxxxxxxx/sandbox/Module/test/runtests.jl:14
Test Summary: | Fail  Total
struct        |    1      1

First, I have strictly no idea why this error occurs. Is it related to the fact that Simple is strictly immutable and Struct is not (Vector is an array and arrays are mutable in julia if i get it right) ?

I try to find an answer in julia documentation and discourse and I thought :

  • I should create following methods : Base.isequal(struct::Struct) and Base.hash(struct::Struct)
  • I should replace Struct variables by strictly immutable types

So I have the following questions :

  • Why this error occurs ?
  • Should I create a specific Base.isequal/hash for each new struct I create ?
  • Is there any way to rely on default Dict implementation to test equality between two dicts with custom composite types ?

Thank you!

What you are running into is that == for custom immutable structs just ends up falling back to ===, and because your two arrays you pass to Struct don’t have the same location in memory, this returns false. There is already an open issue for this here. The solution in your case would be to overload Base.:(==) or Base.isequal for Struct. You might not even need to overload hash, but I would test that again first.

1 Like

Thanks for your answer and the link to the issue.
I understand now why for Struct it does not work and throw an error.
Just have a follow up question for the Simple case :

@testset "identity/equals" begin
        a = 1
        b = 1
        @test 1 === 1 # pass => OK
        @test [1.0] === [1.0] # fail => OK
        @test [1.0] == [1.0] # pass => OK
        @test  a === b # pass => Why ?

In this test a and b should not have the same location in memory and the identity comparison still return true. Is there a special case for primitive types ?

There is no special case for primitive types, in julia, the variables use the memory used to store its value, each variable does not have its own memory. So a and b have the same location, and it is normal that pass the identity comparison. When you say var1 = var2, var1 and var2 are alias, each variable has not its own memory, the memory is the same, the memory needed to store the value.

b = [1.0]
a = b
@test a === b  # true

Actually, when the variable value is scalar, its behavior is similar to have its own memory.

a = 4
b = a # Both are the same value and memory position
a === b # true
a = 5 # Now a make reference to constant 5, stored in a different  memory position
a === b # false
println(b) # Print 4
println(a) # Print 5 

By the way, as @simeonschaub said, your code will pass the tests doing:

import Base: ==

function ==(val1::Module.Struct, val2::Module.Struct)
    return val1.id == val2.id && val1.x == val2.x
1 Like

Thank you for your answer.
I need more insight :

I quote :

So a and b have the same location, and it is normal that pass the identity comparison

a = 1
b = 1
a === b # true

why in this case a and b refers to the same memory location ?

Thank you !

It doesn’t. Forget about memory locations, they are very misleading in understanding ===.

The best definition is in its docstring:

Determine whether x and y are identical, in the sense that no program could distinguish them.

Also, if you end up defining an == method for something, it is usually advantageous to define Base.hash too right away. It is very easy to end up with your values in a Dict or something similar, and then chase a silly bug for hours just because hash does not match ==.


Thank you for your answer.

Ok I had to focus more on === documentation.
Indeed integer literals 1 could not be distinguished.
Then, how julia distinguish arrays (first guess : allocated on the heap at different location? )

a = [1.0] 
b = [1.0]
a === b # false

I agree with you both == and hash should be overloaded right away.

One key ingredient about the efficiency is Julia is that the “how” is left unspecified, so it leaves considerable room for the compiler to do clever things. So unless you want to understand internals (in which case dig into the source and follow the devdocs), don’t be concerned about this.

What is clear that one could devise a conforming program could distinguish them (eg change some values and check if they change in the other one), so they are not equal. Whereas eg

using StaticArrays
a = SVector(1, 2)
b = SVector(1, 2)
a === b # true

Thanks ! All clear now !