internal refactor (#210)

* internal refactor

* cleanup

* remove params

* extra test

Author: Pietro Vertechi

Project.toml

@@ -1,6 +1,6 @@
 name = "StructArrays"
 uuid = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"
-version = "0.6.2"
+version = "0.6.3"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"

docs/src/reference.md

@@ -54,7 +54,6 @@ StructArrays.createinstance
 ```@docs
 StructArrays.get_ith
 StructArrays.map_params
-StructArrays._map_params
 StructArrays.buildfromschema
 StructArrays.bypass_constructor
 StructArrays.iscompatible

src/StructArrays.jl

@@ -1,6 +1,6 @@
 module StructArrays
 
-using Base: tuple_type_cons, tuple_type_head, tuple_type_tail, tail
+using Base: tail
 
 export StructArray, StructVector, LazyRow, LazyRows
 export collect_structarray

src/structarray.jl

@@ -97,13 +97,13 @@ function StructArray{T}(c::C) where {T, C<:Tup}
     StructArray{T, N, typeof(cols)}(cols)
 end
 
-StructArray(c::C) where {C<:NamedTuple} = StructArray{eltypes(C)}(c)
+StructArray(c::NamedTuple) = StructArray{eltypes(c)}(c)
 StructArray(c::Tuple; names = nothing) = _structarray(c, names)
 
 StructArray{T}(; kwargs...) where {T} = StructArray{T}(values(kwargs))
 StructArray(; kwargs...) = StructArray(values(kwargs))
 
-_structarray(args::T, ::Nothing) where {T<:Tuple} = StructArray{eltypes(T)}(args)
+_structarray(args::Tuple, ::Nothing) = StructArray{eltypes(args)}(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))

src/utils.jl

@@ -1,66 +1,39 @@
-eltypes(::Type{T}) where {T} = map_params(eltype, T)
+argtail(_, args...) = args
 
-alwaysfalse(t) = false
-
-"""
-    StructArrays.map_params(f, T)
-
-Apply `f` to each field type of `Tuple` or `NamedTuple` type `T`, returning a
-new `Tuple` or `NamedTuple` type.
+split_tuple_type(T) = fieldtype(T, 1), Tuple{argtail(T.parameters...)...}
 
-```julia-repl
-julia> StructArrays.map_params(T -> Complex{T}, Tuple{Int32,Float64})
-Tuple{Complex{Int32},Complex{Float64}}
-```
-"""
-map_params(f, ::Type{NamedTuple{names, types}}) where {names, types} =
-    NamedTuple{names, map_params(f, types)}
+eltypes(nt::NamedTuple{names}) where {names} = NamedTuple{names, eltypes(values(nt))}
+eltypes(t::Tuple) = Tuple{map(eltype, t)...}
 
-function map_params(f, ::Type{T}) where {T<:Tuple}
-    if @generated
-        types = fieldtypes(T)
-        ex = :(Tuple{})
-        for t ∈ types
-            push!(ex.args, :(f($t)))
-        end
-        ex
-    else
-        map_params_fallback(f, T)
-    end
-end
-
-map_params_fallback(f, ::Type{T}) where {T<:Tuple} = Tuple{map(f, fieldtypes(T))...}
+alwaysfalse(t) = false
 
 """
-    StructArrays._map_params(f, T)
+    StructArrays.map_params(f, T)
 
 Apply `f` to each field type of `Tuple` or `NamedTuple` type `T`, returning a
 new `Tuple` or `NamedTuple` object.
 
 ```julia-repl
-julia> StructArrays._map_params(T -> Complex{T}, Tuple{Int32,Float64})
+julia> StructArrays.map_params(T -> Complex{T}, Tuple{Int32,Float64})
 (Complex{Int32}, Complex{Float64})
 ```
 """
-_map_params(f::F, ::Type{NamedTuple{names, types}}) where {names, types, F} =
-    NamedTuple{names}(_map_params(f, types))
+map_params(f::F, ::Type{NamedTuple{names, types}}) where {F, names, types} =
+    NamedTuple{names}(map_params(f, types))
 
-function _map_params(f::F, ::Type{T}) where {T<:Tuple, F}
+function map_params(f::F, ::Type{T}) where {F, T<:Tuple}
     if @generated
         types = fieldtypes(T)
-        ex = :()
-        for t ∈ types
-            push!(ex.args, :(f($t)))
-        end
-        ex
+        args = map(t -> :(f($t)), types)
+        Expr(:tuple, args...)
     else
-        _map_params_fallback(f, T)
+        map_params_fallback(f, T)
     end
 end
 
-_map_params_fallback(f, ::Type{T}) where {T<:Tuple} = map(f, fieldtypes(T))
+map_params_fallback(f, ::Type{T}) where {T<:Tuple} = map(f, fieldtypes(T))
 
-buildfromschema(initializer::F, ::Type{T}) where {T, F} = buildfromschema(initializer, T, staticschema(T))
+buildfromschema(initializer::F, ::Type{T}) where {F, T} = buildfromschema(initializer, T, staticschema(T))
 
 """
     StructArrays.buildfromschema(initializer, T[, S])
@@ -71,8 +44,8 @@ Construct a [`StructArray{T}`](@ref) with a function `initializer`, using a sche
 
 `S` is a `Tuple` or `NamedTuple` type. The default value is [`staticschema(T)`](@ref).
 """
-function buildfromschema(initializer::F, ::Type{T}, ::Type{NT}) where {T, NT<:Tup, F}
-    nt = _map_params(initializer, NT)
+function buildfromschema(initializer::F, ::Type{T}, ::Type{NT}) where {F, T, NT<:Tup}
+    nt = map_params(initializer, NT)
     StructArray{T}(nt)
 end
 
@@ -123,16 +96,16 @@ iscompatible(::Type{Tuple{}}, ::Type{T}) where {T<:Tuple} = false
 iscompatible(::Type{T}, ::Type{Tuple{}}) where {T<:Tuple} = false
 iscompatible(::Type{Tuple{}}, ::Type{Tuple{}}) = true
 
-function iscompatible(::Type{S}, ::Type{T}) where {S<:Tuple, T<:Tuple}
-    iscompatible(tuple_type_head(S), tuple_type_head(T)) && iscompatible(tuple_type_tail(S), tuple_type_tail(T))
+function iscompatible(::Type{T}, ::Type{T′}) where {T<:Tuple, T′<:Tuple}
+    (f, ls), (f′, ls′) = split_tuple_type(T), split_tuple_type(T′)
+    iscompatible(f, f′) && iscompatible(ls, ls′)
 end
 
-iscompatible(::S, ::T) where {S, T<:AbstractArray} = iscompatible(S, T)
+iscompatible(::S, ::V) where {S, V<:AbstractArray} = iscompatible(S, V)
 
-function _promote_typejoin(::Type{S}, ::Type{T}) where {S<:NTuple{N, Any}, T<:NTuple{N, Any}} where N
-    head = _promote_typejoin(Base.tuple_type_head(S), Base.tuple_type_head(T))
-    tail = _promote_typejoin(Base.tuple_type_tail(S), Base.tuple_type_tail(T))
-    return Base.tuple_type_cons(head, tail)
+function _promote_typejoin(::Type{T}, ::Type{T′}) where {T<:NTuple{N, Any}, T′<:NTuple{N, Any}} where N
+    (f, ls), (f′, ls′) = split_tuple_type(T), split_tuple_type(T′)
+    return Tuple{_promote_typejoin(f, f′), _promote_typejoin(ls, ls′).parameters...}
 end
 
 _promote_typejoin(::Type{Tuple{}}, ::Type{Tuple{}}) = Tuple{}
@@ -141,7 +114,7 @@ function _promote_typejoin(::Type{NamedTuple{names, types}}, ::Type{NamedTuple{n
     return NamedTuple{names, T}
 end
 
-_promote_typejoin(::Type{S}, ::Type{T}) where {S, T} = Base.promote_typejoin(S, T)
+_promote_typejoin(::Type{T}, ::Type{T′}) where {T, T′} = Base.promote_typejoin(T, T′)
 
 function _promote_typejoin(::Type{Pair{A, B}}, ::Type{Pair{A′, B′}}) where {A, A′, B, B′}
     C = _promote_typejoin(A, A′)

test/runtests.jl

@@ -29,10 +29,7 @@ end
 
 @testset "utils" begin
     t = StructArray(rand(ComplexF64, 2, 2))
-    T = staticschema(eltype(t))
-    @test StructArrays.eltypes(T) == NamedTuple{(:re, :im), Tuple{Float64, Float64}}
-    @test StructArrays.map_params(eltype, T) == NamedTuple{(:re, :im), Tuple{Float64, Float64}}
-    @test StructArrays.map_params(eltype, StructArrays.astuple(T)) == Tuple{Float64, Float64}
+    @test StructArrays.eltypes((re = 1.0, im = 1.0)) == NamedTuple{(:re, :im), Tuple{Float64, Float64}}
     @test !iscompatible(typeof((1, 2)), typeof(([1],)))
     @test iscompatible(typeof((1, 2)), typeof(([1], [2])))
     @test !iscompatible(typeof((1, 2)), typeof(([1.1], [2])))
@@ -343,6 +340,21 @@ 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]))
 nt_infer(nt) = StructArray{typeof(nt)}(undef, 4)
+eltype_infer() = StructArray((rand(10), rand(Int, 10)))
+named_eltype_infer() = StructArray((x=rand(10), y=rand(Int, 10)))
+compatible_infer() = Val(iscompatible(Tuple{Int, Int}, Tuple{Vector{Int}, Vector{Real}}))
+function promote_infer()
+    x = (a=1, b=1.2)
+    y = (a=1.2, b="a")
+    T = _promote_typejoin(typeof(x), typeof(y))
+    return convert(T, x)
+end
+function map_params_infer()
+    v = StructArray(rand(ComplexF64, 2, 2))
+    f(T) = similar(v, T)
+    types = Tuple{Int, Float64, ComplexF32, String}
+    return StructArrays.map_params(f, types)
+end
 
 @testset "inferrability" begin
     @inferred f_infer()
@@ -354,6 +366,11 @@ nt_infer(nt) = StructArray{typeof(nt)}(undef, 4)
     @test s[2] == (3, 4)
     @inferred cols_infer()
     @inferred nt_infer((x = 3, y = :a, z = :b))
+    @inferred eltype_infer()
+    @inferred named_eltype_infer()
+    @inferred compatible_infer()
+    @inferred promote_infer()
+    @inferred map_params_infer()
 end
 
 @testset "propertynames" begin
@@ -882,21 +899,21 @@ end
     end
 end
 
-# Test fallback (non-@generated) variant of _map_params
-@testset "_map_params" begin
+# Test fallback (non-@generated) variant of map_params
+@testset "map_params" begin
     v = StructArray(rand(ComplexF64, 2, 2))
     f(T) = similar(v, T)
     types = Tuple{Int, Float64, ComplexF32, String}
-    A = @inferred StructArrays._map_params(f, types)
-    B = StructArrays._map_params_fallback(f, types)
-    @test typeof(A) === typeof(B)
-end
-
-# Same for map_params
-@testset "map_params" begin
-    types = Tuple{Int, Float64, Int32}
-    f(T) = Complex{T}
     A = @inferred StructArrays.map_params(f, types)
     B = StructArrays.map_params_fallback(f, types)
-    @test A === B
-end
+    @test typeof(A) === typeof(B)
+    types = Tuple{Int, Float64, ComplexF32}
+    A = @inferred StructArrays.map_params(zero, types)
+    B = StructArrays.map_params_fallback(zero, types)
+    C = map(zero, fieldtypes(types))
+    @test A === B === C
+    namedtypes = NamedTuple{(:a, :b, :c), types}
+    A = @inferred StructArrays.map_params(zero, namedtypes)
+    C = map(zero, NamedTuple{(:a, :b, :c)}(map(zero, fieldtypes(types))))
+    @test A === C
+end