Update for TypeParameterAccessors.jl v0.4

Author: mtfishman

Project.toml

@@ -44,7 +44,7 @@ SparseArraysBase = "0.5"
 SplitApplyCombine = "1.2.3"
 TensorAlgebra = "0.3.2"
 Test = "1.10"
-TypeParameterAccessors = "0.2, 0.3, 0.4"
+TypeParameterAccessors = "0.4"
 julia = "1.10"
 
 [extras]

src/BlockArraysExtensions/blockedunitrange.jl

@@ -29,6 +29,9 @@ axis(a::AbstractVector) = axes(a, 1)
 function eachblockaxis(a::AbstractVector)
   return map(axis, blocks(a))
 end
+function blockaxistype(a::AbstractVector)
+  return eltype(eachblockaxis(a))
+end
 
 # Take a collection of axes and mortar them
 # into a single blocked axis.

src/abstractblocksparsearray/unblockedsubarray.jl

@@ -30,10 +30,6 @@ function Broadcast.BroadcastStyle(arraytype::Type{<:UnblockedSubArray})
   return BroadcastStyle(blocktype(parenttype(arraytype)))
 end
 
-function TypeParameterAccessors.similartype(arraytype::Type{<:UnblockedSubArray}, elt::Type)
-  return similartype(blocktype(parenttype(arraytype)), elt)
-end
-
 function Base.similar(
   a::UnblockedSubArray, elt::Type, axes::Tuple{Base.OneTo,Vararg{Base.OneTo}}
 )

src/abstractblocksparsearray/wrappedabstractblocksparsearray.jl

@@ -231,9 +231,9 @@ function Base.similar(
 end
 
 function blocksparse_similar(a, elt::Type, axes::Tuple)
-  return BlockSparseArray{elt,length(axes),similartype(blocktype(a), elt, axes)}(
-    undef, axes
-  )
+  ndims = length(axes)
+  blockt = similartype(blocktype(a), Type{elt}, Tuple{blockaxistype.(axes)...})
+  return BlockSparseArray{elt,ndims,blockt}(undef, axes)
 end
 @interface ::AbstractBlockSparseArrayInterface function Base.similar(
   a::AbstractArray, elt::Type, axes::Tuple{Vararg{Int}}

src/blocksparsearrayinterface/blocksparsearrayinterface.jl

@@ -16,7 +16,8 @@ using BlockArrays:
   blocklength,
   blocks,
   findblockindex
-using DerivableInterfaces: DerivableInterfaces, @interface, DefaultArrayInterface, zero!
+using DerivableInterfaces:
+  DerivableInterfaces, @interface, AbstractArrayInterface, DefaultArrayInterface, zero!
 using LinearAlgebra: Adjoint, Transpose
 using SparseArraysBase:
   AbstractSparseArrayInterface,
@@ -101,14 +102,34 @@ blockstype(a::BlockArray) = blockstype(typeof(a))
 blocktype(arraytype::Type{<:BlockArray}) = eltype(blockstype(arraytype))
 blocktype(a::BlockArray) = eltype(blocks(a))
 
-abstract type AbstractBlockSparseArrayInterface{N} <: AbstractSparseArrayInterface{N} end
+abstract type AbstractBlockSparseArrayInterface{N,B<:AbstractArrayInterface{N}} <:
+              AbstractSparseArrayInterface{N} end
+
+function blockinterface(interface::AbstractBlockSparseArrayInterface{<:Any,B}) where {B}
+  return B()
+end
 
 # TODO: Also support specifying the `blocktype` along with the `eltype`.
-function Base.similar(::AbstractBlockSparseArrayInterface, T::Type, ax::Tuple)
-  return similar(BlockSparseArray{T}, ax)
+function Base.similar(interface::AbstractBlockSparseArrayInterface, T::Type, ax::Tuple)
+  # TODO: Generalize by storing the block interface in the block sparse array interface.
+  N = length(ax)
+  B = similartype(blockinterface(interface), T, Tuple{blockaxistype.(ax)...})
+  return similar(BlockSparseArray{T,N,B}, ax)
 end
 
-struct BlockSparseArrayInterface{N} <: AbstractBlockSparseArrayInterface{N} end
+struct BlockSparseArrayInterface{N,B<:AbstractArrayInterface{N}} <:
+       AbstractBlockSparseArrayInterface{N,B}
+  blockinterface::B
+end
+function BlockSparseArrayInterface{N}(blockinterface::AbstractArrayInterface{N}) where {N}
+  return BlockSparseArrayInterface{N,typeof(blockinterface)}(blockinterface)
+end
+function BlockSparseArrayInterface{M,B}(::Val{N}) where {M,B,N}
+  return BlockSparseArrayInterface{N,B}(blockinterface(B)(Val(N)))
+end
+function BlockSparseArrayInterface{N}() where {N}
+  return BlockSparseArrayInterface{N}(DefaultArrayInterface{N}())
+end
 BlockSparseArrayInterface(::Val{N}) where {N} = BlockSparseArrayInterface{N}()
 BlockSparseArrayInterface{M}(::Val{N}) where {M,N} = BlockSparseArrayInterface{N}()
 BlockSparseArrayInterface() = BlockSparseArrayInterface{Any}()

test/Project.toml

@@ -38,4 +38,4 @@ Suppressor = "0.2"
 TensorAlgebra = "0.3.2"
 Test = "1"
 TestExtras = "0.3"
-TypeParameterAccessors = "0.2, 0.3, 0.4"
+TypeParameterAccessors = "0.4"