Fix broadcast on master and some deprecations

REQUIRE

@@ -1,4 +1,4 @@
 julia 0.4
 StatsBase 0.3
-Compat 0.8.6
+Compat 0.9.3
 Reexport

src/broadcast.jl

@@ -1,12 +1,16 @@
 using DataArrays
 using Base: @get!, promote_eltype
-using Base.Broadcast: bitcache_chunks, bitcache_size, dumpbitcache, broadcast_shape
+using Base.Broadcast: bitcache_chunks, bitcache_size, dumpbitcache
 using Compat: promote_eltype_op
 
 if isdefined(Base, :OneTo)
-    _broadcast_shape(x...) = Base.to_shape(broadcast_shape(x...))
+    if VERSION < v"0.6.0-dev.1121"
+        _broadcast_shape(x...) = Base.to_shape(Base.Broadcast.broadcast_shape(x...))
+    else
+        _broadcast_shape(x...) = Base.to_shape(Base.Broadcast.broadcast_indices(x...))
+    end
 else
-    const _broadcast_shape = broadcast_shape
+    const _broadcast_shape = Base.Broadcast.broadcast_shape
 end
 
 # Check that all arguments are broadcast compatible with shape

src/dataarray.jl

@@ -511,7 +511,7 @@ allna(da::DataArray) = all(da.na) # -> Bool
 #' da = @data([1, 2, 3])
 #' isnan(da)
 function Base.isnan(da::DataArray) # -> DataArray{Bool}
-    return DataArray(isnan(da.data), copy(da.na))
+    return @compat DataArray(isnan.(da.data), copy(da.na))
 end
 
 #' @description

src/reduce.jl

@@ -96,10 +96,10 @@ function Base._mapreduce(f::SafeMapFuns, op::SafeReduceFuns, A::DataArray)
 end
 
 function Base.mapreduce(f, op::Function, A::DataArray; skipna::Bool=false)
-    is(op, +) ? (skipna ? _mapreduce_skipna(f, @functorize(+), A) : Base._mapreduce(f, @functorize(+), A)) :
-    is(op, *) ? (skipna ? _mapreduce_skipna(f, @functorize(*), A) : Base._mapreduce(f, @functorize(*), A)) :
-    is(op, &) ? (skipna ? _mapreduce_skipna(f, @functorize(&), A) : Base._mapreduce(f, @functorize(&), A)) :
-    is(op, |) ? (skipna ? _mapreduce_skipna(f, @functorize(|), A) : Base._mapreduce(f, @functorize(|), A)) :
+    (op === +) ? (skipna ? _mapreduce_skipna(f, @functorize(+), A) : Base._mapreduce(f, @functorize(+), A)) :
+    (op === *) ? (skipna ? _mapreduce_skipna(f, @functorize(*), A) : Base._mapreduce(f, @functorize(*), A)) :
+    (op === &) ? (skipna ? _mapreduce_skipna(f, @functorize(&), A) : Base._mapreduce(f, @functorize(&), A)) :
+    (op === |) ? (skipna ? _mapreduce_skipna(f, @functorize(|), A) : Base._mapreduce(f, @functorize(|), A)) :
     skipna ? _mapreduce_skipna(f, op, A) : Base._mapreduce(f, op, A)
 end
 

src/reducedim.jl

@@ -263,19 +263,27 @@ if VERSION < v"0.5.0-dev+3701"
 end
 
 function Base.reducedim_initarray{R}(A::DataArray, region, v0, ::Type{R})
-    rd = Base.reduced_dims(A.data, region)
+    if VERSION < v"0.6.0-dev.1121"
+        rd = Base.reduced_dims(A.data, region)
+    else
+        rd = length.(Base.reduced_indices(A.data, region))
+    end
     DataArray(fill!(similar(A.data, R, rd), v0), falses(rd))
 end
 function Base.reducedim_initarray0{R}(A::DataArray, region, v0, ::Type{R})
-    rd = Base.reduced_dims0(A,region)
+    if VERSION < v"0.6.0-dev.1121"
+        rd = Base.reduced_dims0(A,region)
+    else
+        rd = length.(Base.reduced_indices0(A,region))
+    end
     DataArray(fill!(similar(A.data, R, rd), v0), falses(rd))
 end
 
 function Base.mapreducedim!(f::Function, op, R::AbstractArray, A::DataArray; skipna::Bool=false)
-    is(op, +) ? (skipna ? _mapreducedim_skipna!(f, @functorize(+), R, A) : _mapreducedim!(f, @functorize(+), R, A)) :
-    is(op, *) ? (skipna ? _mapreducedim_skipna!(f, @functorize(*), R, A) : _mapreducedim!(f, @functorize(*), R, A)) :
-    is(op, &) ? (skipna ? _mapreducedim_skipna!(f, @functorize(&), R, A) : _mapreducedim!(f, @functorize(&), R, A)) :
-    is(op, |) ? (skipna ? _mapreducedim_skipna!(f, @functorize(|), R, A) : _mapreducedim!(f, @functorize(|), R, A)) :
+    (op === +) ? (skipna ? _mapreducedim_skipna!(f, @functorize(+), R, A) : _mapreducedim!(f, @functorize(+), R, A)) :
+    (op === *) ? (skipna ? _mapreducedim_skipna!(f, @functorize(*), R, A) : _mapreducedim!(f, @functorize(*), R, A)) :
+    (op === &) ? (skipna ? _mapreducedim_skipna!(f, @functorize(&), R, A) : _mapreducedim!(f, @functorize(&), R, A)) :
+    (op === |) ? (skipna ? _mapreducedim_skipna!(f, @functorize(|), R, A) : _mapreducedim!(f, @functorize(|), R, A)) :
     skipna ? _mapreducedim_skipna!(f, op, R, A) : _mapreducedim!(f, op, R, A)
 end
 Base.mapreducedim!(f, op, R::AbstractArray, A::DataArray; skipna::Bool=false) =
@@ -538,7 +546,11 @@ function Base.var{T}(A::DataArray{T}, region::(@compat Union{Integer, AbstractAr
     elseif mean == nothing
         if skipna
             # Can reduce mean into ordinary array
-            m = zeros(Base.momenttype(T), Base.reduced_dims(A, region))
+            if VERSION < v"0.6.0-dev.1121"
+                m = zeros(Base.momenttype(T), Base.reduced_dims(A, region))
+            else
+                m = zeros(Base.momenttype(T), length.(Base.reduced_indices(A, region)))
+            end
             Base.varm(A, Base.mean!(m, A; skipna=skipna), region;
                  corrected=corrected, skipna=skipna)
         else

test/reducedim.jl

@@ -127,7 +127,11 @@ for Areduc in (DataArray(rand(3, 4, 5, 6)),
             (1, 2, 3), (1, 3, 4), (2, 3, 4), (1, 2, 3, 4)]
             # println("region = $region, skipna = $skipna")
 
-            outputs = Any[DataArray(fill(NaN, Base.reduced_dims(size(Areduc), region)))]
+            if VERSION < v"0.6-"
+                outputs = Any[DataArray(fill(NaN, Base.reduced_dims(size(Areduc), region)))]
+            else
+                outputs = Any[DataArray(fill(NaN, length.(Base.reduced_indices(indices(Areduc), region))))]
+            end
             has_na = anyna(Areduc)
             if has_na && !skipna
                 # Should throw an error reducing to non-DataArray