Clean up code in the require block (#44)

* remove dispatch for string array

* use trait for permutable

* use fastpermute directly

* dispatch

Author: Pietro Vertechi

src/StructArrays.jl

@@ -14,11 +14,10 @@ include("lazy.jl")
 function __init__()
     Requires.@require Tables="bd369af6-aec1-5ad0-b16a-f7cc5008161c" include("tables.jl")
     Requires.@require PooledArrays="2dfb63ee-cc39-5dd5-95bd-886bf059d720" begin
-        ispooledarray(::PooledArrays.PooledArray) = true
+        fastpermute!(v::PooledArrays.PooledArray, p::AbstractVector) = permute!(v, p)
     end
     Requires.@require WeakRefStrings="ea10d353-3f73-51f8-a26c-33c1cb351aa5" begin
-        isstringarray(::WeakRefStrings.StringArray) = true
-        default_array(::Type{T}, d) where {T<:Union{AbstractString, Missing}} = WeakRefStrings.StringArray{T}(d)
+        fastpermute!(v::WeakRefStrings.StringArray, p::AbstractVector) = permute!(v, p)
     end
 end
 

src/collect.jl

@@ -1,5 +1,4 @@
 default_array(::Type{S}, d) where {S} = Array{S}(undef, d)
-default_array(::Type{Missing}, d) = Array{Missing}(undef, d)
 
 struct StructArrayInitializer{F, G}
     unwrap::F

src/sort.jl

@@ -1,16 +1,10 @@
 using Base.Sort, Base.Order
 
-isstringarray(::AbstractArray) = false
-ispooledarray(::AbstractArray) = false
-
-function Base.permute!(c::StructVector, p::AbstractVector)
-    foreachfield(c) do v
-        if  v isa StructVector || isstringarray(v) || ispooledarray(v)
-            permute!(v, p)
-        else
-            copyto!(v, v[p])
-        end
-    end
+fastpermute!(v::AbstractArray, p::AbstractVector) = copyto!(v, v[p])
+fastpermute!(v::StructArray, p::AbstractVector) = permute!(v, p)
+
+function Base.permute!(c::StructArray, p::AbstractVector)
+    foreachfield(v -> fastpermute!(v, p), c)
     return c
 end
 

test/runtests.jl

@@ -23,12 +23,6 @@ end
     a = WeakRefStrings.StringVector(["a", "b", "c"])
     b = PooledArrays.PooledArray([1, 2, 3])
     c = [:a, :b, :c]
-    @test !StructArrays.ispooledarray(a)
-    @test StructArrays.isstringarray(a)
-    @test StructArrays.ispooledarray(b)
-    @test !StructArrays.isstringarray(b)
-    @test !StructArrays.ispooledarray(c)
-    @test !StructArrays.isstringarray(c)
     s = StructArray(a=a, b=b, c=c)
     permute!(s, [2, 3, 1])
     @test s.a == ["b", "c", "a"]
@@ -247,10 +241,6 @@ StructArrays.SkipConstructor(::Type{<:S}) = true
 end
 
 @testset "default_array" begin
-    v = StructArrays.default_array(String, (2, 3))
-    @test v isa WeakRefStrings.StringArray{String, 2}
-    v = StructArrays.default_array(Union{String, Missing}, (2, 3))
-    @test v isa WeakRefStrings.StringArray{Union{String, Missing}, 2}
     v = StructArrays.default_array(Missing, (2,))
     @test v isa Array{Missing, 1}
     v = StructArrays.default_array(Int, (2,))