Trying to construct a nonempty `<:Array{Union{}}` should throw

[nsajko]

julia> Vector{Union{}}(undef, 1)
1-element Vector{Union{}}:
 #undef

Two issues:

1. an array of type <:AbstractArray{Union{}} must always be empty (because Union{} never has instances). So why is the object being show-n as "1-element Vector{Union{}}"?

2. Given that <:AbstractArray{Union{}} can never have elements (or, more precisely I guess, iterate will either return nothing or throw), trying to construct such an array with a nonzero length should throw.

The example above is by @tpapp in #52385 (comment)

[Keno]

1. an array of type <:AbstractArray{Union{}} must always be empty (because Union{} never has instances)

Union{} isn't the only type that doesn't have instances. Arrays have the implicit #undef behavior, so the implemented behavior is consistent. Of course some people (including myself) have argued before that implicit undef-ness is both bad and unnecessary, but as is, there's nothing inconsistent about this.

trying to construct such an array with a nonzero length should throw.

Again, I don't think this is necessarily a given.

[nsajko]

IMO the #undef behavior is a red herring here.

isempty returning false and length returning nonzero is a correctness bug here, and it's inconsistent with eltype(Vector{Union{}}) == Union{}:

julia> v = Vector{Union{}}(undef, 1)
1-element Vector{Union{}}:
 #undef

julia> isempty(v)
false

julia> length(v)
1

julia> eltype(v)
Union{}

The problem is that code (including user code) could/should be able to assume that isempty always returns true for AbstractArray{Union{}} on accord of eltype returning Union{}. Because a value such that value isa Union{} can't exist, leading to the behavior stated above, where iterate can only ever either return nothing or throw.

[nsajko]

Otherwise the semantics of isempty or length are not clear.

[nsajko]

Perhaps, instead of making the constructors throw, isempty and length methods should be overloaded to always return true and zero respectively?

[jakobnissen]

Is it actually possible to quickly test if a type can have no instances? If not, there is no point.

[nsajko]

It's possible to test at compile time that a type parameter is the bottom type. I.e., overload some methods. What more is necessary?

[Keno]

IMO the #undef behavior is a red herring here.

Is it? How is this any different than?

julia> v = Vector{Any}(undef, 1)
1-element Vector{Any}:
 #undef

julia> isempty(v)
false

julia> length(v)
1

or

julia> struct Uninhabited
           u::Uninhabited
       end

julia> v = Vector{Uninhabited}(undef, 1)
1-element Vector{Uninhabited}:
 #undef

julia> isempty(v)
false

julia> length(v)
1

The problem is that code (including user code) could/should be able to assume that isempty is always true for AbstractArray{Union{}} on accord of eltype returning Union{}.

Why is this desirable?

[Keno]

Is it actually possible to quickly test if a type can have no instances? If not, there is no point.

No, this is not computable.

[MasonProtter]

No, this should not throw, things like this are sometimes useful. Here's an example of how one might want to implement map using BangBang.jl and this type of vector:

using BangBang

function mymap(f, v::Array)
    out = similar(v, Union{})
    for i in eachindex(out, v)
        out = setindex!!(out, f(v[i]), i)
    end
    out
end

This way, you start with the narrowest possible initial eltype and then widen it as needed. In practice, it'd be better to use MicroCollections.jl for the initial array (and some other optimizations like unrolling the first couple steps of the loop to try and get type stability), but the wider point is just that there are cases where you might want to be able to construct this object, so it seems weird to deliberately disallow it.