Merge pull request #7 from jw3126/hash_eq_as

Add hash_eq_as

Author: jw3126

Project.toml

@@ -1,7 +1,7 @@
 name = "StructHelpers"
 uuid = "4093c41a-2008-41fd-82b8-e3f9d02b504f"
 authors = ["Jan Weidner <jw3126@gmail.com> and contributors"]
-version = "1.0"
+version = "1.1"
 
 [deps]
 ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9"

src/StructHelpers.jl

@@ -5,15 +5,44 @@ export @enumbatteries
 
 import ConstructionBase: getproperties, constructorof, setproperties
 
+"""
+    hash_eq_as(obj)
+
+This allows to fine tune the behavior or `hash`, `==` and `isequal` for structs decorated by [`@batteries`](@ref).
+For instances the generated `isequal` method looks like this:
+```julia
+function Base.isequal(o1::T, o2::T)
+    proxy1 = StructHelpers.hash_eq_as(o1)
+    proxy2 = StructHelpers.hash_eq_as(o2)
+    isequal(proxy1, proxy2)
+end
+```
+Overloading `hash_eq_as` is useful for instance if you want to skip certain fields
+of `obj` or handle them in a special way.
+"""
+function hash_eq_as(obj)
+    # it would be better to just use getproperties
+    # but this would cause hashed to change, which we want to 
+    # keep backwards compatible for now.
+    #
+    # TODO: Change to getproperties once we want to make a hash breaking change
+    Tuple(getproperties(obj))
+end
+
 @inline function structural_eq(o1, o2)
     getproperties(o1) == getproperties(o2)
 end
 @inline function structural_isequal(o1, o2)
     isequal(getproperties(o1), getproperties(o2))
 end
 
-start_hash(o, h, typesalt::Nothing) = Base.hash(typeof(o), h)
-start_hash(o, h, typesalt) = Base.hash(typesalt, h)
+function start_hash(o, h, typesalt::Nothing) 
+    Base.hash(typeof(o), h)
+end
+function start_hash(o, h, typesalt) 
+    Base.hash(typesalt, h)
+end
+
 @inline function structural_hash(o, h::UInt, typesalt=nothing)::UInt
     h = start_hash(o, h, typesalt)
     nt = Tuple(getproperties(o))
@@ -64,7 +93,7 @@ const BATTERIES_DOCSTRINGS = (
     kwshow        = "Overload `Base.show` such that the names of each field are printed.",
     getproperties = "Overload `ConstructionBase.getproperties`.",
     constructorof = "Overload `ConstructionBase.constructorof`.",
-    typesalt      = "Only used if `hash=true`. In this case the `hash` will be purely computed from `typesalt` and `getproperties(T)`. The type `T` will not be used otherwise. This makes the hash more likely to stay constant, when executing on a different machine or julia version",
+    typesalt      = "Only used if `hash=true`. In this case the `hash` will be purely computed from `typesalt` and `hash_eq_as(obj)`. The type `T` will not be used otherwise. This makes the hash more likely to stay constant, when executing on a different machine or julia version",
 )
 
 if (keys(BATTERIES_DEFAULTS) != keys(BATTERIES_DOCSTRINGS))
@@ -107,6 +136,8 @@ end
 Supported options and defaults are:
 
 $(doc_batteries_options())
+
+See also [`hash_eq_as`](@ref)
 """
 macro batteries(T, kw...)
     nt = parse_all_macro_kw(kw)
@@ -149,15 +180,26 @@ macro batteries(T, kw...)
         fieldnames = Base.fieldnames(Base.eval(__module__, T))
     end
     if nt.hash
-        def = :(Base.hash(o::$T, h::UInt) = $(structural_hash)(o,h, $(nt.typesalt)))
+        def = :(function Base.hash(o::$T, h::UInt) 
+            h = ($start_hash)(o, h, $(nt.typesalt))
+            proxy = ($hash_eq_as)(o)
+            Base.hash(proxy, h)
+        end
+        )
         push!(ret.args, def)
     end
     if nt.eq
-        def = :(Base.:(==)(o1::$T, o2::$T) = $(structural_eq)(o1, o2))
+        def = :(function Base.:(==)(o1::$T, o2::$T)
+            ($hash_eq_as)(o1) == ($hash_eq_as)(o2)
+        end
+        )
         push!(ret.args, def)
     end
     if nt.isequal
-        def = :(Base.isequal(o1::$T, o2::$T) = $(structural_isequal)(o1, o2))
+        def = :(function Base.isequal(o1::$T, o2::$T) 
+            isequal($hash_eq_as(o1), $hash_eq_as(o2))
+        end
+        )
         push!(ret.args, def)
     end
     if nt.kwshow

test/runtests.jl

@@ -36,6 +36,9 @@ struct Salt2 end
 struct NoSalt end
 @batteries NoSalt
 
+struct SaltABC; a;b;c end
+@batteries SaltABC typesalt = 1
+
 struct SErrors;a;b;c;end
 
 struct NoSelfCtor; a; end
@@ -91,9 +94,21 @@ struct SNoIsEqual; a; end
     @test_throws Exception @macroexpand @batteries SErrors nonsense=true
     @macroexpand @batteries SErrors kwconstructor=true
 
-    @test hash(Salt1()) === hash(Salt1b())
-    @test hash(Salt1()) != hash(NoSalt())
-    @test hash(Salt1()) != hash(Salt2())
+    @testset "typesalt" begin
+        @test hash(Salt1()) === hash(Salt1b())
+        @test hash(Salt1()) != hash(NoSalt())
+        @test hash(Salt1()) != hash(Salt2())
+
+        # persistence
+        @test hash(Salt1())  === 0xd39a1e58a7b0c35e
+        @test hash(Salt1b()) === 0xd39a1e58a7b0c35e
+        @test hash(Salt2())  === 0x2f64a52e5f45d104
+
+        @test hash(SaltABC(1  , 2  , 3 )) === 0x92290cfd972fe54d
+        @test hash(SaltABC(10 , 2  , 3 )) === 0xcc48b9e98b6f3ef4
+        @test hash(SaltABC(10 , 20 , 3 )) === 0x6f8c614051f68ec7
+        @test hash(SaltABC(10 , 20 , 30)) === 0x90cb2b9a94741e53
+    end
 
     @test WithSelfCtor(WithSelfCtor(1)) === WithSelfCtor(1)
     @test NoSelfCtor(NoSelfCtor(1)) != NoSelfCtor(1)
@@ -153,3 +168,70 @@ struct Bad end
         @test_throws "Bad keyword argument value" @macroexpand @batteries Bad hash=:nonsense
     end
 end
+
+abstract type AbstractHashEqAs end
+function SH.hash_eq_as(x::AbstractHashEqAs)
+    return x.hash_eq_as(x.payload)
+end
+
+struct HashEqAs <: AbstractHashEqAs
+    hash_eq_as
+    payload
+end
+SH.@batteries HashEqAs 
+struct HashEqAsTS1 <: AbstractHashEqAs
+    hash_eq_as
+    payload
+end
+SH.@batteries HashEqAsTS1 typesalt = 1
+
+struct HashEqAsTS1b <: AbstractHashEqAs
+    hash_eq_as
+    payload
+end
+SH.@batteries HashEqAsTS1b typesalt = 1
+
+struct HashEqAsTS2 <: AbstractHashEqAs
+    hash_eq_as
+    payload
+end
+SH.@batteries HashEqAsTS2 typesalt = 2
+
+@testset "hash_eq_as" begin
+    @test HashEqAs(identity, 1) != HashEqAs(identity, -1)
+    @test HashEqAs(abs, 1) == HashEqAs(abs, -1)
+    @test isequal(HashEqAs(identity, 1), HashEqAs(x->x, 1))
+
+    @test hash(HashEqAs(identity, 1)) != hash(HashEqAs(identity, -1))
+    @test hash(HashEqAs(abs, 1)) === hash(HashEqAs(abs, -1))
+    @test hash(HashEqAs(identity, 1)) === hash(HashEqAs(x->x, 1))
+
+    @test hash(HashEqAsTS1(identity, 1)) != hash(HashEqAsTS1(identity, -1))
+    @test hash(HashEqAsTS1(abs, 1)) == hash(HashEqAsTS1(abs, -1))
+    @test hash(HashEqAsTS1b(abs, 1)) == hash(HashEqAsTS1(abs, -1))
+    @test hash(HashEqAsTS2(abs, 1)) != hash(HashEqAsTS1(abs, -1))
+
+    @test hash(HashEqAsTS1(x->2x::Int, 1)) === hash(HashEqAsTS1(identity, 2))
+    @test hash(HashEqAsTS2(x->2x::Int, 1)) != hash(HashEqAsTS1(identity, 2))
+    @test hash(HashEqAsTS1(identity, 1)) === 0x486b072c90d60e64
+    @test hash(HashEqAsTS2(x->5x, 1)) === 0xa4360acf486c15a4
+end
+
+mutable struct HashEqErr
+    a
+    b
+end
+Base.hash(::HashEqErr, h::UInt) = error()
+Base.isequal(::HashEqErr, ::HashEqErr) = error()
+Base.:(==)(::HashEqErr, ::HashEqErr) = error()
+
+@testset "structural hash eq" begin
+    S = HashEqErr
+    @test SH.structural_eq(S(1,3), S(1,3))
+    @test !SH.structural_eq(S(1,NaN), S(1,NaN))
+    @test SH.structural_isequal(S(1,NaN), S(1,NaN))
+    @test !SH.structural_isequal(S(2,NaN), S(1,NaN))
+    @test SH.structural_hash(S(2,NaN), UInt(0)) != SH.structural_hash(S(1,NaN), UInt(0))
+    @test SH.structural_hash(S(2,NaN), UInt(0)) == SH.structural_hash(S(2,NaN), UInt(0))
+    @test SH.structural_hash(S(2,NaN), UInt(0)) != SH.structural_hash(S(2,NaN), UInt(1))
+end