fix zero-dim similar

Author: ogauthe

src/blockarray.jl

@@ -453,6 +453,10 @@ end
 
 @inline Base.similar(B::BlockArray, ::Type{T}) where {T} = _BlockArray(similar.(blocks(B), T), axes(B))
 
+# specific 0-dim
+@inline Base.similar(B::BlockArray{<:Any,0}, ::Type{T}) where {T} = BlockArray(similar(only(blocks(B)), T), ())
+@inline Base.similar(::BlockArray, ::Type{T}, ::Tuple{}) where {T} = BlockArray(Array{T}(undef))
+
 const OffsetAxis = Union{Integer, UnitRange, Base.OneTo, Base.IdentityUnitRange}
 
 # avoid ambiguities

src/blockedarray.jl

@@ -203,6 +203,9 @@ function Base.similar(block_array::BlockedArray{T,N}, ::Type{T2}) where {T,N,T2}
     BlockedArray(similar(block_array.blocks, T2), axes(block_array))
 end
 
+# specific zero dim
+Base.similar(::BlockedArray{<:Any,0}, ::Type{T}, ::Tuple{}) where {T} = BlockedArray(Array{T}(undef))
+
 to_axes(r::AbstractUnitRange) = r
 to_axes(n::Integer) = Base.oneto(n)
 

test/test_blockarrays.jl

@@ -343,13 +343,18 @@ end
             view(ret)[] = 0
             @test ret[] == 0
 
-            ret = BlockArrays.BlockArray(zeros())
+            ret = BlockArray(zeros())
             @test ret isa BlockArray{Float64, 0}
             @test size(ret) == ()
             @test all(iszero, ret)
             @test ret[Block()] == zeros()
 
-            ret = BlockArrays.BlockArray(zeros(1,1))
+            @test similar(ret) isa BlockArray{Float64, 0}
+            @test similar(ret, Float32) isa BlockArray{Float32, 0}
+            @test similar(ret, Float32, ()) isa BlockArray{Float32, 0}
+            @test similar(ret, Float32, (blockedrange([1]),)) isa BlockVector{Float32}
+
+            ret = BlockArray(zeros(1,1))
             @test reshape(ret, ()) isa AbstractBlockArray{Float64, 0}  # may be BlockedArray
             @test size(reshape(ret, ())) == ()
 
@@ -373,7 +378,12 @@ end
             @test all(iszero, ret)
             @test ret[Block()] == zeros()
 
-            ret = BlockArrays.BlockedArray(zeros(1,1))
+            @test similar(ret) isa BlockedArray{Float64, 0}
+            @test similar(ret, Float32) isa BlockedArray{Float32, 0}
+            @test similar(ret, Float32, ()) isa BlockedArray{Float32, 0}
+            @test similar(ret, Float32, (blockedrange([1]),)) isa BlockedVector{Float32}
+
+            ret = BlockedArray(zeros(1,1))
             @test reshape(ret, ()) isa BlockedArray{Float64, 0}
             @test size(reshape(ret, ())) == ()
         end