Implement tuple-only hashing with magic numbers; test hash properties

Author: phipsgabler

src/lens.jl

@@ -9,6 +9,17 @@ export constructorof
 import Base: get, hash, ==
 using Base: getproperty
 
+
+# used for hashing
+function make_salt(s64::UInt64)::UInt
+    if UInt === UInt64
+        return s64
+    else
+        return UInt32(s64 >> 32) ^ UInt32(s64 & 0x00000000ffffffff)
+    end
+end
+
+
 """
     Lens
 
@@ -119,7 +130,9 @@ end
 function ==(l1::ComposedLens{LO, LI}, l2::ComposedLens{LO, LI}) where {LO, LI}
     return l1.outer == l2.outer && l1.inner == l2.inner
 end
-hash(l::ComposedLens, h::UInt) = hash(l.outer, hash(l.inner, h))
+
+const SALT_COMPOSEDLENS = make_salt(0xcf7322dcc2129a31)
+hash(l::ComposedLens, h::UInt) = hash(l.outer, hash(l.inner, SALT_INDEXLENS + h))
 
 """
     compose([lens₁, [lens₂, [lens₃, ...]]])
@@ -179,8 +192,11 @@ end
 struct IndexLens{I <: Tuple} <: Lens
     indices::I
 end
+
 ==(l1::IndexLens{I}, l2::IndexLens{I}) where {I} = l1.indices == l2.indices
-hash(l::IndexLens, h::UInt) = hash(l.indices, h)
+
+const SALT_INDEXLENS = make_salt(0x8b4fd6f97c6aeed6)
+hash(l::IndexLens, h::UInt) = hash(l.indices, SALT_INDEXLENS + h)
 
 Base.@propagate_inbounds function get(obj, l::IndexLens)
     getindex(obj, l.indices...)

test/test_core.jl

@@ -206,22 +206,50 @@ end
 end
 
 @testset "equality & hashing" begin
-    # singletons (identity and property lens) are object equal
-    for (l, r) ∈ [
+    # singletons (identity and property lens) are egal
+    for (l1, l2) ∈ [
         @lens(_) => @lens(_),
         @lens(_.a) => @lens(_.a)
     ]
-        @test l === r
+        @test l1 === l2
+        @test l1 == l2
+        @test hash(l1) == hash(l2)
     end
 
     # composite and index lenses are structurally equal
-    for (l, r) ∈ [
+    for (l1, l2) ∈ [
         @lens(_[1]) => @lens(_[1])
         @lens(_.a[2]) => @lens(_.a[2])
+        @lens(_.a.b[3]) => @lens(_.a.b[3])
     ]
-        @test l == r
-        @test hash(l) == hash(r)
+        @test l1 == l2
+        @test hash(l1) == hash(l2)
     end
+
+    # inequality
+    for (l1, l2) ∈ [
+        @lens(_[1]) => @lens(_[2])
+        @lens(_.a[1]) => @lens(_.a[2])
+        @lens(_.a[1]) => @lens(_.b[1])
+    ]
+        @test l1 != l2
+    end
+
+    # Hash property: equality implies equal hashes, or in other terms:
+    # lenses either have equal hashes or are unequal
+    # Because collisions can occur theoretically (though unlikely), this is a property test,
+    # not a unit test.
+    random_lenses = (@lens(_.a[rand(Int)]) for _ in 1:1000)
+    @test all((hash(l2) == hash(l1)) || (l1 != l2)
+              for (l1, l2) in zip(random_lenses, random_lenses))
+
+    # Lenses should hash differently from the underlying tuples, to avoid confusion.
+    # To account for potential collisions, we check that the property holds with high
+    # probability.  
+    @test count(hash(@lens(_[i])) != hash((i,)) for i = 1:1000) > 900
+
+    # Same for tuples of tuples (√(1000) ≈ 32).
+    @test count(hash(@lens(_[i][j])) != hash(((i,), (j,))) for i = 1:32, j = 1:32) > 900
 end