0.6 fixes (#171)

* Do not define element-wise operators in Julia 0.6

These go though broadcast() now.

* Make constructor more generic

This allows accepting BitArrays, which are more frequently returned
by broadcast() now.

* Fix deprecations

src/broadcast.jl

@@ -204,15 +204,17 @@ implementation of `broadcast` in `base/broadcast.jl`.
 end
 
 # broadcasted ops
-for (op, scalar_op) in (
-    (:(@compat Base.:(.==)), :(==)),
-    (:(@compat Base.:.!=), :!=),
-    (:(@compat Base.:.<), :<),
-    (:(@compat Base.:.>), :>),
-    (:(@compat Base.:.<=), :<=),
-    (:(@compat Base.:.>=), :>=)
-)
-    @eval begin
-        ($op)(X::NullableArray, Y::NullableArray) = broadcast($scalar_op, X, Y)
+if VERSION < v"0.6.0-dev.1632"
+    for (op, scalar_op) in (
+        (:(@compat Base.:(.==)), :(==)),
+        (:(@compat Base.:.!=), :!=),
+        (:(@compat Base.:.<), :<),
+        (:(@compat Base.:.>), :>),
+        (:(@compat Base.:.<=), :<=),
+        (:(@compat Base.:.>=), :>=)
+    )
+        @eval begin
+            ($op)(X::NullableArray, Y::NullableArray) = broadcast($scalar_op, X, Y)
+        end
     end
 end

src/constructors.jl

@@ -3,9 +3,9 @@
 
 # The following provides an outer constructor whose argument signature matches
 # that of the inner constructor provided in typedefs.jl: constructs a NullableArray
-# from an Array of values and an Array{Bool} mask.
+# from an AbstractArray of values and an AbstractArray{Bool} mask.
 function NullableArray{T, N}(A::AbstractArray{T, N},
-                             m::Array{Bool, N}) # -> NullableArray{T, N}
+                             m::AbstractArray{Bool, N}) # -> NullableArray{T, N}
     return NullableArray{T, N}(A, m)
 end
 

src/typedefs.jl

@@ -12,7 +12,6 @@
 # an exception for any other type.
 #
 # TODO: Ensure that size(values) == size(isnull) using inner constructor.
-# TODO: Implement outer constructor required once we add an inner constructor.
 """
 `NullableArray{T, N}` is an efficient alternative to `Array{Nullable{T}, N}`.
 It allows users to easily define operations on arrays with null values by
@@ -25,7 +24,7 @@ immutable NullableArray{T, N} <: AbstractArray{Nullable{T}, N}
     # (think mmapped file, for example) that `values` is actually derived from
     parent::Vector{UInt8}
 
-    function NullableArray(d::AbstractArray{T, N}, m::Array{Bool, N}, parent::Vector{UInt8}=Vector{UInt8}())
+    function NullableArray(d::AbstractArray{T, N}, m::AbstractArray{Bool, N}, parent::Vector{UInt8}=Vector{UInt8}())
         if size(d) != size(m)
             msg = "values and missingness arrays must be the same size"
             throw(ArgumentError(msg))

test/reduce.jl

@@ -24,13 +24,13 @@ module TestReduce
         @test isequal(mapreduce(f, +, X), Nullable(mapreduce(f, +, X.values)))
         @test isequal(mapreduce(f, +, Y), Nullable{Float64}())
         v = mapreduce(f, +, Y, skipnull=true)
-        @test_approx_eq v.value mapreduce(f, +, B)
+        @test v.value ≈ mapreduce(f, +, B)
         @test !isnull(v)
 
         @test isequal(reduce(+, X), Nullable(reduce(+, X.values)))
         @test isequal(reduce(+, Y), Nullable{Float64}())
         v = reduce(+, Y, skipnull=true)
-        @test_approx_eq v.value reduce(+, B)
+        @test v.value ≈ reduce(+, B)
         @test !isnull(v)
 
         for method in (
@@ -43,22 +43,11 @@ module TestReduce
             @test isequal(method(f, X), Nullable(method(f, A)))
             @test isequal(method(Y), Nullable{Float64}())
             v = method(Y, skipnull=true)
-            @test_approx_eq v.value method(B)
+            @test v.value ≈ method(B)
             @test !isnull(v)
             @test isequal(method(f, Y), Nullable{Float64}())
             v = method(f, Y, skipnull=true)
-            @test_approx_eq v.value method(f, B)
-            @test !isnull(v)
-        end
-
-        for method in (
-            sumabs,
-            sumabs2,
-        )
-            @test isequal(method(X), Nullable(method(A)))
-            @test isequal(method(Y), Nullable{Float64}())
-            v = method(Y, skipnull=true)
-            @test_approx_eq v.value method(B)
+            @test v.value ≈ method(f, B)
             @test !isnull(v)
         end