fix deprecations (#32)

* fix deprecations

* test on 0.6

Author: KristofferC

.travis.yml

@@ -2,8 +2,8 @@
 language: julia
 os:
   - linux
-  - osx
 julia:
+  - 0.6
   - nightly
 notifications:
   email: false

REQUIRE

@@ -1 +1,2 @@
-julia 0.6.0-pre
+julia 0.6
+Compat 0.30.0

src/BlockArrays.jl

@@ -11,6 +11,7 @@ export PseudoBlockArray, PseudoBlockMatrix, PseudoBlockVector, PseudoBlockVecOrM
 
 import Base: @propagate_inbounds, Array
 using Base.Cartesian
+using Compat
 
 include("abstractblockarray.jl")
 

src/abstractblockarray.jl

@@ -23,7 +23,7 @@ const AbstractBlockVecOrMat{T} = Union{AbstractBlockMatrix{T}, AbstractBlockVect
 
 block2string(b, s) = string(join(map(string,b), '×'), "-blocked ", Base.dims2string(s))
 Base.summary(a::AbstractBlockArray) = string(block2string(nblocks(a), size(a)), " ", typeof(a))
-Base.similar{T}(block_array::AbstractBlockArray{T}) = similar(block_array, T)
+Base.similar(block_array::AbstractBlockArray{T}) where {T} = similar(block_array, T)
 Base.IndexStyle(::Type{<:AbstractBlockArray}) = IndexCartesian()
 
 """
@@ -47,12 +47,12 @@ julia> nblocks(A, 3, 2)
 """
 nblocks(block_array::AbstractBlockArray, i::Int) = nblocks(block_array)[i]
 
-function nblocks{N}(block_array::AbstractBlockArray, i::Vararg{Int, N})
+function nblocks(block_array::AbstractBlockArray, i::Vararg{Int, N}) where {N}
     if N == 0
         throw(error("nblocks(A) not implemented"))
     end
     b = nblocks(block_array)
-    return ntuple(k-> b[i[k]], Val{N})
+    return ntuple(k-> b[i[k]], Val(N))
 end
 
 
@@ -71,7 +71,7 @@ julia> blocksize(A, 2, 1, 3)
 (4, 1, 2)
 ```
 """
-function blocksize{T, N}(X, A::AbstractBlockArray{T,N}, ::Vararg{Int, N})
+function blocksize(X, A::AbstractBlockArray{T,N}, ::Vararg{Int, N}) where {T,N}
     throw(error("blocksize for ", typeof(A), "is not implemented"))
 end
 
@@ -94,14 +94,14 @@ julia> A[Block(1, 1)]
  1.0  1.0
 ```
 """
-immutable Block{N, T}
+struct Block{N, T}
     n::NTuple{N, T}
 end
 
-Block{N, T}(n::Vararg{T, N}) = Block{N, T}(n)
+Block(n::Vararg{T, N}) where {N,T} = Block{N, T}(n)
 
-@inline function Block{N, T}(blocks::NTuple{N, Block{1, T}})
-    Block{N, T}(ntuple(i -> blocks[i].n[1], Val{N}))
+@inline function Block(blocks::NTuple{N, Block{1, T}}) where {N,T}
+    Block{N, T}(ntuple(i -> blocks[i].n[1], Val(N)))
 end
 
 """
@@ -131,7 +131,7 @@ julia> A[Block(1, 2)]
  5
 ```
 """
-function getblock{T, N}(A::AbstractBlockArray{T,N}, ::Vararg{Int, N})
+function getblock(A::AbstractBlockArray{T,N}, ::Vararg{Int, N}) where {T,N}
     throw("getblock for ", typeof(A), "is not implemented")
 end
 
@@ -158,11 +158,11 @@ julia> x
  1.0  1.0
 ```
 """
-getblock!{T, N}(X, A::AbstractBlockArray{T,N}, ::Vararg{Int, N}) = throw("getblock! for ", typeof(A), "is not implemented")
+getblock!(X, A::AbstractBlockArray{T,N}, ::Vararg{Int, N}) where {T,N} = throw("getblock! for ", typeof(A), "is not implemented")
 
-@inline getblock!{T, N}(X, A::AbstractBlockArray{T,N}, block::Block{N})             = getblock!(X, A, block.n...)
+@inline getblock!(X, A::AbstractBlockArray{T,N}, block::Block{N}) where {T,N}             = getblock!(X, A, block.n...)
 @inline getblock!(X, A::AbstractBlockVector, block::Block{1})                       = getblock!(X, A, block.n[1])
-@inline getblock!{T, N}(X, A::AbstractBlockArray{T, N}, block::Vararg{Block{1}, N}) = getblock!(X, A, (Block(block).n)...)
+@inline getblock!(X, A::AbstractBlockArray{T, N}, block::Vararg{Block{1}, N}) where {T,N} = getblock!(X, A, (Block(block).n)...)
 
 """
     setblock!(A, v, inds...)
@@ -184,24 +184,24 @@ julia> A
  3.0  4.0  │  0.0
 ```
 """
-setblock!{T, N}(A::AbstractBlockArray{T,N}, v, ::Vararg{Int, N}) = throw("setblock! for ", typeof(A), "is not implemented")
+setblock!(A::AbstractBlockArray{T,N}, v, ::Vararg{Int, N}) where {T,N} = throw("setblock! for ", typeof(A), "is not implemented")
 
-@inline setblock!{T, N}(A::AbstractBlockArray{T, N}, v, block::Block{N})            = setblock!(A, v, block.n...)
+@inline setblock!(A::AbstractBlockArray{T, N}, v, block::Block{N}) where {T,N}      = setblock!(A, v, block.n...)
 @inline setblock!(A::AbstractBlockVector, v, block::Block{1})                       = setblock!(A, v, block.n[1])
-@inline setblock!{T, N}(A::AbstractBlockArray{T, N}, v, block::Vararg{Block{1}, N}) = setblock!(A, v, (Block(blockindex).n)...)
+@inline setblock!(A::AbstractBlockArray{T, N}, v, block::Vararg{Block{1}, N}) where {T,N} = setblock!(A, v, (Block(block).n)...)
 
 
 """
     BlockBoundsError([A], [inds...])
 
 Thrown when a block indexing operation into a block array, `A`, tried to access an out-of-bounds block, `inds`.
 """
-immutable BlockBoundsError <: Exception
+struct BlockBoundsError <: Exception
     a::Any
     i::Any
     BlockBoundsError() = new()
     BlockBoundsError(a::AbstractBlockArray) = new(a)
-    BlockBoundsError(a::AbstractBlockArray, i::ANY) = new(a,i)
+    BlockBoundsError(a::AbstractBlockArray, @nospecialize(i)) = new(a,i)
 end
 
 function Base.showerror(io::IO, ex::BlockBoundsError)
@@ -232,15 +232,15 @@ ERROR: BlockBoundsError: attempt to access 2×2-blocked 2×3 BlockArrays.BlockAr
 [...]
 ```
 """
-@inline function blockcheckbounds{T, N}(A::AbstractBlockArray{T, N}, i::Vararg{Int, N})
+@inline function blockcheckbounds(A::AbstractBlockArray{T, N}, i::Vararg{Int, N}) where {T,N}
     if blockcheckbounds(Bool, A, i...)
         return
     else
         throw(BlockBoundsError(A, i))
     end
 end
 
-@inline function blockcheckbounds{T, N}(::Type{Bool}, A::AbstractBlockArray{T, N}, i::Vararg{Int, N})
+@inline function blockcheckbounds(::Type{Bool}, A::AbstractBlockArray{T, N}, i::Vararg{Int, N}) where {T,N}
     n = nblocks(A)
     k = 0
     for idx in 1:N # using enumerate here will allocate
@@ -275,9 +275,9 @@ julia> Array(A)
 function Base.Array(A::AbstractBlockArray) end
 
 # Convert to @generated...
-@propagate_inbounds Base.getindex{T, N}( block_arr::AbstractBlockArray{T, N}, block::Block{N})       =  getblock(block_arr, block.n...)
-@propagate_inbounds Base.setindex!{T, N}(block_arr::AbstractBlockArray{T, N}, v, block::Block{N})    =  setblock!(block_arr, v, block.n...)
+@propagate_inbounds Base.getindex( block_arr::AbstractBlockArray{T, N}, block::Block{N}) where {T,N}       =  getblock(block_arr, block.n...)
+@propagate_inbounds Base.setindex!(block_arr::AbstractBlockArray{T, N}, v, block::Block{N}) where {T,N}    =  setblock!(block_arr, v, block.n...)
 @propagate_inbounds Base.getindex( block_arr::AbstractBlockVector, block::Block{1})                  =  getblock(block_arr, block.n[1])
 @propagate_inbounds Base.setindex!(block_arr::AbstractBlockVector, v, block::Block{1})               =  setblock!(block_arr, v, block.n[1])
-@inline Base.getindex{T, N}(block_arr::AbstractBlockArray{T,N}, block::Vararg{Block{1}, N})     =  getblock(block_arr, (Block(block).n)...)
-@inline Base.setindex!{T, N}(block_arr::AbstractBlockArray{T,N}, v, block::Vararg{Block{1}, N}) =  setblock!(block_arr, v, (Block(block).n)...)
+@inline Base.getindex(block_arr::AbstractBlockArray{T,N}, block::Vararg{Block{1}, N}) where {T,N}     =  getblock(block_arr, (Block(block).n)...)
+@inline Base.setindex!(block_arr::AbstractBlockArray{T,N}, v, block::Vararg{Block{1}, N}) where {T,N} =  setblock!(block_arr, v, (Block(block).n)...)

src/blockarray.jl

@@ -49,17 +49,17 @@ julia> BlockArray(Matrix{Float64}, [1,3], [2,2])
  #undef  │  #undef  #undef  #undef  │
 ```
 """
-@inline function BlockArray{T, N, R <: AbstractArray{T,N}}(::Type{R}, block_sizes::Vararg{Vector{Int}, N})
+@inline function BlockArray(::Type{R}, block_sizes::Vararg{Vector{Int}, N}) where {T,N,R <: AbstractArray{T, N}}
     BlockArray(R, BlockSizes(block_sizes...))
 end
 
-function BlockArray{T, N, R <: AbstractArray{T,N}}(::Type{R}, block_sizes::BlockSizes{N})
+function BlockArray(::Type{R}, block_sizes::BlockSizes{N}) where {T,N,R <: AbstractArray{T, N}}
     n_blocks = nblocks(block_sizes)
     blocks = Array{R, N}(n_blocks)
     BlockArray{T,N,R}(blocks, block_sizes)
 end
 
-function BlockArray{T, N}(arr::AbstractArray{T, N}, block_sizes::Vararg{Vector{Int}, N})
+function BlockArray(arr::AbstractArray{T, N}, block_sizes::Vararg{Vector{Int}, N}) where {T,N}
     for i in 1:N
         if sum(block_sizes[i]) != size(arr, i)
             throw(DimensionMismatch("block size for dimension $i: $(block_sizes[i]) does not sum to the array size: $(size(arr, i))"))
@@ -68,7 +68,7 @@ function BlockArray{T, N}(arr::AbstractArray{T, N}, block_sizes::Vararg{Vector{I
     BlockArray(arr, BlockSizes(block_sizes...))
 end
 
-@generated function BlockArray{T, N}(arr::AbstractArray{T, N}, block_sizes::BlockSizes{N})
+@generated function BlockArray(arr::AbstractArray{T, N}, block_sizes::BlockSizes{N}) where {T,N}
     return quote
         block_arr = BlockArray(typeof(arr), block_sizes)
         @nloops $N i i->(1:nblocks(block_sizes, i)) begin
@@ -82,25 +82,25 @@ end
 end
 
 
-BlockArray{T, N, R <: AbstractArray{T,N}}(::Type{R}, block_sizes::Vararg{AbstractVector{Int}, N}) =
+BlockArray(::Type{R}, block_sizes::Vararg{AbstractVector{Int}, N}) where {T,N,R <: AbstractArray{T, N}} =
     BlockArray(R, Vector{Int}.(block_sizes)...)
 
-BlockArray{T, N}(arr::AbstractArray{T, N}, block_sizes::Vararg{AbstractVector{Int}, N}) =
+BlockArray(arr::AbstractArray{T, N}, block_sizes::Vararg{AbstractVector{Int}, N}) where {T,N} =
     BlockArray(arr, Vector{Int}.(block_sizes)...)
 
 ################################
 # AbstractBlockArray Interface #
 ################################
 
 @inline nblocks(block_array::BlockArray) = nblocks(block_array.block_sizes)
-@inline blocksize{T, N}(block_array::BlockArray{T,N}, i::Vararg{Int, N}) = blocksize(block_array.block_sizes, i)
+@inline blocksize(block_array::BlockArray{T,N}, i::Vararg{Int, N}) where {T,N} = blocksize(block_array.block_sizes, i)
 
-@inline function getblock{T, N}(block_arr::BlockArray{T,N}, block::Vararg{Int, N})
+@inline function getblock(block_arr::BlockArray{T,N}, block::Vararg{Int, N}) where {T,N}
     @boundscheck blockcheckbounds(block_arr, block...)
     block_arr.blocks[block...]
 end
 
-@inline function Base.getindex{T, N}(block_arr::BlockArray{T,N}, blockindex::BlockIndex{N})
+@inline function Base.getindex(block_arr::BlockArray{T,N}, blockindex::BlockIndex{N}) where {T,N}
     @boundscheck checkbounds(block_arr.blocks, blockindex.I...)
     @inbounds block = block_arr.blocks[blockindex.I...]
     @boundscheck checkbounds(block, blockindex.α...)
@@ -113,24 +113,24 @@ end
 # AbstractArray Interface #
 ###########################
 
-@inline function Base.similar{T,N,T2}(block_array::BlockArray{T,N}, ::Type{T2})
+@inline function Base.similar(block_array::BlockArray{T,N}, ::Type{T2}) where {T,N,T2}
     BlockArray(similar(block_array.blocks, Array{T2, N}), copy(block_array.block_sizes))
 end
 
-@generated function Base.size{T,N}(arr::BlockArray{T,N})
+@generated function Base.size(arr::BlockArray{T,N}) where {T,N}
     exp = Expr(:tuple, [:(arr.block_sizes[$i][end] - 1) for i in 1:N]...)
     return quote
         @inbounds return $exp
     end
 end
 
-@inline function Base.getindex{T, N}(block_arr::BlockArray{T, N}, i::Vararg{Int, N})
+@inline function Base.getindex(block_arr::BlockArray{T, N}, i::Vararg{Int, N}) where {T,N}
     @boundscheck checkbounds(block_arr, i...)
     @inbounds v = block_arr[global2blockindex(block_arr.block_sizes, i)]
     return v
 end
 
-@inline function Base.setindex!{T, N}(block_arr::BlockArray{T, N}, v, i::Vararg{Int, N})
+@inline function Base.setindex!(block_arr::BlockArray{T, N}, v, i::Vararg{Int, N}) where {T,N}
     @boundscheck checkbounds(block_arr, i...)
     @inbounds block_arr[global2blockindex(block_arr.block_sizes, i)] = v
     return block_arr
@@ -140,7 +140,7 @@ end
 # Indexing #
 ############
 
-function _check_setblock!{T,N}(block_arr::BlockArray{T, N}, v, block::NTuple{N, Int})
+function _check_setblock!(block_arr::BlockArray{T, N}, v, block::NTuple{N, Int}) where {T,N}
     for i in 1:N
         if size(v, i) != blocksize(block_arr.block_sizes, i, block[i])
             throw(DimensionMismatch(string("tried to assign $(size(v)) array to ", blocksize(block_arr, block...), " block")))
@@ -149,22 +149,22 @@ function _check_setblock!{T,N}(block_arr::BlockArray{T, N}, v, block::NTuple{N,
 end
 
 
-@inline function setblock!{T, N}(block_arr::BlockArray{T, N}, v, block::Vararg{Int, N})
+@inline function setblock!(block_arr::BlockArray{T, N}, v, block::Vararg{Int, N}) where {T,N}
     @boundscheck blockcheckbounds(block_arr, block...)
     @boundscheck _check_setblock!(block_arr, v, block)
     @inbounds block_arr.blocks[block...] = v
     return block_arr
 end
 
-@propagate_inbounds function Base.setindex!{T,N}(block_array::BlockArray{T, N}, v, block_index::BlockIndex{N})
+@propagate_inbounds function Base.setindex!(block_array::BlockArray{T, N}, v, block_index::BlockIndex{N}) where {T,N}
     getblock(block_array, block_index.I...)[block_index.α...] = v
 end
 
 ########
 # Misc #
 ########
 
-@generated function Base.Array{T,N,R}(block_array::BlockArray{T, N, R})
+@generated function Base.Array(block_array::BlockArray{T, N, R}) where {T,N,R}
     # TODO: This will fail for empty block array
     return quote
         block_sizes = block_array.block_sizes
@@ -179,7 +179,7 @@ end
     end
 end
 
-@generated function Base.copy!{T, N, R <: AbstractArray}(block_array::BlockArray{T, N, R}, arr::R)
+@generated function Base.copy!(block_array::BlockArray{T, N, R}, arr::R) where {T,N,R <: AbstractArray}
     return quote
         block_sizes = block_array.block_sizes
 

src/blockindices.jl

@@ -25,7 +25,7 @@ julia> a[BlockIndex((2,2), (2,3))]
 20
 ```
 """
-immutable BlockIndex{N}
+struct BlockIndex{N}
     I::NTuple{N, Int}
     α::NTuple{N, Int}
 end
@@ -34,7 +34,7 @@ end
 @inline BlockIndex(a::NTuple, b::Int) = BlockIndex(a, (b,))
 @inline BlockIndex(a::Int, b::NTuple) = BlockIndex((a,), b)
 
-@generated function BlockIndex{M, N}(I::NTuple{N, Int}, α::NTuple{M, Int})
+@generated function BlockIndex(I::NTuple{N, Int}, α::NTuple{M, Int}) where {M,N}
     @assert M < N
     α_ex = Expr(:tuple, [k <= M ? :(α[$k]) : :(1) for k = 1:N]...)
     return quote
@@ -49,7 +49,7 @@ end
 
 Converts from global indices `inds` to a `BlockIndex`.
 """
-@generated function global2blockindex{N}(block_sizes::BlockSizes{N}, i::NTuple{N, Int})
+@generated function global2blockindex(block_sizes::BlockSizes{N}, i::NTuple{N, Int}) where {N}
     block_index_ex = Expr(:tuple, [:(_find_block(block_sizes, $k, i[$k])) for k = 1:N]...)
     I_ex = Expr(:tuple, [:(block_index[$k][1]) for k = 1:N]...)
     α_ex = Expr(:tuple, [:(block_index[$k][2]) for k = 1:N]...)
@@ -67,7 +67,7 @@ end
 
 Converts from a block index to a tuple containing the global indices
 """
-@generated function blockindex2global{N}(block_sizes::BlockSizes{N}, block_index::BlockIndex{N})
+@generated function blockindex2global(block_sizes::BlockSizes{N}, block_index::BlockIndex{N}) where {N}
     ex = Expr(:tuple, [:(block_sizes[$k, block_index.I[$k]] + block_index.α[$k] - 1) for k = 1:N]...)
     return quote
         $Expr(:meta, :inline)

src/blocksizes.jl

@@ -3,21 +3,19 @@
 ##############
 
 # Keeps track of the (cumulative) sizes of all the blocks in the `BlockArray`.
-immutable BlockSizes{N}
+struct BlockSizes{N}
     cumul_sizes::NTuple{N, Vector{Int}}
     # Takes a tuple of sizes, accumulates them and create a `BlockSizes`
 end
 
-function BlockSizes{N}(sizes::Vararg{Vector{Int}, N}) where {N}
-    cumul_sizes = ntuple(k -> _cumul_vec(sizes[k]), Val{N})
+function BlockSizes(sizes::Vararg{Vector{Int}, N}) where {N}
+    cumul_sizes = ntuple(k -> _cumul_vec(sizes[k]), Val(N))
     return BlockSizes(cumul_sizes)
 end
 
-@inline BlockSizes{N}(sizes::Vararg{Vector{Int}, N}) = BlockSizes{N}(sizes...)
-
 Base.:(==)(a::BlockSizes, b::BlockSizes) = a.cumul_sizes == b.cumul_sizes
 
-function _cumul_vec{T}(v::Vector{T})
+function _cumul_vec(v::Vector{T}) where {T}
     v_cumul = similar(v, length(v) + 1)
     z = one(T)
     v_cumul[1] = z
@@ -34,12 +32,12 @@ end
 @propagate_inbounds blocksize(block_sizes::BlockSizes, i, j) = block_sizes[i, j+1] - block_sizes[i, j]
 
 # ntuple with Val was slow here. @generated it is!
-@generated function blocksize{N}(block_sizes::BlockSizes{N}, i::NTuple{N, Int})
+@generated function blocksize(block_sizes::BlockSizes{N}, i::NTuple{N, Int}) where {N}
     exp = Expr(:tuple, [:(blocksize(block_sizes, $k, i[$k])) for k in 1:N]...)
     return exp
 end
 
-function Base.show{N}(io::IO, block_sizes::BlockSizes{N})
+function Base.show(io::IO, block_sizes::BlockSizes{N}) where {N}
     if N == 0
         print(io, "[]")
     else
@@ -70,7 +68,7 @@ end
     return block, i - cum_size
 end
 
-@generated function nblocks{N}(block_sizes::BlockSizes{N})
+@generated function nblocks(block_sizes::BlockSizes{N}) where {N}
     ex = Expr(:tuple, [:(nblocks(block_sizes, $i)) for i in 1:N]...)
     return quote
         @inbounds return $ex
@@ -81,15 +79,15 @@ end
 
 
 # ntuple is yet again slower
-@generated function Base.copy{N}(block_sizes::BlockSizes{N})
+@generated function Base.copy(block_sizes::BlockSizes{N}) where {N}
     exp = Expr(:tuple, [:(copy(block_sizes[$k])) for k in 1:N]...)
     return quote
         BlockSizes($exp)
     end
 end
 
 # Computes the global range of an Array that corresponds to a given block_index
-@generated function globalrange{N}(block_sizes::BlockSizes{N}, block_index::NTuple{N, Int})
+@generated function globalrange(block_sizes::BlockSizes{N}, block_index::NTuple{N, Int}) where {N}
     indices_ex = Expr(:tuple, [:(block_sizes[$i, block_index[$i]]:block_sizes[$i, block_index[$i] + 1] - 1) for i = 1:N]...)
     return quote
         $Expr(:meta, :inline)