Definition of `==` for NullableArray doesn't seem to work

[quinnj]

My guess is we're relying on some AbstractArray behavior, but the fact that we return Nullable{Bool} instead of Bool is throwing something off. To be clear, I'm not advocating for not returning Nullable{Bool}, I think we may just need to define our own == or something where the semantics of Nullable{Bool} vs. Bool are currently breaking things.

julia> a = NullableArrays.NullableArray([1])
1-element NullableArrays.NullableArray{Int64,1}:
 1

julia> b = NullableArrays.NullableArray([1])
1-element NullableArrays.NullableArray{Int64,1}:
 1

julia> a == b
ERROR: TypeError: non-boolean (Nullable{Bool}) used in boolean context
 in == at abstractarray.jl:1041

julia>

[nalimilan]

Good catch. Unfortunately, the only way to fix this everywhere would be to allow Nullable{Bool} in if (JuliaLang/julia#13207). Without it, we need to override ==. I've made a proposal in #84.

(See also #74)

[nalimilan]

There's also the question of what to do with comparisons between NullableArrays and other arrays:

julia> [1,2,3] == NullableArray([1,2,3])
false

This comes from the fact that Nullable(1) == 1 is false. If ==(::Nullable, x) returned a Nullable{Bool}, we would get an error, and require a special function just like the one I proposed above.

[nalimilan]

I've updated the PR with support for ==(::NullableArray, ::AbstractArray). This is the logical complement of #85.

[davidagold]

FWIW I've been using isequal for this sort of functionality:

julia> X = NullableArray([1])
1-element NullableArray{Int64,1}:
 1

julia> Y = NullableArray([1])
1-element NullableArray{Int64,1}:
 1

julia> isequal(X, Y)
true

[andyferris]

I just came across the == problem.

This comes from the fact that Nullable(1) == 1

At first glance that seems insane to me. Don't we have different things like == and isequal to avoid these issues?

[davidagold]

julia> using NullableArrays

julia> Nullable(1) == 1
false

What exactly are you referring to?

[andyferris]

Well, we have 1.0 == 1 as true and many many other examples. == is meant to be the "handwavey", and "its close enough in meaning" (not implementation) type of equality. For an example of different implementations, Diagonal([1,2,3]) == diagm([1,2,3]).

This is different to is/===, and isequal which are more about being implemented the same. My interpretation of Nullable is to formalize the idea of NaN to arbitrary types, just like NA did. But maybe I have the premise incorrect?

[davidagold]

I'm just confused because the quote you provided doesn't seem to be true. Are you saying it's insane that Nullable(1) == 1, in which case I would respond "that would be insane, but it's not true", or are you saying it's insane that it's not the case that Nullable(1) == 1, in which case I'd respond that I think that's actually appropriate.

[nalimilan]

I think he meant the latter. Cf #85.