add StructArray constructor from slices of an existing array (#159)

* add StructArray constructor from slices of an existing array

* disable tests on 1.0

* add to docs

* add recursive example to docs

Author: simonbyrne

docs/src/index.md

@@ -15,6 +15,7 @@ StructArray
 
 ```@docs
 StructArray(tup::Union{Tuple,NamedTuple})
+StructArray(::AbstractArray)
 StructArray(::Base.UndefInitializer, sz::Dims)
 StructArray(v)
 collect_structarray

src/structarray.jl

@@ -109,6 +109,58 @@ const StructVector{T, C<:Tup, I} = StructArray{T, 1, C, I}
 StructVector{T}(args...; kwargs...) where {T} = StructArray{T}(args...; kwargs...)
 StructVector(args...; kwargs...) = StructArray(args...; kwargs...)
 
+"""
+    StructArray{T}(A::AbstractArray; dims, unwrap=FT->FT!=eltype(A))
+
+Construct a `StructArray` from slices of `A` along `dims`. 
+
+The `unwrap` keyword argument is a function that determines whether to
+recursively convert fields of type `FT` to `StructArray`s.
+
+!!! compat "Julia 1.1"
+     This function requires at least Julia 1.1.
+
+```julia-repl
+julia> X = [1.0 2.0; 3.0 4.0]
+2×2 Array{Float64,2}:
+ 1.0  2.0
+ 3.0  4.0
+
+julia> StructArray{Complex{Float64}}(X; dims=1)
+2-element StructArray(view(::Array{Float64,2}, 1, :), view(::Array{Float64,2}, 2, :)) with eltype Complex{Float64}:
+ 1.0 + 3.0im
+ 2.0 + 4.0im
+
+julia> StructArray{Complex{Float64}}(X; dims=2)
+2-element StructArray(view(::Array{Float64,2}, :, 1), view(::Array{Float64,2}, :, 2)) with eltype Complex{Float64}:
+ 1.0 + 2.0im
+ 3.0 + 4.0im
+```
+
+By default, fields will be unwrapped until they match the element type of the array:
+```
+julia> StructArray{Tuple{Float64,Complex{Float64}}}(rand(3,2); dims=1)
+2-element StructArray(view(::Array{Float64,2}, 1, :), StructArray(view(::Array{Float64,2}, 2, :), view(::Array{Float64,2}, 3, :))) with eltype Tuple{Float64,Complex{Float64}}:
+ (0.004767505234193781, 0.27949621887414566 + 0.9039320635041561im)
+ (0.41853472213051335, 0.5760165160827859 + 0.9782723869433818im)
+```
+"""
+StructArray(A::AbstractArray; dims, unwrap)
+function StructArray{T}(A::AbstractArray; dims, unwrap=FT->FT!=eltype(A)) where {T}
+    slices = Iterators.Stateful(eachslice(A; dims=dims))
+    buildfromslices(T, unwrap, slices)
+end
+function buildfromslices(::Type{T}, unwrap::F, slices) where {T,F}
+    if unwrap(T)
+        buildfromschema(T) do FT
+            buildfromslices(FT, unwrap, slices)
+        end
+    else
+        return popfirst!(slices)
+    end
+end
+
+
 function Base.IndexStyle(::Type{S}) where {S<:StructArray}
     index_type(S) === Int ? IndexLinear() : IndexCartesian()
 end

test/runtests.jl

@@ -223,6 +223,18 @@ end
     @test getproperty(t, 2) == [3.0, 2.0]
 end
 
+@testset "constructor from slices" begin
+    if VERSION >= v"1.1"
+        X = [1.0 2.0; 3.0 4.0]
+        @test StructArray{Complex{Float64}}(X; dims=1) == [Complex(1.0,3.0), Complex(2.0,4.0)]
+        @test StructArray{Complex{Float64}}(X; dims=2) == [Complex(1.0,2.0), Complex(3.0,4.0)]
+
+        X = [1.0 2.0; 3.0 4.0; 5.0 6.0]
+        @test StructArray{Tuple{Float64,Complex{Float64}}}(X; dims=1) == [(1.0,Complex(3.0,5.0)), (2.0, Complex(4.0,6.0))]
+    end
+end
+
+
 struct A
     x::Int
     y::Int