Merge pull request #162 from phipsgabler/phg/hashing

Fix #161: Implement == and hash for IndexLens and ComposedLens

Author: jw3126

Project.toml

@@ -1,6 +1,6 @@
 name = "Setfield"
 uuid = "efcf1570-3423-57d1-acb7-fd33fddbac46"
-version = "0.7.1"
+version = "0.8.0"
 
 [deps]
 ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9"

src/lens.jl

@@ -6,9 +6,20 @@ export setproperties
 export constructorof
 
 
-import Base: get
+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
 
@@ -99,6 +110,7 @@ struct IdentityLens <: Lens end
 get(obj, ::IdentityLens) = obj
 set(obj, ::IdentityLens, val) = val
 
+
 struct PropertyLens{fieldname} <: Lens end
 
 function get(obj, l::PropertyLens{field}) where {field}
@@ -115,6 +127,13 @@ struct ComposedLens{LO, LI} <: Lens
     inner::LI
 end
 
+function ==(l1::ComposedLens{LO, LI}, l2::ComposedLens{LO, LI}) where {LO, LI}
+    return l1.outer == l2.outer && l1.inner == l2.inner
+end
+
+const SALT_COMPOSEDLENS = make_salt(0xcf7322dcc2129a31)
+hash(l::ComposedLens, h::UInt) = hash(l.outer, hash(l.inner, SALT_INDEXLENS + h))
+
 """
     compose([lens₁, [lens₂, [lens₃, ...]]])
 
@@ -174,6 +193,11 @@ struct IndexLens{I <: Tuple} <: Lens
     indices::I
 end
 
+==(l1::IndexLens{I}, l2::IndexLens{I}) where {I} = l1.indices == l2.indices
+
+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...)
 end

test/test_core.jl

@@ -205,6 +205,54 @@ end
     end
 end
 
+@testset "equality & hashing" begin
+    # singletons (identity and property lens) are egal
+    for (l1, l2) ∈ [
+        @lens(_) => @lens(_),
+        @lens(_.a) => @lens(_.a)
+    ]
+        @test l1 === l2
+        @test l1 == l2
+        @test hash(l1) == hash(l2)
+    end
+
+    # composite and index lenses are structurally equal
+    for (l1, l2) ∈ [
+        @lens(_[1]) => @lens(_[1])
+        @lens(_.a[2]) => @lens(_.a[2])
+        @lens(_.a.b[3]) => @lens(_.a.b[3])
+    ]
+        @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
+
+
 @testset "type stability" begin
     o1 = 2
     o22 = 2