[SparseArrayDOKs] [ENHANCEMENT] resize! and @maybe_grow

[mtfishman]

It would be helpful to make the size of SparseArrayDOK a mutable field (and maybe define an IsResizable trait).

Then we can have an API for setting the size of a SparseArrayDOK in-place with:

function resize!(a::SparseArrayDOK{<:Any,N}, new_size::NTuple{N,Integer}) where {N}
  a.dims = new_size
  return a
end

and additionally functionality for setting an element and allowing the array to grow as needed:

function setindex_maybe_grow!(a::SparseArrayDOK{<:Any,N}, value, index::NTuple{N,Int}...) where {N}
  if any(index .> size(a))
    resize!(a, max.(index, size(a)))
  end
  a[index...] = value
  return a
end

which could have an external API based around annotating calls to setindex! with a macro @maybe_grow:

a = SparseArrayDOK{Float64}(3, 3)
a[4, 4] = 44.0 # Calls `setindex!, errors as out-of-bounds.
@maybe_grow a[4, 4] = 44.0 # Calls `setindex_maybe_grow!`, resizes to `(4, 4)` and sets the element.

@emstoudenmire

[emstoudenmire]

I like this proposal & will try to work on it if I can figure out the macro part. Other name suggestions could be @auto_resize or @allow_resize.

[mtfishman]

I like the terminology grow instead of resize since it makes it clearer that it will only (potentially) grow the array size, and never shrink it.

[emstoudenmire]

Some thought may be needed about constructors also, given this system. While the following works:

m = SparseArrayDOK{Float64,2}((0, 0))

the default constructor errors:

m = SparseArrayDOK{Float64,2}() # gives an error

It's not clear to me whether it's best to require users to give an initial size if they are going to use the grow feature, and if they would give (0,0) then it might be good to let them default initialize, unless that causes other problems.

[mtfishman]

I think we should just follow the convention followed by other Julia AbstractArray constructors, which is that if no size is specified it constructs a zero-dimensional SparseArrayDOK:

julia> Array{Float64}(undef)
0-dimensional Array{Float64, 0}:
2.225328024e-314

julia> zeros()
0-dimensional Array{Float64, 0}:
0.0

SparseArrayDOK{Float64,2}() therefore shouldn't be allowed:

julia> Array{Float64,2}(undef)
ERROR: MethodError: no method matching Matrix{Float64}(::UndefInitializer)

Closest candidates are:
  Matrix{T}(::UndefInitializer, ::Tuple{Int64, Int64}) where T
   @ Core boot.jl:487
  Matrix{T}(::UndefInitializer, ::Int64, ::Int64) where T
   @ Core boot.jl:479
  Array{T, N}(::UndefInitializer, ::Tuple{Vararg{Int64, N}}) where {T, N}
   @ Core boot.jl:489
  ...

Stacktrace:
 [1] top-level scope
   @ REPL[4]:1

and users should be required to write SparseArrayDOK{Float64,2}(0, 0).