Cannot both broadcast and access components with StructArrays of StaticArrays

[jlchan]

One nice feature is that StructArrays built from StaticArrays are compatible with broadcasting, e.g.,

x = StructArray([SVector{2}(1.,2.) for i = 1:5])
x .+ x  # works
2 .* x  # works

However, it's harder to access the components - StructArrays.components(x) just returns the underlying storage for SVector

julia> StructArrays.components(x)
(data = [(1.0, 2.0), (1.0, 2.0), (1.0, 2.0), (1.0, 2.0), (1.0, 2.0)],).

It's possible to extract the components using unwrap and accessing the underlying SVector storage directly

x = StructArray([SVector(1., 2,) for i in 1:5], unwrap = t -> t <: Tuple)
StructArrays.components(x.data) # returns a tuple containing a vector of 1's and a vector of 2's

but this creates a nested StructArray with type

StructArray(StructArray(::Vector{Float64}, ::Vector{Float64}))  with eltype SVector{2, Float64}

Because of the nested StructArray types, both operation and function broadcasting break again.

[jlchan]

Looks like these few lines from @lcw https://github.com/lcw/Bennu.jl/blob/80e6cec5a37dae2df14c727a80ba08248f799331/src/structarrays.jl#L89-L94 fix things.

# These definitions allow `StructArray` and `StaticArrays.SArray` to play nicely together.
StructArrays.staticschema(::Type{SArray{S,T,N,L}}) where {S,T,N,L} = NTuple{L,T}
StructArrays.createinstance(::Type{SArray{S,T,N,L}}, args...) where {S,T,N,L} =
    SArray{S,T,N,L}(args...)
StructArrays.component(s::SArray, i) = getindex(s, i)

V = StructArray([SVector{2}(Float64[i;i+1]) for i = 1:2])
StructArrays.components(V) # ([1.0, 2.0], [2.0, 3.0])

[jlchan]

@piever StructArrays tests still pass if I import SArray and add these lines, and both broadcasting and components function as expected for StructArrays of StaticVectors. Would this be OK for a PR?

[piever]

Yes, a PR would be great! You should probably implement those for StaticArray in general (which is the common supertype of the various statically-sized arrays). Happy to give some guidance in case the general StaticArray case proves tricky.

I'm mildly uncomfortable special-casing StaticArrays, but it seems that a StructArray{SVector} is a pretty common usecase, and the nested layout really does not make much sense there. (Still, we should probably figure out why broadcasting errored in that case, but that is a separate worry.)

[jlchan]

I'm not the most capable Julia programmer, but I can give that a shot. StructArrays.components would be the same, and StructArrays.staticschema can be generalized by copying StaticArrays and using generated functions https://github.com/JuliaArrays/StaticArrays.jl/blob/5e5a7a8334f6a6d386885495cf8b74d7df6e68a2/src/SArray.jl#L32-L51

However, I'm not sure about StructArrays.createinstance since different StaticArrays have different type signatures?

[piever]

However, I'm not sure about StructArrays.createinstance since different StaticArrays have different type signatures?

It looks like the interface also requires that they have a constructor that takes a flat Tuple, see here. So

createinstance(::Type{T}, args...) where {T<:StaticArray} = T(args)

should already be correct.