Constructor reorg (#37)

Author: Pietro Vertechi

src/sort.jl

@@ -55,12 +55,11 @@ function finduniquesorted(args...)
     (row => p[idxs] for (row, idxs) in t)
 end
 
-function Base.sortperm(c::StructVector{T};
-    alg = DEFAULT_UNSTABLE) where {T<:Union{Tuple, NamedTuple}}
+function Base.sortperm(c::StructVector{T}) where {T<:Union{Tuple, NamedTuple}}
 
     cols = fieldarrays(c)
     x = cols[1]
-    p = sortperm(x; alg = alg)
+    p = sortperm(x)
     if length(cols) > 1
         y = cols[2]
         refine_perm!(p, cols, 1, x, y, 1, length(x))

src/structarray.jl

@@ -7,27 +7,36 @@ struct StructArray{T, N, C<:NamedTuple} <: AbstractArray{T, N}
     fieldarrays::C
 
     function StructArray{T, N, C}(c) where {T, N, C<:NamedTuple}
-        length(c) > 0 || error("must have at least one column")
-        ax = axes(c[1])
-        length(ax) == N || error("wrong number of dimensions")
-        for i = 2:length(c)
-            axes(c[i]) == ax || error("all field arrays must have same shape")
+        if length(c) > 0
+            ax = axes(c[1])
+            length(ax) == N || error("wrong number of dimensions")
+            for i = 2:length(c)
+                axes(c[i]) == ax || error("all field arrays must have same shape")
+            end
         end
         new{T, N, C}(c)
     end
 end
 
+_dims(c::NamedTuple) = length(axes(c[1]))
+_dims(c::NamedTuple{(), Tuple{}}) = 1
+
 StructArray{T}(c::C) where {T, C<:Tuple} = StructArray{T}(NamedTuple{fields(T)}(c))
-StructArray{T}(c::C) where {T, C<:NamedTuple} = StructArray{T, length(size(c[1])), C}(c)
+StructArray{T}(c::C) where {T, C<:NamedTuple} = StructArray{T, _dims(c), C}(c)
 StructArray{T}(c::C) where {T, C<:Pair} = StructArray{T}(Tuple(c))
 StructArray(c::C) where {C<:NamedTuple} = StructArray{eltypes(C)}(c)
-StructArray(c::C) where {C<:Tuple} = 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))
 
-StructArray{T}(args...) where {T} = StructArray{T}(NamedTuple{fields(T)}(args))
+@deprecate(StructArray{T}(args...) where {T}, StructArray{T}(args))
+
+_structarray(args::T, ::Nothing) where {T<:Tuple} = StructArray{eltypes(T)}(args)
+_structarray(args::Tuple, names) = _structarray(args, Tuple(names))
+_structarray(args::Tuple, ::Tuple) = _structarray(args, nothing)
+_structarray(args::NTuple{N, Any}, names::NTuple{N, Symbol}) where {N} = StructArray(NamedTuple{names}(args))
 
 const StructVector{T, C<:NamedTuple} = StructArray{T, 1, C}
 StructVector{T}(args...; kwargs...) where {T} = StructArray{T}(args...; kwargs...)
@@ -69,10 +78,9 @@ function Base.similar(::Type{StructArray{T, N, C}}, sz::Dims) where {T, N, C}
     StructArray{T}(cols)
 end
 
-Base.similar(s::StructArray, sz::Tuple) = similar(s, Base.to_shape(sz))
 Base.similar(s::StructArray, sz::Base.DimOrInd...) = similar(s, Base.to_shape(sz))
 Base.similar(s::StructArray) = similar(s, Base.to_shape(axes(s)))
-function Base.similar(s::StructArray{T}, sz::Dims) where {T}
+function Base.similar(s::StructArray{T}, sz::Tuple) where {T}
     StructArray{T}(map(typ -> similar(typ, sz), fieldarrays(s)))
 end
 
@@ -84,7 +92,9 @@ Base.propertynames(s::StructArray) = fieldnames(typeof(fieldarrays(s)))
 staticschema(::Type{<:StructArray{T}}) where {T} = staticschema(T)
 
 Base.size(s::StructArray) = size(fieldarrays(s)[1])
+Base.size(s::StructArray{<:Any, <:Any, <:NamedTuple{(), Tuple{}}}) = (0,)
 Base.axes(s::StructArray) = axes(fieldarrays(s)[1])
+Base.axes(s::StructArray{<:Any, <:Any, <:NamedTuple{(), Tuple{}}}) = (1:0,)
 
 @generated function Base.getindex(x::StructArray{T, N, NamedTuple{names, types}}, I::Int...) where {T, N, names, types}
     args = [:(getfield(cols, $i)[I...]) for i in 1:length(names)]

src/utils.jl

@@ -9,7 +9,9 @@ end
 map_types(f, ::Type{NamedTuple{names, types}}) where {names, types} =
     NamedTuple{names, map_types(f, types)}
 
-all_types(f, ::Type{Tuple{}}, ::Type{T}) where {T<:Tuple} = true
+all_types(f, ::Type{Tuple{}}, ::Type{T}) where {T<:Tuple} = false
+all_types(f, ::Type{T}, ::Type{Tuple{}}) where {T<:Tuple} = false
+all_types(f, ::Type{Tuple{}}, ::Type{Tuple{}}) = true
 
 function all_types(f, ::Type{S}, ::Type{T}) where {S<:Tuple, T<:Tuple}
     f(tuple_type_head(S), tuple_type_head(T)) && all_types(f, tuple_type_tail(S), tuple_type_tail(T))

test/runtests.jl

@@ -125,7 +125,7 @@ end
     @test s[1] == (1, "test")
     @test Base.getproperty(s, 1) == [1]
     @test Base.getproperty(s, 2) == ["test"]
-    t = StructArray{Tuple{Int, Float64}}([1], [1.2])
+    t = StructArray{Tuple{Int, Float64}}(([1], [1.2]))
     @test t[1] == (1, 1.2)
 
     t[1] = (2, 3)
@@ -139,26 +139,26 @@ end
     a = [1.2]
     b = [2.3]
     @test StructArray(a=a, b=b) == StructArray((a=a, b=b))
-    @test StructArray{ComplexF64}(re=a, im=b) == StructArray{ComplexF64}(a, b)
+    @test StructArray{ComplexF64}(re=a, im=b) == StructArray{ComplexF64}((a, b))
     f1() = StructArray(a=[1.2], b=["test"])
     f2() = StructArray{Pair}(first=[1.2], second=["test"])
     t1 = @inferred f1()
     t2 = @inferred f2()
     @test t1 == StructArray((a=[1.2], b=["test"]))
-    @test t2 == StructArray{Pair}([1.2], ["test"])
+    @test t2 == StructArray{Pair}(([1.2], ["test"]))
 end
 
 @testset "complex" begin
     a, b = [1 2; 3 4], [4 5; 6 7]
-    t = StructArray{ComplexF64}(a, b)
+    t = StructArray{ComplexF64}((a, b))
     @test t[2,2] == ComplexF64(4, 7)
-    @test t[2,1:2] == StructArray{ComplexF64}([3, 4], [6, 7])
-    @test view(t, 2, 1:2) == StructArray{ComplexF64}(view(a, 2, 1:2), view(b, 2, 1:2))
+    @test t[2,1:2] == StructArray{ComplexF64}(([3, 4], [6, 7]))
+    @test view(t, 2, 1:2) == StructArray{ComplexF64}((view(a, 2, 1:2), view(b, 2, 1:2)))
 end
 
 @testset "copy" begin
     a, b = [1 2; 3 4], [4 5; 6 7]
-    t = StructArray{ComplexF64}(a, b)
+    t = StructArray{ComplexF64}((a, b))
     t2 = @inferred copy(t)
     @test t2[1,1] == 1.0 + im*4.0
     t2[1,1] = 2.0 + im*4.0
@@ -176,7 +176,7 @@ end
 end
 
 @testset "resize!" begin
-    t = StructArray{Pair}([3, 5], ["a", "b"])
+    t = StructArray{Pair}(([3, 5], ["a", "b"]))
     resize!(t, 5)
     @test length(t) == 5
     p = 1 => "c"
@@ -185,23 +185,24 @@ end
 end
 
 @testset "concat" begin
-    t = StructArray{Pair}([3, 5], ["a", "b"])
+    t = StructArray{Pair}(([3, 5], ["a", "b"]))
     push!(t, (2 => "c"))
-    @test t == StructArray{Pair}([3, 5, 2], ["a", "b", "c"])
+    @test t == StructArray{Pair}(([3, 5, 2], ["a", "b", "c"]))
     append!(t, t)
-    @test t == StructArray{Pair}([3, 5, 2, 3, 5, 2], ["a", "b", "c", "a", "b", "c"])
-    t = StructArray{Pair}([3, 5], ["a", "b"])
-    t2 = StructArray{Pair}([1, 6], ["a", "b"])
-    @test cat(t, t2; dims=1)::StructArray == StructArray{Pair}([3, 5, 1, 6], ["a", "b", "a", "b"]) == vcat(t, t2)
+    @test t == StructArray{Pair}(([3, 5, 2, 3, 5, 2], ["a", "b", "c", "a", "b", "c"]))
+    t = StructArray{Pair}(([3, 5], ["a", "b"]))
+    t2 = StructArray{Pair}(([1, 6], ["a", "b"]))
+    @test cat(t, t2; dims=1)::StructArray == StructArray{Pair}(([3, 5, 1, 6], ["a", "b", "a", "b"])) == vcat(t, t2)
     @test vcat(t, t2) isa StructArray
-    @test cat(t, t2; dims=2)::StructArray == StructArray{Pair}([3 1; 5 6], ["a" "a"; "b" "b"]) == hcat(t, t2)
+    @test cat(t, t2; dims=2)::StructArray == StructArray{Pair}(([3 1; 5 6], ["a" "a"; "b" "b"])) == hcat(t, t2)
     @test hcat(t, t2) isa StructArray
 end
 
-f_infer() = StructArray{ComplexF64}(rand(2,2), rand(2,2))
+f_infer() = StructArray{ComplexF64}((rand(2,2), rand(2,2)))
 
 g_infer() = StructArray([(a=(b="1",), c=2)], unwrap = t -> t <: NamedTuple)
 tup_infer() = StructArray([(1, 2), (3, 4)])
+cols_infer() = StructArray(([1, 2], [1.2, 2.3]))
 
 @testset "inferrability" begin
     @inferred f_infer()
@@ -211,10 +212,11 @@ tup_infer() = StructArray([(1, 2), (3, 4)])
     @test Tables.columns(s) == (x1 = [1, 3], x2 = [2, 4])
     @test s[1] == (1, 2)
     @test s[2] == (3, 4)
+    @inferred cols_infer()
 end
 
 @testset "propertynames" begin
-    a = StructArray{ComplexF64}(Float64[], Float64[])
+    a = StructArray{ComplexF64}((Float64[], Float64[]))
     @test sort(collect(propertynames(a))) == [:im, :re]
 end
 
@@ -239,7 +241,7 @@ end
 StructArrays.SkipConstructor(::Type{<:S}) = true
 
 @testset "inner" begin
-    v = StructArray{S}([1], [1])
+    v = StructArray{S}(([1], [1]))
     @test v[1] == S(1)
     @test v[1].y isa Float64
 end
@@ -367,32 +369,32 @@ end
 
 @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) == StructArray{Pair{Int, Int}}(([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) == StructArray{Pair{Real, Int}}(([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{Pair{NamedTuple{(:a,),Tuple{Int64}},NamedTuple{(:b,),Tuple{String}}}}(StructArray((a = [1,2,3],)), StructArray((b = ["a1","a2","a3"],)))
+    @test collect_structarray_rec(v) == 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{Pair{NamedTuple{(:a,),Tuple{Any}},NamedTuple{(:b,),Tuple{String}}}}(StructArray((a = ["1",2,3],)), StructArray((b = ["a1","a2","a3"],)))
+    @test collect_structarray_rec(v) == 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{Pair{NamedTuple{(:a,),Tuple{Int64}},NamedTuple{(:b,),Tuple{String}}}}(StructArray((a = Int[],)), StructArray((b = String[],)))
+    @test collect_structarray_rec(v) == 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{Pair{NamedTuple{(:a,),Tuple{Int64}},NamedTuple{(:b,),Tuple{String}}}}(StructArray((a = Int[],)), StructArray((b = String[],)))
+    @test collect_structarray_rec(v) == 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{Pair{NamedTuple{(:b,),Tuple{Int64}},NamedTuple{(:a,),Tuple{Union{Missing, Int64}}}}}(StructArray(b = [1,1,1]), StructArray(a = [2, missing, 3]))
+    s = 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]