Merge pull request JuliaArrays#28 from piever/pv/fieldarrays

rename to fieldarrays

Author: Pietro Vertechi

src/collect.jl

@@ -17,29 +17,29 @@ ArrayInitializer() = ArrayInitializer(t -> false)
 _reshape(v, itr, ::Base.HasShape) = reshape(v, axes(itr))
 _reshape(v, itr, ::Union{Base.HasLength, Base.SizeUnknown}) = v
 
-function collect_columns(itr; initializer = default_initializer)
+function collect_fieldarrays(itr; initializer = default_initializer)
     sz = Base.IteratorSize(itr)
-    v = collect_columns(itr, sz, initializer = initializer)
+    v = collect_fieldarrays(itr, sz, initializer = initializer)
     _reshape(v, itr, sz)
 end
 
-function collect_empty_columns(itr::T; initializer = default_initializer) where {T}
+function collect_empty_fieldarrays(itr::T; initializer = default_initializer) where {T}
     S = Core.Compiler.return_type(first, Tuple{T})
     initializer(S, (0,))
 end
 
-function collect_columns(@nospecialize(itr), ::Union{Base.HasShape, Base.HasLength};
+function collect_fieldarrays(@nospecialize(itr), ::Union{Base.HasShape, Base.HasLength};
     initializer = default_initializer)
 
     st = iterate(itr)
-    st === nothing && return collect_empty_columns(itr, initializer = initializer)
+    st === nothing && return collect_empty_fieldarrays(itr, initializer = initializer)
     el, i = st
     dest = initializer(typeof(el), (length(itr),))
     dest[1] = el
-    collect_to_columns!(dest, itr, 2, i)
+    collect_to_fieldarrays!(dest, itr, 2, i)
 end
 
-function collect_to_columns!(dest::AbstractArray{T}, itr, offs, st) where {T}
+function collect_to_fieldarrays!(dest::AbstractArray{T}, itr, offs, st) where {T}
     # collect to dest array, checking the type of each result. if a result does not
     # match, widen the result type and re-dispatch.
     i = offs
@@ -51,24 +51,24 @@ function collect_to_columns!(dest::AbstractArray{T}, itr, offs, st) where {T}
             @inbounds dest[i] = el
             i += 1
         else
-            new = widencolumns(dest, i, el)
+            new = widenfieldarrays(dest, i, el)
             @inbounds new[i] = el
-            return collect_to_columns!(new, itr, i+1, st)
+            return collect_to_fieldarrays!(new, itr, i+1, st)
         end
     end
     return dest
 end
 
-function collect_columns(itr, ::Base.SizeUnknown; initializer = default_initializer)
+function collect_fieldarrays(itr, ::Base.SizeUnknown; initializer = default_initializer)
     elem = iterate(itr)
-    elem === nothing && return collect_empty_columns(itr; initializer = initializer)
+    elem === nothing && return collect_empty_fieldarrays(itr; initializer = initializer)
     el, st = elem
     dest = initializer(typeof(el), (1,))
     dest[1] = el
-    grow_to_columns!(dest, itr, iterate(itr, st))
+    grow_to_fieldarrays!(dest, itr, iterate(itr, st))
 end
 
-function grow_to_columns!(dest::AbstractArray{T}, itr, elem = iterate(itr)) where {T}
+function grow_to_fieldarrays!(dest::AbstractArray{T}, itr, elem = iterate(itr)) where {T}
     # collect to dest array, checking the type of each result. if a result does not
     # match, widen the result type and re-dispatch.
     i = length(dest)+1
@@ -79,9 +79,9 @@ function grow_to_columns!(dest::AbstractArray{T}, itr, elem = iterate(itr)) wher
             elem = iterate(itr, st)
             i += 1
         else
-            new = widencolumns(dest, i, el)
+            new = widenfieldarrays(dest, i, el)
             push!(new, el)
-            return grow_to_columns!(new, itr, iterate(itr, st))
+            return grow_to_fieldarrays!(new, itr, iterate(itr, st))
         end
     end
     return dest
@@ -92,18 +92,18 @@ function to_structarray(::Type{T}, nt::C) where {T, C}
     StructArray{S}(nt)
 end
 
-function widencolumns(dest::StructArray{T}, i, el::S) where {T, S}
+function widenfieldarrays(dest::StructArray{T}, i, el::S) where {T, S}
     fs = fields(S)
     if fs === fields(T)
-        new_cols = (widencolumns(columns(dest)[ind], i, getfieldindex(el, f, ind)) for (ind, f) in enumerate(fs))
+        new_cols = (widenfieldarrays(fieldarrays(dest)[ind], i, getfieldindex(el, f, ind)) for (ind, f) in enumerate(fs))
         nt = NamedTuple{fs}(Tuple(new_cols))
         v = to_structarray(T, nt)
     else
         widenarray(dest, i, el)
     end
 end
 
-widencolumns(dest::AbstractArray, i, el) = widenarray(dest, i, el)
+widenfieldarrays(dest::AbstractArray, i, el) = widenarray(dest, i, el)
 
 function widenarray(dest::AbstractArray{T}, i, el::S) where {S, T}
     S <: T && return dest

src/structarray.jl

@@ -1,17 +1,17 @@
 """
 A type that stores an array of structures as a structure of arrays.
 # Fields:
-- `columns`: a named tuple of arrays. Also `columns(x)`
+- `fieldarrays`: a named tuple of arrays. Also `fieldarrays(x)`
 """
 struct StructArray{T, N, C<:NamedTuple} <: AbstractArray{T, N}
-    columns::C
+    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 columns must have same size")
+            axes(c[i]) == ax || error("all field arrays must have same shape")
         end
         new{T, N, C}(c)
     end
@@ -69,35 +69,30 @@ Base.similar(s::S, sz::Tuple) where {S<:StructArray} = similar(S, Base.to_shape(
 Base.similar(s::S, sz::Base.DimOrInd...) where {S<:StructArray} = similar(S, Base.to_shape(sz))
 Base.similar(s::S) where {S<:StructArray} = similar(S, Base.to_shape(axes(s)))
 
-columns(s::StructArray) = getfield(s, :columns)
-columns(v::AbstractVector) = v
-ncols(v::AbstractVector) = 1
-ncols(v::StructArray{T, N, C}) where {T, N, C} = length(getnames(C))
-colnames(v::AbstractVector) = (1,)
-colnames(v::StructArray{T, N, C}) where {T, N, C} = getnames(C)
+fieldarrays(s::StructArray) = getfield(s, :fieldarrays)
 
-Base.getproperty(s::StructArray, key::Symbol) = getfield(columns(s), key)
-Base.getproperty(s::StructArray, key::Int) = getfield(columns(s), key)
-Base.propertynames(s::StructArray) = fieldnames(typeof(columns(s)))
+Base.getproperty(s::StructArray, key::Symbol) = getfield(fieldarrays(s), key)
+Base.getproperty(s::StructArray, key::Int) = getfield(fieldarrays(s), key)
+Base.propertynames(s::StructArray) = fieldnames(typeof(fieldarrays(s)))
 
-Base.size(s::StructArray) = size(columns(s)[1])
-Base.axes(s::StructArray) = axes(columns(s)[1])
+Base.size(s::StructArray) = size(fieldarrays(s)[1])
+Base.axes(s::StructArray) = axes(fieldarrays(s)[1])
 
 @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)]
     return quote
-        cols = columns(x)
+        cols = fieldarrays(x)
         @boundscheck checkbounds(x, I...)
         @inbounds $(Expr(:call, :createinstance, :T, args...))
     end
 end
 
 function Base.getindex(s::StructArray{T, N, C}, I::Union{Int, AbstractArray, Colon}...) where {T, N, C}
-    StructArray{T}(map(v -> getindex(v, I...), columns(s)))
+    StructArray{T}(map(v -> getindex(v, I...), fieldarrays(s)))
 end
 
 function Base.view(s::StructArray{T, N, C}, I...) where {T, N, C}
-    StructArray{T}(map(v -> view(v, I...), columns(s)))
+    StructArray{T}(map(v -> view(v, I...), fieldarrays(s)))
 end
 
 function Base.setindex!(s::StructArray, vals, I::Int...)
@@ -124,7 +119,7 @@ function Base.cat(args::StructArray...; dims)
 end
 
 function Base.resize!(s::StructArray, i::Integer)
-    for a in columns(s)
+    for a in fieldarrays(s)
         resize!(a, i)
     end
     return s
@@ -144,8 +139,8 @@ for op in [:hcat, :vcat]
     end
 end
 
-Base.copy(s::StructArray{T,N,C}) where {T,N,C} = StructArray{T,N,C}(C(copy(x) for x in columns(s)))
+Base.copy(s::StructArray{T,N,C}) where {T,N,C} = StructArray{T,N,C}(C(copy(x) for x in fieldarrays(s)))
 
 function Base.reshape(s::StructArray{T}, d::Dims) where {T}
-    StructArray{T}(map(x -> reshape(x, d), columns(s)))
+    StructArray{T}(map(x -> reshape(x, d), fieldarrays(s)))
 end

src/tables.jl

@@ -3,7 +3,7 @@ Tables.rowaccess(::Type{<:StructArray}) = true
 Tables.columnaccess(::Type{<:StructArray}) = true
 
 Tables.rows(s::StructArray) = s
-Tables.columns(s::StructArray) = columns(s)
+Tables.columns(s::StructArray) = fieldarrays(s)
 
 function Tables.schema(s::StructArray{T}) where {T}
     NT = staticschema(T)