timearray: Revoke deprecation of == and redefine its meaning

NEWS.md

@@ -1,3 +1,28 @@
+### 0.12.0
+
+* Revoking deprecation warning of `==` and redefining its meaning as
+  'comparing all fields of two `TimeArray`s'.
+  Note that if two `TimeArray`s have different dimension, we consider that is
+  unequal.
+  (#356, #357)
+
+  ```julia
+  julia> cl == copy(cl)
+  true
+  ```
+
+  * Also, `isequal` and `hash` is supported now.
+
+    ```julia
+    julia> d = Dict(cl => 42);
+
+    julia> d[cl]
+    42
+
+    julia> d[copy(cl)]
+    42
+    ```
+
 ### 0.11.0
 
 * Dropping 0.5 support. (issue [#327])

src/deprecated.jl

@@ -30,7 +30,7 @@ for f ∈ (:^, :/)
 end
 
 for f ∈ (:+, :-, :*, :%,
-         :|, :&, :<, :>, :(==), :(!=), :>=, :<=)
+         :|, :&, :<, :>, :>=, :<=)
     g = Symbol(".", string(f))
     @eval import Base: $f
     @eval @deprecate $f(ta::TimeArray, args...) $g(ta, args...)

src/timearray.jl

@@ -1,7 +1,7 @@
 ###### type definition ##########
 
 import Base: convert, copy, length, show, getindex, start, next, done, isempty,
-             endof, size, eachindex
+             endof, size, eachindex, ==, isequal, hash
 
 abstract type AbstractTimeSeries end
 
@@ -69,13 +69,47 @@ length(ata::AbstractTimeSeries) = length(ata.timestamp)
 
 size(ta::TimeArray, dim...) = size(ta.values, dim...)
 
-###### iterator protocol #########
+###### iterator protocol ########
 
 start(ta::TimeArray)   = 1
 next(ta::TimeArray, i) = ((ta.timestamp[i], ta.values[i, :]), i + 1)
 done(ta::TimeArray, i) = (i > length(ta))
 isempty(ta::TimeArray) = (length(ta) == 0)
 
+###### equal ####################
+
+"""
+    ==(x::TimeArray, y::TimeArray)
+
+If `true`, all fields of `x` and `y` should be equal,
+meaning that the two `TimeArray`s have the same values at the same points in time,
+the same colnames and the same metadata.
+
+Implies
+
+```julia
+x.timestamp == y.timestamp &&
+x.values    == y.values    &&
+x.colnames  == y.colnames  &&
+x.meta      == y.meta
+```
+"""
+# Other type info is not helpful for assertion.
+# e.g.
+#      1.0 == 1
+#      Date(2111, 1, 1) == DateTime(2111, 1, 1)
+==(x::TimeArray{T,N}, y::TimeArray{S,M}) where {T,S,N,M} = false
+==(x::TimeArray{T,N}, y::TimeArray{S,N}) where {T,S,N} =
+    all(f -> getfield(x, f) == getfield(y, f), fieldnames(TimeArray))
+
+isequal(x::TimeArray{T,N}, y::TimeArray{S,M}) where {T,S,N,M} = false
+isequal(x::TimeArray{T,N}, y::TimeArray{S,N}) where {T,S,N} =
+    all(f -> isequal(getfield(x, f), getfield(y, f)), fieldnames(TimeArray))
+
+# support for Dict
+hash(x::TimeArray, h::UInt) =
+    sum(f -> hash(getfield(x, f), h), fieldnames(TimeArray))
+
 ###### show #####################
 
 @inline _showval(v::Any) = repr(v)

test/timearray.jl

@@ -240,6 +240,57 @@ end
 end
 
 
+@testset "equal" begin
+    @test cl == copy(cl)
+    @test cl ≠ ohlc  # rely on fallback definition
+    @test cl ≠ lag(cl)
+
+    @test isequal(cl, copy(cl))
+    @test !isequal(cl, ohlc)
+    @test !isequal(cl, lag(cl))
+
+    ds = DateTime(2017, 12, 25):DateTime(2017, 12, 31) |> collect
+
+    let  # diff colnames
+        x = TimeArray(ds, 1:7, ["foo"])
+        y = TimeArray(ds, 1:7, ["bar"])
+        @test x != y
+    end
+
+    let  # Float vs Int
+        x = TimeArray(ds, 1:7)
+        y = TimeArray(ds, 1.0:7)
+        @test x == y
+    end
+
+    let  # Date vs DateTime
+        ds2 = Date(2017, 12, 25):Date(2017, 12, 31) |> collect
+        x = TimeArray(ds,  1:7, ["foo"], "bar")
+        y = TimeArray(ds2, 1:7, ["foo"], "bar")
+        @test x == y
+    end
+
+    let  # diff meta
+        x = TimeArray(ds, 1:7, ["foo"], "bar")
+        y = TimeArray(ds, 1:7, ["foo"], "baz")
+        @test x != y
+    end
+
+    @testset "hash" begin
+        @test hash(cl)   == hash(copy(cl))
+        @test hash(ohlc) == hash(copy(ohlc))
+
+        d = Dict(cl => 42)
+        @test d[cl] == 42
+        @test d[copy(cl)] == 42
+
+        d = Dict(ohlc => 24)
+        @test d[ohlc] == 24
+        @test d[copy(ohlc)] == 24
+    end
+end
+
+
 @testset "show methods don't throw errors" begin
     let str = sprint(show, cl)
         out = """500x1 TimeSeries.TimeArray{Float64,1,Date,Array{Float64,1}} 2000-01-03 to 2001-12-31