Change kwarg name

Author: mtfishman

src/abstractsparsearray.jl

@@ -37,7 +37,7 @@ end
 # ----------------------------
 
 """
-    sparse(storage::Union{AbstractDict,AbstractDictionary}, dims...[; getunstoredfun])
+    sparse(storage::Union{AbstractDict,AbstractDictionary}, dims...[; getunstored])
 
 Construct an `N`-dimensional [`SparseArrayDOK`](@ref) containing elements of type `T`. Both
 `T` and `N` can either be supplied explicitly or be determined by the `storage` and the
@@ -64,7 +64,7 @@ end
 using Random: Random, AbstractRNG, default_rng
 
 @doc """
-    sparsezeros([T::Type], dims[; getunstoredfun]) -> A::SparseArrayDOK{T}
+    sparsezeros([T::Type], dims[; getunstored]) -> A::SparseArrayDOK{T}
 
 Create an empty size `dims` sparse array.
 The optional `T` argument specifies the element type, which defaults to `Float64`.

src/oneelementarray.jl

@@ -8,13 +8,13 @@ struct OneElementArray{T,N,I,A,F} <: AbstractSparseArray{T,N}
   value::T
   index::I
   axes::A
-  getunstoredfun::F
+  getunstored::F
   global @inline function _OneElementArray(
-    value::T, index::I, axes::A, getunstoredfun::F
+    value::T, index::I, axes::A, getunstored::F
   ) where {T,I,A,F}
     N = length(axes)
     @assert N == length(index)
-    return new{T,N,I,A,F}(value, index, axes, getunstoredfun)
+    return new{T,N,I,A,F}(value, index, axes, getunstored)
   end
 end
 
@@ -23,9 +23,9 @@ using DerivableInterfaces: @array_aliases
 @array_aliases OneElementArray
 
 function OneElementArray{T,N}(
-  value, index::NTuple{N,Int}, axes::NTuple{N,AbstractUnitRange}; getunstoredfun=getzero
+  value, index::NTuple{N,Int}, axes::NTuple{N,AbstractUnitRange}; getunstored=getzero
 ) where {T,N}
-  return _OneElementArray(convert(T, value), index, axes, getunstoredfun)
+  return _OneElementArray(convert(T, value), index, axes, getunstored)
 end
 
 function OneElementArray{<:Any,N}(
@@ -104,9 +104,9 @@ end
 
 # Fix ambiguity errors.
 function OneElementArray{T,0}(
-  value, index::Tuple{}, axes::Tuple{}; getunstoredfun=getzero
+  value, index::Tuple{}, axes::Tuple{}; getunstored=getzero
 ) where {T}
-  return _OneElementArray(convert(T, value), index, axes, getunstoredfun)
+  return _OneElementArray(convert(T, value), index, axes, getunstored)
 end
 function OneElementArray{<:Any,0}(
   value::T, index::Tuple{}, axes::Tuple{}; kwargs...
@@ -295,7 +295,7 @@ function getstoredindex(a::OneElementArray, I::Int...)
   return storedvalue(a)
 end
 function getunstoredindex(a::OneElementArray, I::Int...)
-  return a.getunstoredfun(a, I...)
+  return a.getunstored(a, I...)
 end
 function setstoredindex!(a::OneElementArray, value, I::Int...)
   return error("`OneElementArray` is immutable, you can't set elements.")

src/sparsearraydok.jl

@@ -18,19 +18,19 @@ optionally with a function of type `F` to instantiate non-stored elements.
 struct SparseArrayDOK{T,N,F} <: AbstractSparseArray{T,N}
   storage::DOKStorage{T,N}
   size::NTuple{N,Int}
-  getunstoredfun::F
+  getunstored::F
   global @inline function _SparseArrayDOK(
-    storage::DOKStorage{T,N}, size::Dims{N}, getunstoredfun::F
+    storage::DOKStorage{T,N}, size::Dims{N}, getunstored::F
   ) where {T,N,F}
-    return new{T,N,F}(storage, size, getunstoredfun)
+    return new{T,N,F}(storage, size, getunstored)
   end
 end
 
 # Constructors
 # ------------
 """
-    SparseArrayDOK{T}(undef, dims...[; getunstoredfun])
-    SparseArrayDOK{T,N}(undef, dims...[; getunstoredfun])
+    SparseArrayDOK{T}(undef, dims...[; getunstored])
+    SparseArrayDOK{T,N}(undef, dims...[; getunstored])
 
 Construct an uninitialized `N`-dimensional [`SparseArrayDOK`](@ref) containing
 elements of type `T`. `N` can either be supplied explicitly, or be determined by
@@ -39,12 +39,12 @@ the length or number of `dims`.
 SparseArrayDOK{T,N}(::UndefInitializer, dims; kwargs...)
 
 function SparseArrayDOK{T,N}(
-  ::UndefInitializer, dims::Dims; getunstoredfun=getzero
+  ::UndefInitializer, dims::Dims; getunstored=getzero
 ) where {T,N}
   (length(dims) == N && all(≥(0), dims)) ||
     throw(ArgumentError("Invalid dimensions: $dims"))
   storage = DOKStorage{T,N}()
-  return _SparseArrayDOK(storage, dims, getunstoredfun)
+  return _SparseArrayDOK(storage, dims, getunstored)
 end
 function SparseArrayDOK{T,N}(::UndefInitializer, dims::Vararg{Int,N}; kwargs...) where {T,N}
   return SparseArrayDOK{T,N}(undef, dims; kwargs...)
@@ -56,8 +56,8 @@ function SparseArrayDOK{T}(::UndefInitializer, dims::Vararg{Int,N}; kwargs...) w
   return SparseArrayDOK{T,N}(undef, dims; kwargs...)
 end
 
-function set_getunstoredfun(a::SparseArrayDOK, f)
-  @set a.getunstoredfun = f
+function set_getunstored(a::SparseArrayDOK, f)
+  @set a.getunstored = f
   return a
 end
 
@@ -83,7 +83,7 @@ function getstoredindex(a::SparseArrayDOK, I::Int...)
   return storage(a)[CartesianIndex(I)]
 end
 function getunstoredindex(a::SparseArrayDOK, I::Int...)
-  return a.getunstoredfun(a, I...)
+  return a.getunstored(a, I...)
 end
 function setstoredindex!(a::SparseArrayDOK, value, I::Int...)
   # TODO: Have a way to disable this check, analogous to `checkbounds`,