Kinda depends on how I interpret your question.
Vector of nD Arrays is basically a list of pointers to arrays, so iterating through it inherently requires following a pointer. This is different from an (n+1)D Array, which can be stored densely in a single contiguous piece of memory. This has fairly significant performance implications, thus I am happy that Julia makes interacting with them explicitly different.
If you do want the more convenient indexing, you can use tools like
RecursiveArrayTools.jl which simplify the indexing for you.
cat added a new index at the end instead of at the beginning, it is because I used
dims=4. By the way, there is a literal version of
cat that is equivalent:
[vec_of_arr...;;;;] where the number of semicolons specifies the dimension along which you want to concatenate. Both
cat and the literal inherit this style from how array literals work in julia: each semicolon adds a new dimension (at the back of the list of indices).
Lastly, the order of indices, I claim, is consistent with the fact that Julia has Fortran style, not C style matrices. I.e. the first index is the fastest growing one, not the last index. E.g. see this example:
julia> a = [1 3; 2 4] # or maybe a = [1; 2;; 3; 4] to make it more explicit
julia> a, a, a, a # single-index lookup gives us the contiguous in-memory array
(1, 2, 3, 4)
julia> a[1,1], a[1,2] # modifying the last index causes discontinuous jumps
julia> a[1,1], a[2,1] # modifying the first index gives neighbors
Thus, the first index should refer to contiguous neighbors-in-memory, while the last index should refer to big jumps in memory, which hopefully makes what you are observing make sense.