Rename createtype to add_params and cleanup

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

@@ -22,7 +22,7 @@ _dims(c::Tup) = length(axes(c[1]))
 _dims(c::EmptyTup) = 1
 
 function StructArray{T}(c::C) where {T, C<:Tup}
-    cols = strip_types(staticschema(T))(c)
+    cols = strip_params(staticschema(T))(c)
     StructArray{T, _dims(cols), typeof(cols)}(cols)
 end
 

src/utils.jl

@@ -61,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