disallow scalars in `cat`?

[JeffBezanson]

The cat functions are currently very permissive:

julia> vcat([1], :a)
2-element Array{Any,1}:
 1
  :a

This can lead to confusion when non-array collections are passed and mysteriously treated as scalars, e.g.

julia> vcat([1], keys(Dict()))
2-element Array{Any,1}:
 1
  Any[]

So a similar situation to what we had before in broadcast. We should make the corresponding change to cat and require all arguments to be array-like somehow.

[tkf]

How do you handle [1; 2], [[1]; [2]], etc.?

[BioTurboNick]

Coming from my issue #38019 documenting a few of these oddities, concatenating scalars along one dimension seems like a reasonable function of cat.

To this issue, if cat is defined only for arrays, maybe it's okay that non-array collections are treated like scalars?

Worth noting that in Julia 1.5, the example in the OP is less confusing:

vcat([1], keys(Dict()))
#=
2-element Array{Any,1}:
 1
  Base.KeySet for a Dict{Any,Any} with 0 entries
=#

[goretkin]

If I'm following, disallowing "scalars" (i.e. values of type eltype) would avoid this terribly inconsistent situation:

julia> vcat([(1,), (2,)], (3,))
3-element Vector{Tuple{Int64}}:
 (1,)
 (2,)
 (3,)

julia> vcat([[1,], [2,]], [3,])
3-element Vector{Any}:
  [1]
  [2]
 3

To concatenate one element, one can then use a one-element value, such as [x]. It would be nice, however, to have a generic spelling for concatenating one element to a static-sized array, such that the resulting size is inferred correctly.

[Seelengrab]

This came up on zulip today, with the following example:

how can these have the same result?

julia> struct Foo end;

julia> vcat([1,2,3], [Foo()])
4-element Vector{Any}:
1
2
3
Foo()

julia> vcat([1,2,3], Foo())
4-element Vector{Any}:
1
2
3
 Foo()

The docstring of vcat and hcat are very sparse on details about what happens and what is expected of their input - should this be documented (albeit with a warning that it will be removed in a future version of julia)?

[knuesel]

This also causes confusion with reduce, see here and here:

julia> typeof(reduce(vcat, [[1], [2]])) == typeof(reduce(vcat, [[1]]))
true

julia> typeof(reduce(vcat, [1, 2])) == typeof(reduce(vcat, [1]))
false