Merge pull request #72 from piever/pv/API

API changes pre 1.0

Author: Pietro Vertechi

src/collect.jl

@@ -110,7 +110,7 @@ function grow_to_structarray!(dest::AbstractArray, itr, elem = iterate(itr))
 end
 
 function to_structarray(::Type{T}, nt::C) where {T, C<:Tup}
-    S = createtype(T, eltypes(C))
+    S = add_params(T, eltypes(astuple(C)))
     return StructArray{S}(nt)
 end
 
@@ -122,7 +122,7 @@ function widenstructarray(dest::StructArray{T}, i, ::Type{S}) where {T, S}
     types = ntuple(i -> fieldtype(sch, i), fieldcount(sch))
     cols = fieldarrays(dest)
     if names == propertynames(cols)
-        nt = map((a, b) -> widenstructarray(a, i, b), cols, strip_types(sch)(types))
+        nt = map((a, b) -> widenstructarray(a, i, b), cols, strip_params(sch)(types))
         return to_structarray(T, nt)
     else
         return widenarray(dest, i, S)

src/interface.jl

@@ -9,12 +9,12 @@ end
 
 staticschema(::Type{T}) where {T<:Tup} = T
 
-tuple_type(::Type{NamedTuple{names, types}}) where {names, types} = types
-tuple_type(::Type{T}) where {T<:Tuple} = T
+astuple(::Type{NamedTuple{names, types}}) where {names, types} = types
+astuple(::Type{T}) where {T<:Tuple} = T
 
 function fields(::Type{T}) where {T}
     fieldnames(staticschema(T))
 end
 
-strip_types(::Type{<:Tuple}) = Tuple
-strip_types(::Type{<:NamedTuple{names}}) where {names} = NamedTuple{names}
+strip_params(::Type{<:Tuple}) = Tuple
+strip_params(::Type{<:NamedTuple{names}}) where {names} = NamedTuple{names}

src/structarray.jl

@@ -21,14 +21,13 @@ end
 _dims(c::Tup) = length(axes(c[1]))
 _dims(c::EmptyTup) = 1
 
-function StructArray{T}(c::C) where {T, C<:Union{Tup, Pair}}
-    cols = strip_types(staticschema(T))(Tuple(c))
+function StructArray{T}(c::C) where {T, C<:Tup}
+    cols = strip_params(staticschema(T))(c)
     StructArray{T, _dims(cols), typeof(cols)}(cols)
 end
 
 StructArray(c::C) where {C<:NamedTuple} = StructArray{eltypes(C)}(c)
 StructArray(c::Tuple; names = nothing) = _structarray(c, names)
-StructArray(c::Pair{P, Q}) where {P, Q} = StructArray{Pair{eltype(P), eltype(Q)}}(c)
 
 StructArray{T}(; kwargs...) where {T} = StructArray{T}(values(kwargs))
 StructArray(; kwargs...) = StructArray(values(kwargs))

src/utils.jl

@@ -25,14 +25,18 @@ end
 
 Base.@pure SkipConstructor(::Type) = false
 
-@inline getfieldindex(v::Tuple, field, index) = getfield(v, index)
-@inline getfieldindex(v, field, index) = getproperty(v, field)
+@static if VERSION < v"1.2.0"
+    @inline _getproperty(v::Tuple, field) = getfield(v, field)
+    @inline _getproperty(v, field) = getproperty(v, field)
+else
+    const _getproperty = getproperty
+end
 
 function _foreachfield(names, xs)
     exprs = Expr[]
-    for (ind, field) in enumerate(names)
+    for field in names
         sym = QuoteNode(field)
-        args = [Expr(:call, :getfieldindex, :(getfield(xs, $j)), sym, ind) for j in 1:length(xs)]
+        args = [Expr(:call, :_getproperty, :(getfield(xs, $j)), sym) for j in 1:length(xs)]
         push!(exprs, Expr(:call, :f, args...))
     end
     push!(exprs, :(return nothing))
@@ -57,20 +61,18 @@ createinstance(::Type{T}, args...) where {T<:Union{Tuple, NamedTuple}} = T(args)
     Expr(:block, new_tup, construct)
 end
 
-createtype(::Type{T}, ::Type{C}) where {T<:Tup, C<:Tup} = C
-function createtype(::Type{<:Pair}, ::Type{C}) where {C<:Tup}
-    tp = tuple_type(C).parameters
-    Pair{tp[1], tp[2]}
-end
-createtype(::Type{T}, ::Type{C}) where {T, C<:Tup} = T
+add_params(::Type{T}, ::Type{C}) where {T, C<:Tuple} = T
+add_params(::Type{T}, ::Type{C}) where {T<:Tuple, C<:Tuple} = C
+add_params(::Type{<:NamedTuple{names}}, ::Type{C}) where {names, C<:Tuple} = NamedTuple{names, C}
+add_params(::Type{<:Pair}, ::Type{Tuple{S, T}}) where {S, T} = Pair{S, T}
 
 """
 `iscompatible(::Type{S}, ::Type{V}) where {S, V<:AbstractArray}`
 
 Check whether element type `S` can be pushed to a container of type `V`.
 """
 iscompatible(::Type{S}, ::Type{<:AbstractArray{T}}) where {S, T} = S<:T
-iscompatible(::Type{S}, ::Type{StructArray{T, N, C}}) where {S, T, N, C} = iscompatible(tuple_type(staticschema(S)), tuple_type(C))
+iscompatible(::Type{S}, ::Type{StructArray{T, N, C}}) where {S, T, N, C} = iscompatible(astuple(staticschema(S)), astuple(C))
 
 iscompatible(::Type{Tuple{}}, ::Type{T}) where {T<:Tuple} = false
 iscompatible(::Type{T}, ::Type{Tuple{}}) where {T<:Tuple} = false

test/runtests.jl

@@ -420,34 +420,36 @@ end
     @test isequal(StructArrays.fieldarrays(t)[1], [1, missing, 3])
 end
 
+pair_structarray((first, last)) = StructArray{Pair{eltype(first), eltype(last)}}((first, last))
+
 @testset "collectpairs" begin
     v = (i=>i+1 for i in 1:3)
-    @test collect_structarray_rec(v) == StructArray{Pair{Int, Int}}(([1,2,3], [2,3,4]))
+    @test collect_structarray_rec(v) == pair_structarray([1,2,3] => [2,3,4])
     @test eltype(collect_structarray_rec(v)) == Pair{Int, Int}
 
     v = (i == 1 ? (1.2 => i+1) : (i => i+1) for i in 1:3)
-    @test collect_structarray_rec(v) == StructArray{Pair{Real, Int}}(([1.2,2,3], [2,3,4]))
+    @test collect_structarray_rec(v) == pair_structarray([1.2,2,3] => [2,3,4])
     @test eltype(collect_structarray_rec(v)) == Pair{Real, Int}
 
     v = ((a=i,) => (b="a$i",) for i in 1:3)
-    @test collect_structarray_rec(v) == StructArray(StructArray((a = [1,2,3],)) => StructArray((b = ["a1","a2","a3"],)))
+    @test collect_structarray_rec(v) == pair_structarray(StructArray((a = [1,2,3],)) => StructArray((b = ["a1","a2","a3"],)))
     @test eltype(collect_structarray_rec(v)) == Pair{NamedTuple{(:a,), Tuple{Int64}}, NamedTuple{(:b,), Tuple{String}}}
 
     v = (i == 1 ? (a="1",) => (b="a$i",) : (a=i,) => (b="a$i",) for i in 1:3)
-    @test collect_structarray_rec(v) == StructArray(StructArray((a = ["1",2,3],)) => StructArray((b = ["a1","a2","a3"],)))
+    @test collect_structarray_rec(v) == pair_structarray(StructArray((a = ["1",2,3],)) => StructArray((b = ["a1","a2","a3"],)))
     @test eltype(collect_structarray_rec(v)) == Pair{NamedTuple{(:a,), Tuple{Any}}, NamedTuple{(:b,), Tuple{String}}}
 
     # empty
     v = ((a=i,) => (b="a$i",) for i in 0:-1)
-    @test collect_structarray_rec(v) == StructArray(StructArray((a = Int[],)) => StructArray((b = String[],)))
+    @test collect_structarray_rec(v) == pair_structarray(StructArray((a = Int[],)) => StructArray((b = String[],)))
     @test eltype(collect_structarray_rec(v)) == Pair{NamedTuple{(:a,), Tuple{Int}}, NamedTuple{(:b,), Tuple{String}}}
 
     v = Iterators.filter(t -> t.first.a == 4, ((a=i,) => (b="a$i",) for i in 1:3))
-    @test collect_structarray_rec(v) == StructArray(StructArray((a = Int[],)) => StructArray((b = String[],)))
+    @test collect_structarray_rec(v) == pair_structarray(StructArray((a = Int[],)) => StructArray((b = String[],)))
     @test eltype(collect_structarray_rec(v)) == Pair{NamedTuple{(:a,), Tuple{Int}}, NamedTuple{(:b,), Tuple{String}}}
 
     t = collect_structarray_rec((b = 1,) => (a = i,) for i in (2, missing, 3))
-    s = StructArray(StructArray(b = [1,1,1]) => StructArray(a = [2, missing, 3]))
+    s = pair_structarray(StructArray(b = [1,1,1]) => StructArray(a = [2, missing, 3]))
     @test s[1] == t[1]
     @test ismissing(t[2].second.a)
     @test s[3] == t[3]