StructArray into KeyedArray

General Usage
1

How do I turn a StructArray into a KeyedArray?

┌───────┬───────┬───────────┬──────────┬──────────┐
│     a │     b │         x │        y │        z │
│ Int64 │ Int64 │   Float64 │  Float64 │  Float64 │
├───────┼───────┼───────────┼──────────┼──────────┤
│     1 │     3 │ 0.0271853 │ 0.426652 │ 0.908247 │
│     2 │     3 │  0.331786 │ 0.470659 │  0.80698 │
│     1 │     4 │  0.636678 │ 0.350289 │ 0.708534 │
│     2 │     4 │ 0.0822821 │ 0.263246 │ 0.981152 │
└───────┴───────┴───────────┴──────────┴──────────┘

using StructArrays, AxisKeys, DataManipulation
let k = 4
    d = (;
        a = 1:k,
        b = [1,1,2,2],
        x = rand(k),
        y = rand(k),
        z = rand(k),
    ) |> StructArray

    @p begin
        d
        group(_.b)
        map(pairs(__)) do (b, __)
            group(_.a)
            map() do __
                [__.x __.y __.z]
                KeyedArray(; row=[1], col=[:x, :y, :z])
            end
            KeyedArray(collect(__); a=collect(keys(__)))
            stack
            dropdims(;dims=1)        
        end        
        KeyedArray(collect(__); b=collect(keys(__)))
        stack
    end
end
ERROR: DimensionMismatch: stack expects uniform axiskeys for all arrays
2

Found 2 issues with the code:

  1. stack of KeyedArrays returns a normal array and loses axes information.
  2. d.a is in the code is [1,2,3,4] where this leads to an error, as a keys in each b category should be similar (the a values in the graphic table are correct though :thinking:)

A working version could be:

@p begin
    d
    group(_.b)
    @aside bnames = collect(keys(__))
    map(pairs(__)) do (b, __)
        group(_.a)
        @aside anames = collect(keys(__))
        map(pairs(__)) do (a, __)
            [__.x __.y __.z]
        end
        stack
        dropdims(;dims=1)
        KeyedArray(;col = [:x, :y, :z], a = anames)
    end
    @aside anames = only(unique(axiskeys.(__)))[2]
    stack
    KeyedArray(;col = [:x, :y, :z], a = anames, b = bnames)
end

Note the use of @aside to propagate the keys from group ops, and the explicit check on all a keys being the same in each group.

This is basically unstack in DataFrames lingo. But a generalized version to match unstack could be nice.