Allow resize!(A, Block(0)) to make empty (#210)

* Support resize!(a, Block(0)) to make empty

* Special case isless with Block{1}

* add BlockVector resize!

* add printing tests

Author: dlfivefifty

Project.toml

@@ -1,6 +1,6 @@
 name = "BlockArrays"
 uuid = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
-version = "0.16.14"
+version = "0.16.15"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"

src/blockarray.jl

@@ -471,3 +471,17 @@ Base.reshape(block_array::BlockArray, axes::Tuple{Union{Integer,Base.OneTo}, Var
     reshape(PseudoBlockArray(block_array), axes)
 Base.reshape(block_array::BlockArray, dims::Tuple{Vararg{Union{Int,Colon}}}) =
     reshape(PseudoBlockArray(block_array), dims)
+
+"""
+resize!(a::BlockVector, N::Block) -> PseudoBlockVector
+
+Resize `a` to contain the first `N` blocks, returning a new `BlockVector` sharing
+memory with `a`. If `N` is smaller than the current
+collection block length, the first `N` blocks will be retained. `N` is not allowed to be larger.
+"""
+function resize!(a::BlockVector, N::Block{1})
+    ax = axes(a,1)
+    Ni = Int(N)
+    _BlockArray(resize!(a.blocks, Ni), (ax[Block.(Base.OneTo(Ni))],))
+end
+

src/blockindices.jl

@@ -20,12 +20,15 @@ julia> A[Block(1, 1)]
 struct Block{N, T}
     n::NTuple{N, T}
     Block{N, T}(n::NTuple{N, T}) where {N, T} = new{N, T}(n)
+    Block{1, T}(n::Tuple{T}) where T = new{1, T}(n)
 end
 
-
-Block{N, T}(n::Vararg{T, N}) where {N,T} = Block{N, T}(n)
+Block{N, T}(n::Tuple{Vararg{Any, N}}) where {N,T} = Block{N, T}(convert(NTuple{N,T}, n))
+Block{N, T}(n::Vararg{Any, N}) where {N,T} = Block{N, T}(n)
 Block{N}(n::Vararg{T, N}) where {N,T} = Block{N, T}(n)
-Block() = Block{0,Int}()
+Block{1, T}(n::Tuple{Any}) where {N,T} = Block{1, T}(convert(Tuple{T}, n))
+Block{0}() = Block{0,Int}()
+Block() = Block{0}()
 Block(n::Vararg{T, N}) where {N,T} = Block{N, T}(n)
 Block{1}(n::Tuple{T}) where {T} = Block{1, T}(n)
 Block{N}(n::NTuple{N, T}) where {N,T} = Block{N, T}(n)
@@ -77,6 +80,7 @@ end
 _isless(ret, ::Tuple{}, ::Tuple{}) = ifelse(ret==1, true, false)
 icmp(a, b) = ifelse(isless(a,b), 1, ifelse(a==b, 0, -1))
 @inline isless(I1::Block{N}, I2::Block{N}) where {N} = _isless(0, I1.n, I2.n)
+@inline isless(I1::Block{1}, I2::Block{1}) = isless(Integer(I1), Integer(I2))
 
 # conversions
 convert(::Type{T}, index::Block{1}) where {T<:Number} = convert(T, index.n[1])

src/pseudo_blockarray.jl

@@ -258,10 +258,15 @@ collection block length, the first `N` blocks will be retained. `N` is not allow
 """
 function resize!(a::PseudoBlockVector, N::Block{1})
     ax = axes(a,1)
-    PseudoBlockVector(resize!(a.blocks, last(ax[N])), (ax[Block.(Base.OneTo(Int(N)))],))
+    if iszero(Int(N))
+        PseudoBlockVector(resize!(a.blocks, 0), (ax[Block.(Base.OneTo(0))],))
+    else
+        PseudoBlockVector(resize!(a.blocks, last(ax[N])), (ax[Block.(Base.OneTo(Int(N)))],))
+    end
 end
 
 
+
 ###########################
 # Strided Array interface #
 ###########################

test/test_blockarrays.jl

@@ -606,5 +606,14 @@ end
         b = resize!(a,Block(2))
         @test b == 1:3
         @test_throws BoundsError a[4] # length of a.blocks has changed
+        c = resize!(b,Block(0))
+        @test isempty(c)
+
+        a = BlockVector(collect(1:6), 1:3)
+        b = resize!(a,Block(2))
+        @test b == 1:3
+        @test_throws BoundsError a[4] # length of a.blocks has changed
+        c = resize!(b,Block(0))
+        @test isempty(c)
     end
 end

test/test_blockindices.jl

@@ -91,6 +91,19 @@ import BlockArrays: BlockIndex, BlockIndexRange, BlockSlice
 
         @test intersect(Block.(2:5), Block.(3:6)) ≡ Block.(3:5)
     end
+
+    @testset "print" begin
+        @test stringmime("text/plain", Block()) == "Block()"
+        @test stringmime("text/plain", Block(1)) == "Block(1)"
+        @test stringmime("text/plain", Block(1,2)) == "Block(1, 2)"
+        @test stringmime("text/plain", Block{0}()) == "Block()"
+        @test stringmime("text/plain", Block{1}(1)) == "Block(1)"
+        @test stringmime("text/plain", Block{2}(1,2)) == "Block(1, 2)"
+
+        @test stringmime("text/plain", Block{0,BigInt}()) == "Block{0, BigInt}(())"
+        @test stringmime("text/plain", Block{1,BigInt}(1)) == "Block{1, BigInt}((1,))"
+        @test stringmime("text/plain", Block{2}(1,2)) == "Block(1, 2)"
+    end
 end
 
 @testset "BlockedUnitRange" begin