Full 0.5/0.4 compat + fix failing tests (#113)

* Updates for 0.5 and get tests passing

* Do the 0.5 updates in a compat friendly way

* Add 0.4 compat for the sum_pairwise_blocksize removal from Base

* Quick update to constructors test

Author: quinnj

src/broadcast.jl

@@ -4,8 +4,8 @@ using Base.Broadcast: check_broadcast_shape
 function gen_nullcheck(narrays::Int, nd::Int)
     e_nullcheck = macroexpand(:( @nref $nd isnull_1 d->j_d_1 ))
     for k = 2:narrays
-        isnull = symbol("isnull_$k")
-        j_d_k = symbol("j_d_$k")
+        isnull = Symbol("isnull_$k")
+        j_d_k = Symbol("j_d_$k")
         e_isnull_k = macroexpand(:( @nref $nd $(isnull) d->$(j_d_k) ))
         e_nullcheck = Expr(:||, e_nullcheck, e_isnull_k)
     end
@@ -43,7 +43,7 @@ function gen_broadcast_body(nd::Int, narrays::Int, f, lift::Bool)
 end
 
 function gen_broadcast_function(nd::Int, narrays::Int, f, lift::Bool)
-    As = [symbol("A_"*string(i)) for i = 1:narrays]
+    As = [Symbol("A_"*string(i)) for i = 1:narrays]
     body = gen_broadcast_body(nd, narrays, f, lift)
     @eval let
         local _F_
@@ -104,12 +104,12 @@ end
 
 # broadcasted ops
 for (op, scalar_op) in (
-    (:(Base.(:(.==))), :(==)),
-    (:(Base.(:.!=)), :!=),
-    (:(Base.(:.<)), :<),
-    (:(Base.(:.>)), :>),
-    (:(Base.(:.<=)), :<=),
-    (:(Base.(:.>=)), :>=)
+    (:(@compat Base.:(.==)), :(==)),
+    (:(@compat Base.:.!=), :!=),
+    (:(@compat Base.:.<), :<),
+    (:(@compat Base.:.>), :>),
+    (:(@compat Base.:.<=), :<=),
+    (:(@compat Base.:.>=), :>=)
 )
     @eval begin
         ($op)(X::NullableArray, Y::NullableArray) = broadcast($scalar_op, X, Y)

src/map.jl

@@ -1,7 +1,7 @@
 using Base.Cartesian
 
 function gen_nullcheck(narrays::Int)
-    As = [symbol("A_"*string(i)) for i = 1:narrays]
+    As = [Symbol("A_"*string(i)) for i = 1:narrays]
     e_nullcheck = :($(As[1]).isnull[i])
     for i = 2:narrays
         e_nullcheck = Expr(:||, e_nullcheck, :($(As[i]).isnull[i]))
@@ -99,7 +99,7 @@ function gen_map_body{F}(_map_to!::Symbol, narrays::Int, f::F)
 end
 
 function gen_map!_function{F}(narrays::Int, lift::Bool, f::F)
-    As = [symbol("A_"*string(i)) for i = 1:narrays]
+    As = [Symbol("A_"*string(i)) for i = 1:narrays]
     body = gen_map!_body(narrays, lift, f)
     @eval let
         local _F_
@@ -111,7 +111,7 @@ function gen_map!_function{F}(narrays::Int, lift::Bool, f::F)
 end
 
 function gen_map_function{F}(_map_to!::Symbol, narrays::Int, f::F)
-    As = [symbol("A_"*string(i)) for i = 1:narrays]
+    As = [Symbol("A_"*string(i)) for i = 1:narrays]
     body_map_to! = gen_map_to!_body(_map_to!, narrays, f)
     body_map = gen_map_body(_map_to!, narrays, f)
 

src/operators.jl

@@ -3,10 +3,10 @@ import Compat: @functorize
 @noinline throw_error() = error()
 
 for f in (
-    :(Base.(:+)),
-    :(Base.(:-)),
-    :(Base.(:!)),
-    :(Base.(:~)),
+    :(@compat Base.:+),
+    :(@compat Base.:-),
+    :(@compat Base.:!),
+    :(@compat Base.:~),
 )
     @eval begin
         @inline function $(f){S}(x::Nullable{S})
@@ -21,16 +21,16 @@ end
 
 # Implement the binary operators: +, -, *, /, %, &, |, ^, <<, and >>
 for f in (
-    :(Base.(:+)),
-    :(Base.(:-)),
-    :(Base.(:*)),
-    :(Base.(:/)),
-    :(Base.(:%)),
-    :(Base.(:&)),
-    :(Base.(:|)),
-    :(Base.(:^)),
-    :(Base.(:<<)),
-    :(Base.(:>>)),
+    :(@compat Base.:+),
+    :(@compat Base.:-),
+    :(@compat Base.:*),
+    :(@compat Base.:/),
+    :(@compat Base.:%),
+    :(@compat Base.:&),
+    :(@compat Base.:|),
+    :(@compat Base.:^),
+    :(@compat Base.:<<),
+    :(@compat Base.:>>),
 )
     @eval begin
         @inline function $(f){S1, S2}(x::Nullable{S1}, y::Nullable{S2})
@@ -45,8 +45,8 @@ end
 
 # Implement the binary operators: == and !=
 for f in (
-    :(Base.(:(==))),
-    :(Base.(:!=)),
+    :(@compat Base.:(==)),
+    :(@compat Base.:!=),
 )
     @eval begin
         function $(f){S1, S2}(x::Nullable{S1}, y::Nullable{S2})
@@ -61,10 +61,10 @@ end
 
 # Implement the binary operators: <, >, <=, and >=
 for f in (
-    :(Base.(:<)),
-    :(Base.(:>)),
-    :(Base.(:<=)),
-    :(Base.(:>=)),
+    :(@compat Base.:<),
+    :(@compat Base.:>),
+    :(@compat Base.:<=),
+    :(@compat Base.:>=),
 )
     @eval begin
         function $(f){S1, S2}(x::Nullable{S1}, y::Nullable{S2})
@@ -119,4 +119,3 @@ end
         error()
     end
 end
-

src/reduce.jl

@@ -55,11 +55,18 @@ function mapreduce_pairwise_impl_skipnull{T}(f, op, X::NullableArray{T},
     end
 end
 
+# from comment: https://github.com/JuliaLang/julia/pull/16217#issuecomment-223768129
+if VERSION < v"0.5.0-dev+4441"
+    sum_pairwise_blocksize = Base.sum_pairwise_blocksize
+else
+    sum_pairwise_blocksize(T) = Base.pairwise_blocksize(T, +)
+end
+
 mapreduce_impl_skipnull{T}(f, op, X::NullableArray{T}) =
     mapreduce_seq_impl_skipnull(f, op, X, 1, length(X.values))
 mapreduce_impl_skipnull(f, op::typeof(@functorize(+)), X::NullableArray) =
     mapreduce_pairwise_impl_skipnull(f, op, X, 1, length(X.values),
-                                   max(128, Base.sum_pairwise_blocksize(f)))
+                                   max(128, sum_pairwise_blocksize(f)))
 
 # general mapreduce interface
 

test/constructors.jl

@@ -60,7 +60,7 @@ module TestConstructors
     @test isa(Z, NullableVector{Int})
     @test Z.isnull == [false, true, false, false, false, false, true]
 
-    Y = NullableArray([1, "na", 2, 3, 4, 5, "na"], Int, ASCIIString)
+    Y = NullableArray([1, nothing, 2, 3, 4, 5, nothing], Int, Void)
     @test isequal(Y, Z)
 
     # test parameterized type constructor with no arguments