From 596fcb6bd59d42dd296fc1fd2ee2c29de8a8c93d Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Sat, 30 Apr 2016 18:49:51 +0200 Subject: [PATCH] Fix functor-related deprecation warnings on Julia 0.5 Also move mapreduce(::Any, ::Union{typeof(&), typeof(|)}, ::NullableArray, ...) before the more general method to avoid ambiguity warning. --- REQUIRE | 2 +- perf/reduce.jl | 51 +++++++++++++++++++------------------ src/operators.jl | 5 ++-- src/reduce.jl | 66 ++++++++++++++++++++++++++++-------------------- 4 files changed, 68 insertions(+), 56 deletions(-) diff --git a/REQUIRE b/REQUIRE index 0fb4b71..73e2302 100644 --- a/REQUIRE +++ b/REQUIRE @@ -1,3 +1,3 @@ julia 0.4- -Compat +Compat 0.7.14 Reexport diff --git a/perf/reduce.jl b/perf/reduce.jl index 547d0cd..b27169c 100644 --- a/perf/reduce.jl +++ b/perf/reduce.jl @@ -1,5 +1,6 @@ using NullableArrays using DataArrays +import Compat: @functorize srand(1) A = rand(5_000_000) @@ -226,68 +227,68 @@ end function profile_skip(skip::Bool) println("Comparison of skipnull/skipNA methods") println() - println("f := IdFun(), op := AddFun()") + println("f := identity, op := +") println("mapreduce(f, op, X; skipnull/skipNA=$skip) (0 missing entries)") - mapreduce(Base.IdFun(), Base.AddFun(), X, skipnull=skip) + mapreduce(@functorize(identity), @functorize(+), X, skipnull=skip) print(" for NullableArray{Float64}: ") - @time(mapreduce(Base.IdFun(), Base.AddFun(), X, skipnull=skip)) + @time(mapreduce(@functorize(identity), @functorize(+), X, skipnull=skip)) - mapreduce(Base.IdFun(), Base.AddFun(), D, skipna=skip) + mapreduce(@functorize(identity), @functorize(+), D, skipna=skip) print(" for DataArray{Float64}: ") - @time(mapreduce(Base.IdFun(), Base.AddFun(), D, skipna=skip)) + @time(mapreduce(@functorize(identity), @functorize(+), D, skipna=skip)) println() println("reduce(op, X; skipnull/skipNA=$skip) (0 missing entries)") - reduce(Base.AddFun(), X, skipnull=skip) + reduce(@functorize(+), X, skipnull=skip) print(" for NullableArray{Float64}: ") - @time(reduce(Base.AddFun(), X, skipnull=skip)) + @time(reduce(@functorize(+), X, skipnull=skip)) - reduce(Base.AddFun(), D, skipna=skip) + reduce(@functorize(+), D, skipna=skip) print(" for DataArray{Float64}: ") - @time(reduce(Base.AddFun(), D, skipna=skip)) + @time(reduce(@functorize(+), D, skipna=skip)) println() println("mapreduce(f, op, X; skipnull/skipNA=$skip) (~half missing entries)") - mapreduce(Base.IdFun(), Base.AddFun(), Y, skipnull=skip) + mapreduce(@functorize(identity), @functorize(+), Y, skipnull=skip) print(" for NullableArray{Float64}: ") - @time(mapreduce(Base.IdFun(), Base.AddFun(), Y, skipnull=skip)) + @time(mapreduce(@functorize(identity), @functorize(+), Y, skipnull=skip)) - mapreduce(Base.IdFun(), Base.AddFun(), E, skipna=skip) + mapreduce(@functorize(identity), @functorize(+), E, skipna=skip) print(" for DataArray{Float64}: ") - @time(mapreduce(Base.IdFun(), Base.AddFun(), E, skipna=skip)) + @time(mapreduce(@functorize(identity), @functorize(+), E, skipna=skip)) println() println("reduce(op, X; skipnull/skipNA=$skip) (~half missing entries)") - reduce(Base.AddFun(), Y, skipnull=skip) + reduce(@functorize(+), Y, skipnull=skip) print(" for NullableArray{Float64}: ") - @time(reduce(Base.AddFun(), Y, skipnull=skip)) + @time(reduce(@functorize(+), Y, skipnull=skip)) - reduce(Base.AddFun(), E, skipna=true) + reduce(@functorize(+), E, skipna=true) print(" for DataArray{Float64}: ") - @time(reduce(Base.AddFun(), E, skipna=true)) + @time(reduce(@functorize(+), E, skipna=true)) nothing end function profile_skip_impl() println("Comparison of internal skip methods:") println("mapreduce_impl_skipnull(f, op, X) (0 missing entries)") - NullableArrays.mapreduce_impl_skipnull(Base.IdFun(), Base.AddFun(), X) + NullableArrays.mapreduce_impl_skipnull(@functorize(identity), @functorize(+), X) print(" for NullableArray{Float64}: ") - @time(NullableArrays.mapreduce_impl_skipnull(Base.IdFun(), Base.AddFun(), X)) + @time(NullableArrays.mapreduce_impl_skipnull(@functorize(identity), @functorize(+), X)) - DataArrays.mapreduce_impl_skipna(Base.IdFun(), Base.AddFun(), D) + DataArrays.mapreduce_impl_skipna(@functorize(identity), @functorize(+), D) print(" for DataArray{Float64}: ") - @time(DataArrays.mapreduce_impl_skipna(Base.IdFun(), Base.AddFun(), D)) + @time(DataArrays.mapreduce_impl_skipna(@functorize(identity), @functorize(+), D)) println() println("mapreduce_impl_skipnull(f, op, X) (~half missing entries)") - NullableArrays.mapreduce_impl_skipnull(Base.IdFun(), Base.AddFun(), Y) + NullableArrays.mapreduce_impl_skipnull(@functorize(identity), @functorize(+), Y) print(" for NullableArray{Float64}: ") - @time(NullableArrays.mapreduce_impl_skipnull(Base.IdFun(), Base.AddFun(), Y)) + @time(NullableArrays.mapreduce_impl_skipnull(@functorize(identity), @functorize(+), Y)) - DataArrays.mapreduce_impl_skipna(Base.IdFun(), Base.AddFun(), E) + DataArrays.mapreduce_impl_skipna(@functorize(identity), @functorize(+), E) print(" for DataArray{Float64}: ") - @time(DataArrays.mapreduce_impl_skipna(Base.IdFun(), Base.AddFun(), E)) + @time(DataArrays.mapreduce_impl_skipna(@functorize(identity), @functorize(+), E)) nothing end diff --git a/src/operators.jl b/src/operators.jl index 47c0480..c874709 100644 --- a/src/operators.jl +++ b/src/operators.jl @@ -1,3 +1,4 @@ +import Compat: @functorize @noinline throw_error() = error() @@ -104,14 +105,14 @@ end ## Lifted functors -@compat function (::Base.MinFun){S1, S2}(x::Nullable{S1}, y::Nullable{S2}) +@compat function (::typeof(@functorize(scalarmin))){S1, S2}(x::Nullable{S1}, y::Nullable{S2}) if isbits(S1) & isbits(S2) return Nullable(Base.scalarmin(x.value, y.value), x.isnull | y.isnull) else error() end end -@compat function (::Base.MaxFun){S1, S2}(x::Nullable{S1}, y::Nullable{S2}) +@compat function (::typeof(@functorize(scalarmax))){S1, S2}(x::Nullable{S1}, y::Nullable{S2}) if isbits(S1) & isbits(S2) return Nullable(Base.scalarmax(x.value, y.value), x.isnull | y.isnull) else diff --git a/src/reduce.jl b/src/reduce.jl index 512055c..471fc5b 100644 --- a/src/reduce.jl +++ b/src/reduce.jl @@ -1,4 +1,5 @@ # interface for skipping null entries +import Compat: @functorize function skipnull_init(f, op, X::NullableArray, ifirst::Int, ilast::Int) @@ -56,7 +57,7 @@ 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::Base.AddFun, X::NullableArray) = +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))) @@ -79,6 +80,24 @@ function Base._mapreduce(f, op, X::NullableArray, missingdata) Nullable(Base._mapreduce(f, op, X.values)) end +# to fix ambiguity warnings +function Base.mapreduce(f, op::Union{typeof(@functorize(&)), typeof(@functorize(|))}, + X::NullableArray, skipnull::Bool = false) + missingdata = anynull(X) + if skipnull + return _mapreduce_skipnull(f, op, X, missingdata) + else + return Base._mapreduce(f, op, X, missingdata) + end +end + + +if VERSION >= v"0.5.0-dev+3701" + const specialized_binary = identity +else + const specialized_binary = Base.specialized_binary +end + @doc """ `mapreduce(f, op::Function, X::NullableArray; [skipnull::Bool=false])` @@ -93,21 +112,10 @@ function Base.mapreduce(f, op::Function, X::NullableArray; skipnull::Bool = false) missingdata = anynull(X) if skipnull - return _mapreduce_skipnull(f, Base.specialized_binary(op), + return _mapreduce_skipnull(f, specialized_binary(op), X, missingdata) else - return Base._mapreduce(f, Base.specialized_binary(op), X, missingdata) - end -end - -# to fix ambiguity warnings -function Base.mapreduce(f, op::Union{Base.AndFun, Base.OrFun}, X::NullableArray, - skipnull::Bool = false) - missingdata = anynull(X) - if skipnull - return _mapreduce_skipnull(f, op, X, missingdata) - else - return Base._mapreduce(f, op, X, missingdata) + return Base._mapreduce(f, specialized_binary(op), X, missingdata) end end @@ -131,42 +139,44 @@ over the elements of `X`. Note that, in general, mapreducing over a is set to `true` or `false`. """ -> Base.reduce(op, X::NullableArray; skipnull::Bool = false) = - mapreduce(Base.IdFun(), op, X; skipnull = skipnull) + mapreduce(@functorize(identity), op, X; skipnull = skipnull) # standard reductions -for (fn, op) in ((:(Base.sum), Base.AddFun()), - (:(Base.prod), Base.MulFun()), - (:(Base.minimum), Base.MinFun()), - (:(Base.maximum), Base.MaxFun())) +for (fn, op) in ((:(Base.sum), @functorize(+)), + (:(Base.prod), @functorize(*)), + (:(Base.minimum), @functorize(scalarmin)), + (:(Base.maximum), @functorize(scalarmax))) @eval begin - $fn(f::Union{Function,Base.Func{1}}, + # supertype(typeof(@functorize(abs))) returns Func{1} on Julia 0.4, + # and Function on 0.5 + $fn(f::Union{Function,supertype(typeof(@functorize(abs)))}, X::NullableArray; skipnull::Bool = false) = mapreduce(f, $op, X; skipnull = skipnull) $fn(X::NullableArray; skipnull::Bool = false) = - mapreduce(Base.IdFun(), $op, X; skipnull = skipnull) + mapreduce(@functorize(identity), $op, X; skipnull = skipnull) end end -for (fn, f, op) in ((:(Base.sumabs), Base.AbsFun(), Base.AddFun()), - (:(Base.sumabs2), Base.Abs2Fun(), Base.AddFun())) +for (fn, f, op) in ((:(Base.sumabs), @functorize(abs), @functorize(+)), + (:(Base.sumabs2), @functorize(abs2), @functorize(+))) @eval $fn(X::NullableArray; skipnull::Bool = false) = mapreduce($f, $op, X; skipnull=skipnull) end # internal methods for Base.minimum and Base.maximum -for Op in (:(Base.MinFun), :(Base.MaxFun)) +for op in (@functorize(scalarmin), @functorize(scalarmax)) @eval begin - function Base._mapreduce{T}(::Base.IdFun, ::$Op, + function Base._mapreduce{T}(::typeof(@functorize(identity)), ::$(typeof(op)), X::NullableArray{T}, missingdata) missingdata && return Nullable{T}() - Nullable(Base._mapreduce(Base.IdFun(), $Op(), X.values)) + Nullable(Base._mapreduce(@functorize(identity), $op, X.values)) end end end -function Base.mapreduce_impl{T}(f, op::Base.MinFun, X::NullableArray{T}, +function Base.mapreduce_impl{T}(f, op::typeof(@functorize(scalarmin)), X::NullableArray{T}, first::Int, last::Int) i = first v = f(X[i]) @@ -183,7 +193,7 @@ function Base.mapreduce_impl{T}(f, op::Base.MinFun, X::NullableArray{T}, return v end -function Base.mapreduce_impl{T}(f, op::Base.MaxFun, X::NullableArray{T}, +function Base.mapreduce_impl{T}(f, op::typeof(@functorize(scalarmax)), X::NullableArray{T}, first::Int, last::Int) i = first v = f(X[i])