Use skipmissing() instead of Missings.skip()

The latter is deprecated.

Author: nalimilan

REQUIRE

@@ -1,5 +1,5 @@
 julia 0.6
-Missings
+Missings 0.2.1
 StatsBase 0.15.0
 Reexport
 SpecialFunctions

src/dataarray.jl

@@ -273,7 +273,7 @@ end
 struct EachDropMissing{T<:DataArray}
     da::T
 end
-Missings.skip(da::DataArray) = EachDropMissing(da)
+Missings.skipmissing(da::DataArray) = EachDropMissing(da)
 function _next_nonna_ind(da::DataArray, ind::Int)
     ind += 1
     @inbounds while ind <= length(da) && da.na[ind]

src/deprecated.jl

@@ -78,10 +78,10 @@ end
 @deprecate_binding NA missing
 @deprecate_binding NAException MissingException
 @deprecate isna ismissing
-@deprecate dropna(x) collect(Missings.skip(x))
+@deprecate dropna(x) collect(skipmissing(x))
 @deprecate padna padmissing
 @deprecate each_failna Missings.fail
-@deprecate each_dropna Missings.skip
+@deprecate each_dropna skipmissing
 @deprecate each_replacena Missings.replace
 @deprecate_binding EachFailNA DataArrays.EachFailMissing
 @deprecate_binding EachDropNA DataArrays.EachDropMissing

src/pooleddataarray.jl

@@ -375,7 +375,7 @@ function PooledDataArray(x::PooledDataArray{S,R,N},
 end
 
 myunique(x::AbstractVector) = unique(x)
-myunique(x::AbstractDataVector) = unique(Missings.skip(x))
+myunique(x::AbstractDataVector) = unique(skipmissing(x))
 
 """
     setlevels(x::PooledDataArray, newpool::Union{AbstractVector, Dict})

src/statistics.jl

@@ -41,8 +41,8 @@ StatsBase.describe(X::DataVector) = StatsBase.describe(STDOUT, X)
 function StatsBase.describe(io::IO, X::AbstractDataVector{T}) where T<:Real
     nacount = sum(ismissing, X)
     pna = 100nacount/length(X)
-    if pna != 100 # describe will fail if Missings.skip returns an empty vector
-        describe(io, collect(Missings.skip(X)))
+    if pna != 100 # describe will fail if skipmissing returns an empty vector
+        describe(io, collect(skipmissing(X)))
     else
         println(io, "Summary Stats:")
         println(io, "Type:           $(T)")

test/data.jl

@@ -88,7 +88,7 @@
     # @test isequal(pdvstr .== "two", PooledDataVector[false, false, true, true, missing, false, false])
 
     #test_group("DataVector to something else")
-    @test collect(Missings.skip(dvint)) == [1, 2, 4]
+    @test collect(skipmissing(dvint)) == [1, 2, 4]
     @test all(convert(Vector, dvint, 0) .== [1, 2, 0, 4])
     @test all(convert(Vector, dvany, 0) .== [1, 2, 0, 4])
     utf8three = convert(String, "three")
@@ -103,19 +103,19 @@
                           "Union{Missings.Missing, $Int}[1, 2, missing, 4]")
 
     #test_group("PooledDataVector to something else")
-    @test collect(Missings.skip(pdvstr)) == ["one", "one", "two", "two", "one", "one"]
+    @test collect(skipmissing(pdvstr)) == ["one", "one", "two", "two", "one", "one"]
     @test all(convert(Vector, pdvstr, "nine") .== ["one", "one", "two", "two", "nine", "one", "one"])
     #@test all([length(i)::Int for i in pdvstr] .== [3, 3, 3, 3, 1, 3, 3])
     @test string(pdvstr[1:3]) == "[one, one, two]"
 
     #test_group("DataVector Filter and Replace")
-    @test collect(Missings.skip(dvint)) == [1, 2, 4]
+    @test collect(skipmissing(dvint)) == [1, 2, 4]
     @test isequal(convert(Vector, dvint, 7), [1, 2, 7, 4])
-    @test sum(Missings.skip(dvint)) == 7
+    @test sum(skipmissing(dvint)) == 7
     @test sum(convert(Vector, dvint, 7)) == 14
 
     #test_group("PooledDataVector Filter and Replace")
-    @test reduce(string, "", Missings.skip(pdvstr)) == "oneonetwotwooneone"
+    @test reduce(string, "", skipmissing(pdvstr)) == "oneonetwotwooneone"
     @test reduce(string, "", convert(Vector, pdvstr, "!")) == "oneonetwotwo!oneone"
 
     #test_group("DataVector assignment")

test/dataarray.jl

@@ -44,8 +44,8 @@
     x = @data [1, missing, -2, 1, missing, 4]
     @test isequal(unique(x), @data [1, missing, -2, 4])
     @test isequal(unique(reverse(x)), @data [4, missing, 1, -2])
-    @test isequal(unique(Missings.skip(x)), @data [1, -2, 4])
-    @test isequal(unique(reverse(collect(Missings.skip(x)))), @data [4, 1, -2])
+    @test isequal(unique(skipmissing(x)), @data [1, -2, 4])
+    @test isequal(unique(reverse(collect(skipmissing(x)))), @data [4, 1, -2])
     @test isequal(levels(x), @data [1, -2, 4])
     @test isequal(levels(reverse(x)), @data [4, 1, -2])
 

test/nas.jl

@@ -53,7 +53,7 @@
     dv = DataArray(collect(1:6), fill(false, 6))
     a = dv[.!ismissing.(dv)]
     @test collect(Missings.fail(dv)) == a
-    @test collect(Missings.skip(dv)) == a
+    @test collect(skipmissing(dv)) == a
     @test collect(Missings.replace(dv, 4)) == a
 
     dv[[1, 2, end]] = missing
@@ -69,7 +69,7 @@
 
     a = dv[.!ismissing.(dv)]
     @test_throws MissingException for v in Missings.fail(dv); end
-    @test collect(Missings.skip(dv)) == a
+    @test collect(skipmissing(dv)) == a
     @test collect(Missings.replace(dv, 4)) == [4, 4, a..., 4]
 
 end

test/newtests/dataarray.jl

@@ -119,9 +119,9 @@ module TestDataArrays
     convert(Vector, DataArray([1, 0, 3], [false, true, false]), -1)
     convert(Vector, DataArray([1, 2, 3], [false, false, false]), -1)
 
-    # Missings.skip(da::DataArray)
-    Missings.skip(DataArray([1, 0, 3], [false, true, false]))
-    Missings.skip(DataArray([1, 2, 3], [false, false, false]))
+    # skipmissing(da::DataArray)
+    skipmissing(DataArray([1, 0, 3], [false, true, false]))
+    skipmissing(DataArray([1, 2, 3], [false, false, false]))
 
     # Iterators
 

test/pooleddataarray.jl

@@ -3,14 +3,14 @@
     pcopy = copy(p)
     @test levels(p) == [1, 8, 9]
     @test levels(setlevels(p, ["a", "b", "c"])) == ["a", "b", "c"]
-    @test collect(Missings.skip(setlevels(p, (@data ["a", "b", missing])))) == ["b", "a", "a"]
-    @test collect(Missings.skip(setlevels(p, (@data ["a", "b", "a"])))) == ["a", "a", "b", "a", "a"]
+    @test collect(skipmissing(setlevels(p, (@data ["a", "b", missing])))) == ["b", "a", "a"]
+    @test collect(skipmissing(setlevels(p, (@data ["a", "b", "a"])))) == ["a", "a", "b", "a", "a"]
     @test levels(setlevels(p, (@data ["a", "b", "a"]))) == ["a", "b"]
     @test levels(setlevels(p, Dict([(1, 111)]))) == [111, 8, 9]
     @test levels(setlevels(p, Dict([(1, 111), (8, missing)]))) == [111, 9]
     @test levels(PooledDataArray(p, [9, 8, 1])) == [9, 8, 1]
     @test levels(PooledDataArray(p, [9, 8])) == [9, 8]
-    @test collect(Missings.skip(PooledDataArray(p, [9, 8]))) == [9, 9, 8]
+    @test collect(skipmissing(PooledDataArray(p, [9, 8]))) == [9, 9, 8]
     @test levels(PooledDataArray(p, levels(p)[[3,2,1]])) == [9,8,1]
     v = collect(1:6)
     @test isequal(p, reorder(p))
@@ -29,14 +29,14 @@
     y = @pdata [1, missing, -2, 1, missing, 4, missing]
     @test isequal(unique(y), @pdata [1, missing, -2, 4])
     @test isequal(unique(reverse(y)), @data [missing, 4, 1, -2])
-    @test isequal(unique(Missings.skip(y)), @data [1, -2, 4])
-    @test isequal(unique(reverse(collect(Missings.skip(y)))), @data [4, 1, -2])
+    @test isequal(unique(skipmissing(y)), @data [1, -2, 4])
+    @test isequal(unique(reverse(collect(skipmissing(y)))), @data [4, 1, -2])
 
     z = @pdata ["frank", missing, "gertrude", "frank", missing, "herbert", missing]
     @test isequal(unique(z), @pdata ["frank", missing, "gertrude", "herbert"])
     @test isequal(unique(reverse(z)), @pdata [missing, "herbert", "frank", "gertrude"])
-    @test isequal(unique(Missings.skip(z)), @pdata ["frank", "gertrude", "herbert"])
-    @test isequal(unique(reverse(collect(Missings.skip(z)))), @pdata ["herbert", "frank", "gertrude"])
+    @test isequal(unique(skipmissing(z)), @pdata ["frank", "gertrude", "herbert"])
+    @test isequal(unique(reverse(collect(skipmissing(z)))), @pdata ["herbert", "frank", "gertrude"])
 
     # check case where only missing occurs in final position
     @test isequal(unique(@pdata [1, 2, 1, missing]), @pdata [1, 2, missing])

test/reduce.jl

@@ -60,20 +60,20 @@ end
         da2 = copy(da)
         da2[1:2:end] = missing
         @test ismissing(sum(da2))
-        @test sum(da2; skipmissing=true) ≈ sum(Missings.skip(da2))
+        @test sum(da2; skipmissing=true) ≈ sum(skipmissing(da2))
 
         da2 = convert(DataArray{BigFloat}, da2)
         @test ismissing(sum(da2))
-        @test sum(da2; skipmissing=true) ≈ sum(Missings.skip(da2))
+        @test sum(da2; skipmissing=true) ≈ sum(skipmissing(da2))
 
         da2 = copy(da)
         da2[2:2:end] = missing
         @test ismissing(sum(da2))
-        @test sum(da2; skipmissing=true) ≈ sum(Missings.skip(da2))
+        @test sum(da2; skipmissing=true) ≈ sum(skipmissing(da2))
 
         da2 = convert(DataArray{BigFloat}, da2)
         @test ismissing(sum(da2))
-        @test sum(da2; skipmissing=true) ≈ sum(Missings.skip(da2))
+        @test sum(da2; skipmissing=true) ≈ sum(skipmissing(da2))
     end
 
     ## other reductions
@@ -96,20 +96,20 @@ end
             da2 = copy(da)
             da2[1:2:end] = missing
             n > 0 && @test ismissing(fn(da2))
-            @same_behavior fn(da2; skipmissing=true) fn(Missings.skip(da2))
+            @same_behavior fn(da2; skipmissing=true) fn(skipmissing(da2))
 
             da2 = convert(DataArray{BigFloat}, da2)
             n > 0 && @test ismissing(fn(da2))
-            @same_behavior fn(da2; skipmissing=true) fn(Missings.skip(da2))
+            @same_behavior fn(da2; skipmissing=true) fn(skipmissing(da2))
 
             da2 = copy(da)
             da2[2:2:end] = missing
             n > 1 && @test ismissing(fn(da2))
-            @same_behavior fn(da2; skipmissing=true) fn(Missings.skip(da2))
+            @same_behavior fn(da2; skipmissing=true) fn(skipmissing(da2))
 
             da2 = convert(DataArray{BigFloat}, da2)
             n > 1 && @test ismissing(fn(da2))
-            @same_behavior fn(da2; skipmissing=true) fn(Missings.skip(da2))
+            @same_behavior fn(da2; skipmissing=true) fn(skipmissing(da2))
         end
     end
 
@@ -140,8 +140,8 @@ end
     @same_behavior mean(da1, weights(da2.data); skipmissing=true) mean(da1.data, weights(da2.data))
 
     da1[1:3:end] = missing
-    @same_behavior mean(da1, weights(da2); skipmissing=true) mean(Missings.skip(da1), weights(da2.data[(!).(da1.na)]))
-    @same_behavior mean(da1, weights(da2.data); skipmissing=true) mean(Missings.skip(da1), weights(da2.data[(!).(da1.na)]))
+    @same_behavior mean(da1, weights(da2); skipmissing=true) mean(skipmissing(da1), weights(da2.data[(!).(da1.na)]))
+    @same_behavior mean(da1, weights(da2.data); skipmissing=true) mean(skipmissing(da1), weights(da2.data[(!).(da1.na)]))
 
     da2[1:2:end] = missing
     keep = .!da1.na .& .!da2.na

test/sort.jl

@@ -17,11 +17,11 @@
         ra = randn(n-nna)
         a[.!na] = ra
         for da in (DataArray(a, na), PooledDataArray(a, na), (pda = PooledDataArray(a, na); setlevels!(pda, shuffle!(pda.pool))))
-            @test isequal(sort(da), [DataArray(sort!(collect(Missings.skip(da)))); DataArray(T, nna)])
-            @test isequal(sort(da; lt=(x,y)->isless(x,y)), [DataArray(sort!(collect(Missings.skip(da)))); DataArray(T, nna)])
-            @test isequal(da[sortperm(da)], [DataArray(sort!(collect(Missings.skip(da)))); DataArray(T, nna)])
-            @test isequal(sort(da, rev=true), [DataArray(T, nna); DataArray(sort!(collect(Missings.skip(da)), rev=true))])
-            @test isequal(da[sortperm(da, rev=true)], [DataArray(T, nna); DataArray(sort!(collect(Missings.skip(da)), rev=true))])
+            @test isequal(sort(da), [DataArray(sort!(collect(skipmissing(da)))); DataArray(T, nna)])
+            @test isequal(sort(da; lt=(x,y)->isless(x,y)), [DataArray(sort!(collect(skipmissing(da)))); DataArray(T, nna)])
+            @test isequal(da[sortperm(da)], [DataArray(sort!(collect(skipmissing(da)))); DataArray(T, nna)])
+            @test isequal(sort(da, rev=true), [DataArray(T, nna); DataArray(sort!(collect(skipmissing(da)), rev=true))])
+            @test isequal(da[sortperm(da, rev=true)], [DataArray(T, nna); DataArray(sort!(collect(skipmissing(da)), rev=true))])
         end
     end
 end