Tests pass

Author: chriselrod

.github/workflows/ci.yml

@@ -52,6 +52,10 @@ jobs:
       - uses: julia-actions/setup-julia@latest
         with:
           version: '1.2'
+      - run: julia --color=yes -e 'using Pkg; VERSION >= v"1.5-" && !isdir(joinpath(DEPOT_PATH[1], "registries", "General")) && Pkg.Registry.add("General")'
+        shell: bash
+        env:
+          JULIA_PKG_SERVER: ""
       - run: julia --project=docs -e '
           using Pkg;
           Pkg.develop(PackageSpec(; path=pwd()));

src/ArrayInterface.jl

@@ -93,10 +93,13 @@ known_length(::Type{<:Tuple{Vararg{Any,N}}}) where {N} = N
 known_length(::Type{<:Number}) = 1
 known_length(::Type{<:AbstractCartesianIndex{N}}) where {N} = N
 known_length(::Type{T}) where {T} = _maybe_known_length(Base.IteratorSize(T), T)
-_maybe_known_length(::Base.HasShape, ::Type{T}) where {T} = prod(Static.maybe_static(known_size, size, T))
+@inline _prod_or_nothing(x, ::Tuple{}) = x
+@inline _prod_or_nothing(_, ::Tuple{Nothing,Vararg}) = nothing
+@inline _prod_or_nothing(x, y::Tuple{I,Vararg}) where {I} = _prod_or_nothing(x*first(y), Base.tail(y))
+_maybe_known_length(::Base.HasShape, ::Type{T}) where {T} = _prod_or_nothing(1, known_size(T))
 _maybe_known_length(::Base.IteratorSize, ::Type) = nothing
 function known_length(::Type{<:Iterators.Flatten{I}}) where {I}
-    known_length(I) * known_length(eltype(I))
+  _prod_or_nothing(1, (known_length(I),known_length(eltype(I))))
 end
 
 """

src/dimensions.jl

@@ -146,37 +146,39 @@ function to_parent_dims(::Type{T}, ::StaticInt{dim}) where {T,dim}
         throw_dim_error(T, dim)
     end
 end
-
-_nunderscore(::Val{N}) where {N} = ntuple(Compat.Returns(:_), Val(N))
+struct Returns{T}; x::T; end; @inline (r::Returns)(_::Vararg{Any,K}) where {K} = r.x
+_nunderscore(::Val{N}) where {N} = ntuple(Returns(nothing), Val(N))
 
 """
     has_dimnames(::Type{T}) -> StaticBool
 
 Returns `static(true)` if `x` has on or more named dimensions. If all dimensions correspond
-to `static(:_)`, then `static(false)` is returned.
+to `nothing`, then `static(false)` is returned.
 """
 Compat.@constprop :aggressive has_dimnames(x) = static(_is_named(known_dimnames(x)))
-_is_named(x::NTuple{N,Symbol}) where {N} = x !== _nunderscore(Val(N))
-_is_named(::Any) = true
+_is_named(x::Tuple{Nothing,Vararg}) = _is_named(Base.tail(x))
+_is_named(x::Tuple{Nothing}) = false
+_is_named(x::Tuple{Symbol,Vararg}) = true
+_is_named(x::Tuple{}) = true
 
 """
     known_dimnames(::Type{T}) -> Tuple{Vararg{Union{Symbol,Nothing}}}
     known_dimnames(::Type{T}, dim::Union{Int,StaticInt}) -> Union{Symbol,Nothing}
 
-Return the names of the dimensions for `x`. `:_` is used to indicate a dimension does not
+Return the names of the dimensions for `x`. `nothing` is used to indicate a dimension does not
 have a name.
 """
 @inline known_dimnames(x, dim::Integer) = _known_dimname(known_dimnames(x), canonicalize(dim))
 known_dimnames(x) = known_dimnames(typeof(x))
 known_dimnames(::Type{T}) where {T} = _known_dimnames(T, parent_type(T))
 _known_dimnames(::Type{T}, ::Type{T}) where {T} = _unknown_dimnames(Base.IteratorSize(T))
 _unknown_dimnames(::Base.HasShape{N}) where {N} = _nunderscore(Val(N))
-_unknown_dimnames(::Any) = (:_,)
+_unknown_dimnames(::Any) = (nothing,)
 function _known_dimnames(::Type{C}, ::Type{P}) where {C,P}
     eachop(_inbounds_known_dimname, to_parent_dims(C), known_dimnames(P))
 end
 @inline function _known_dimname(x::Tuple{Vararg{Any,N}}, dim::CanonicalInt) where {N}
-    @boundscheck (dim > N || dim < 1) && return :_
+    (dim > N || dim < 1) && return nothing
     return @inbounds(x[dim])
 end
 @inline _inbounds_known_dimname(x, dim) = @inbounds(_known_dimname(x, dim))
@@ -185,17 +187,17 @@ end
     dimnames(x) -> Tuple{Vararg{Union{Symbol,StaticSymbol}}}
     dimnames(x, dim::Union{Int,StaticInt}) -> Union{Symbol,StaticSymbol}
 
-Return the names of the dimensions for `x`. `:_` is used to indicate a dimension does not
+Return the names of the dimensions for `x`. `nothing` is used to indicate a dimension does not
 have a name.
 """
 @inline dimnames(x, dim::Integer) = _dimname(dimnames(x), canonicalize(dim))
 @inline dimnames(x) = _dimnames(has_parent(x), x)
 @inline function _dimnames(::True, x)
     eachop(_inbounds_dimname, to_parent_dims(x), dimnames(parent(x)))
 end
-_dimnames(::False, x) = ntuple(_->static(:_), Val(ndims(x)))
+_dimnames(::False, x) = ntuple(_->nothing, Val(ndims(x)))
 @inline function _dimname(x::Tuple{Vararg{Any,N}}, dim::CanonicalInt) where {N}
-    @boundscheck (dim > N || dim < 1) && return static(:_)
+    @boundscheck (dim > N || dim < 1) && return nothing
     return @inbounds(x[dim])
 end
 @inline _inbounds_dimname(x, dim) = @inbounds(_dimname(x, dim))

test/dimensions.jl

@@ -101,18 +101,18 @@ end
     @test @inferred(ArrayInterface.has_dimnames(typeof(view(x, :, 1, :)))) == true
     @test @inferred(dimnames(x)) === d
     @test @inferred(ArrayInterface.dimnames(z)) === (:x, static(:y))
-    @test @inferred(dimnames(parent(x))) === (static(:_), static(:_))
+    @test @inferred(dimnames(parent(x))) === (nothing, nothing)
     @test @inferred(dimnames(x')) === reverse(d)
-    @test @inferred(dimnames(y')) === (static(:_), static(:x))
+    @test @inferred(dimnames(y')) === (nothing, static(:x))
     @test @inferred(dimnames(PermutedDimsArray(x, (2, 1)))) === reverse(d)
     @test @inferred(dimnames(PermutedDimsArray(x', (2, 1)))) === d
     @test @inferred(dimnames(view(x, :, 1))) === (static(:x),)
-    @test @inferred(dimnames(view(x, :, :, :))) === (static(:x),static(:y), static(:_))
-    @test @inferred(dimnames(view(x, :, 1, :))) === (static(:x), static(:_))
+    @test @inferred(dimnames(view(x, :, :, :))) === (static(:x),static(:y), nothing)
+    @test @inferred(dimnames(view(x, :, 1, :))) === (static(:x), nothing)
     @test @inferred(dimnames(x, ArrayInterface.One())) === static(:x)
-    @test @inferred(dimnames(parent(x), ArrayInterface.One())) === static(:_)
-    @test @inferred(ArrayInterface.known_dimnames(Iterators.flatten(1:10))) === (:_,)
-    @test @inferred(ArrayInterface.known_dimnames(Iterators.flatten(1:10), static(1))) === :_
+    @test @inferred(dimnames(parent(x), ArrayInterface.One())) === nothing
+    @test @inferred(ArrayInterface.known_dimnames(Iterators.flatten(1:10))) === (nothing,)
+    @test @inferred(ArrayInterface.known_dimnames(Iterators.flatten(1:10), static(1))) === nothing
     @test @inferred(ArrayInterface.known_dimnames(z)) === (nothing, :y)
 end