Add == definition of ComposedOptic and IndexLens from Setfield

src/optics.jl

@@ -9,6 +9,17 @@ using CompositionsBase
 using Base: getproperty
 using Base
 
+import Base: ==, hash
+
+function make_salt(s64::UInt64)::UInt
+    # used for faster hashes. See https://github.com/jw3126/Setfield.jl/pull/162
+    if UInt === UInt64
+        return s64
+    else
+        return UInt32(s64 >> 32)^UInt32(s64 & 0x00000000ffffffff)
+    end
+end
+
 const EXPERIMENTAL = """This function/type is experimental. It can be changed or deleted at any point without warning"""
 
 """
@@ -130,6 +141,11 @@ const ComposedOptic{Outer,Inner} = ComposedFunction{Outer,Inner}
 outertype(::Type{ComposedOptic{Outer,Inner}}) where {Outer,Inner} = Outer
 innertype(::Type{ComposedOptic{Outer,Inner}}) where {Outer,Inner} = Inner
 
+const SALT_COMPOSEDOPTIC = make_salt(0xcf7322dcc2129a31)
+Base.hash(l::ComposedOptic, h::UInt) = hash(l.outer, hash(l.inner, SALT_COMPOSEDOPTIC + h))
+
+Base.:(==)(l::ComposedOptic, r::ComposedOptic) = l.outer == r.outer && l.inner == r.inner
+
 # TODO better name
 # also better way to organize traits will
 # probably only emerge over time
@@ -416,6 +432,8 @@ Construct a lens for accessing an element of an object at `indices` via `[]`.
 """
 IndexLens(indices::Integer...) = IndexLens(indices)
 
+Base.:(==)(l::IndexLens, r::IndexLens) = l.indices == r.indices
+
 Base.@propagate_inbounds function (lens::IndexLens)(obj)
     getindex(obj, lens.indices...)
 end
@@ -486,14 +504,5 @@ Broadcast.broadcastable(
 
 Base.:(!)(f::Union{PropertyLens,IndexLens,DynamicIndexLens}) = (!) ∘ f
 
-
-function make_salt(s64::UInt64)::UInt
-    # used for faster hashes. See https://github.com/jw3126/Setfield.jl/pull/162
-    if UInt === UInt64
-        return s64
-    else
-        return UInt32(s64 >> 32)^UInt32(s64 & 0x00000000ffffffff)
-    end
-end
 const SALT_INDEXLENS = make_salt(0x8b4fd6f97c6aeed6)
 Base.hash(l::IndexLens, h::UInt) = hash(l.indices, SALT_INDEXLENS + h)

test/test_core.jl

@@ -187,6 +187,71 @@ Base.show(io::IO, ::MIME"text/plain", ::LensIfTextPlain) =
     end
 end
 
+@testset "equality & hashing" begin
+    # singletons (identity and property optic) are egal
+    for (l1, l2) ∈ [
+        @optic(_) => @optic(_),
+        @optic(_.a) => @optic(_.a),
+    ]
+        @test l1 === l2
+        @test l1 == l2
+        @test hash(l1) == hash(l2)
+    end
+
+    # composite and index optics are structurally equal
+    for (l1, l2) ∈ [
+        @optic(_[1]) => @optic(_[1]),
+        @optic(_.a[2]) => @optic(_.a[2]),
+        @optic(_.a.b[3]) => @optic(_.a.b[3]),
+        @optic(_[1:10]) => @optic(_[1:10]),
+        @optic(_.a[2:20]) => @optic(_.a[2:20]),
+        @optic(_.a.b[3:30]) => @optic(_.a.b[3:30]),
+    ]
+        @test l1 == l2
+        @test hash(l1) == hash(l2)
+    end
+
+    # inequality
+    for (l1, l2) ∈ [
+        @optic(_[1]) => @optic(_[2]),
+        @optic(_.a[1]) => @optic(_.a[2]),
+        @optic(_.a[1]) => @optic(_.b[1]),
+        @optic(_[1:10]) => @optic(_[2:20]),
+        @optic(_.a[1:10]) => @optic(_.a[2:20]),
+        @optic(_.a[1:10]) => @optic(_.b[1:10]),
+    ]
+        @test l1 != l2
+    end
+
+    # equality with non-equal range types (Setfield #165)
+    for (l1, l2) ∈ [
+        @optic(_[1:10]) => @optic(_[Base.OneTo(10)]),
+        @optic(_.a[1:10]) => @optic(_.a[Base.OneTo(10)]),
+        @optic(_.a.b[1:10]) => @optic(_.a.b[Base.OneTo(10)]),
+        @optic(_.a[Base.StepRange(1, 1, 5)].b[1:10]) => @optic(_.a[1:5].b[Base.OneTo(10)]),
+        @optic(_.a.b[1:3]) => @optic(_.a.b[[1, 2, 3]]),
+    ]
+        @test l1 == l2
+        @test hash(l1) == hash(l2)
+    end
+
+    # Hash property: equality implies equal hashes, or in other terms:
+    # optics either have equal hashes or are unequal
+    # Because collisions can occur theoretically (though unlikely), this is a property test,
+    # not a unit test.
+    random_optics = (@optic(_.a[rand(Int)]) for _ in 1:1000)
+    @test all((hash(l2) == hash(l1)) || (l1 != l2)
+              for (l1, l2) in zip(random_optics, random_optics))
+
+    # Optics 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(@optic(_[i])) != hash((i,)) for i = 1:1000) > 900
+
+    # Same for tuples of tuples (√(1000) ≈ 32).
+    @test count(hash(@optic(_[i][j])) != hash(((i,), (j,))) for i = 1:32, j = 1:32) > 900
+end
+
 @testset "type stability" begin
     o1 = 2
     o22 = 2