Factor out new code

Author: Will Tebbutt

src/tables.jl

@@ -37,23 +37,24 @@ Tables.columnaccess(::Type{<:KeyedArray{T,N,AT}}) where {T,N,AT} =
 function Tables.columns(A::Union{KeyedArray, NdaKa})
     L = hasnames(A) ? (dimnames(A)..., :value) :
         (ntuple(d -> Symbol(:dim_,d), ndims(A))..., :value)
-    R = keys_or_axes(A)
+    G = _get_keys_columns(A)
+    C = (G..., vec(parent(A)))
+    NamedTuple{L}(C)
+end
 
-    # R_inds comprises the indices for each of the keys.
-    
+# indices is a tuple, the dth element of which is an index for the dth column of R.
+# By using these indices, and mapping over the columns of R, the compiler seems to
+# successfully infer the types in G, because it knows the element types of each column
+# of R, so is presumably able to unroll the call to map.
+# The previous implementation called `Iterators.product` on `R` and pulled out
+# the dth element of `indices`, whose type it could not infer.
+function _get_keys_columns(A)
+    R = keys_or_axes(A)
     R_inds = map(eachindex, R)
-    # indices is a tuple, the dth element of which is an index for the dth column of R.
-    # By using these indices, and mapping over the columns of R, the compiler seems to
-    # successfully infer the types in G, because it knows the element types of each column
-    # of R, so is presumably able to unroll the call to map.
-    # The previous implementation called `Iterators.product` on `R` and pulled out
-    # the dth element of `indices`, whose type it could not infer.
-    G = map(
+    return map(
         (r, d) -> vec([r[indices[d]] for indices in Iterators.product(R_inds...)]),
         R, ntuple(identity, length(R)),
     )
-    C = (G..., vec(parent(A)))
-    NamedTuple{L}(C)
 end
 
 function Tables.Schema(nt::NamedTuple) # 🏴‍☠️